701 lines
23 KiB
TypeScript
701 lines
23 KiB
TypeScript
import {ClientEvents, MusicClientEntry, SongInfo} from "tc-shared/ui/client";
|
|
import {guid} from "tc-shared/crypto/uid";
|
|
import * as React from "react";
|
|
|
|
export interface Event<Events, T = keyof Events> {
|
|
readonly type: T;
|
|
as<T extends keyof Events>() : Events[T];
|
|
}
|
|
|
|
export interface SingletonEvents {
|
|
"singletone-instance": never;
|
|
}
|
|
|
|
export class SingletonEvent implements Event<SingletonEvents, "singletone-instance"> {
|
|
static readonly instance = new SingletonEvent();
|
|
|
|
readonly type = "singletone-instance";
|
|
private constructor() { }
|
|
as<T extends keyof SingletonEvents>() : SingletonEvents[T] { return; }
|
|
}
|
|
|
|
const event_annotation_key = guid();
|
|
export class Registry<Events> {
|
|
private readonly registry_uuid;
|
|
|
|
private handler: {[key: string]: ((event) => void)[]} = {};
|
|
private connections: {[key: string]:Registry<string>[]} = {};
|
|
private event_handler_objects: {
|
|
object: any,
|
|
handlers: {[key: string]: ((event) => void)[]}
|
|
}[] = [];
|
|
private debug_prefix = undefined;
|
|
private warn_unhandled_events = false;
|
|
|
|
constructor() {
|
|
this.registry_uuid = "evreg_data_" + guid();
|
|
}
|
|
|
|
|
|
enable_debug(prefix: string) { this.debug_prefix = prefix || "---"; }
|
|
disable_debug() { this.debug_prefix = undefined; }
|
|
|
|
enable_warn_unhandled_events() { this.warn_unhandled_events = true; }
|
|
disable_warn_unhandled_events() { this.warn_unhandled_events = false; }
|
|
|
|
on<T extends keyof Events>(event: T, handler: (event?: Events[T] & Event<Events, T>) => void);
|
|
on(events: (keyof Events)[], handler: (event?: Event<Events, keyof Events>) => void);
|
|
on(events, handler) {
|
|
if(!Array.isArray(events))
|
|
events = [events];
|
|
|
|
handler[this.registry_uuid] = {
|
|
singleshot: false
|
|
};
|
|
for(const event of events) {
|
|
const handlers = this.handler[event] || (this.handler[event] = []);
|
|
handlers.push(handler);
|
|
}
|
|
}
|
|
|
|
/* one */
|
|
one<T extends keyof Events>(event: T, handler: (event?: Events[T] & Event<Events, T>) => void);
|
|
one(events: (keyof Events)[], handler: (event?: Event<Events, keyof Events>) => void);
|
|
one(events, handler) {
|
|
if(!Array.isArray(events))
|
|
events = [events];
|
|
|
|
for(const event of events) {
|
|
const handlers = this.handler[event] || (this.handler[event] = []);
|
|
|
|
handler[this.registry_uuid] = { singleshot: true };
|
|
handlers.push(handler);
|
|
}
|
|
}
|
|
|
|
off<T extends keyof Events>(handler: (event?) => void);
|
|
off<T extends keyof Events>(event: T, handler: (event?: Events[T] & Event<Events, T>) => void);
|
|
off(event: (keyof Events)[], handler: (event?: Event<Events, keyof Events>) => void);
|
|
off(handler_or_events, handler?) {
|
|
if(typeof handler_or_events === "function") {
|
|
for(const key of Object.keys(this.handler))
|
|
this.handler[key].remove(handler_or_events);
|
|
} else {
|
|
if(!Array.isArray(handler_or_events))
|
|
handler_or_events = [handler_or_events];
|
|
|
|
for(const event of handler_or_events) {
|
|
const handlers = this.handler[event];
|
|
if(handlers) handlers.remove(handler);
|
|
}
|
|
}
|
|
}
|
|
|
|
connect<EOther, T extends keyof Events & keyof EOther>(events: T | T[], target: Registry<EOther>) {
|
|
for(const event of Array.isArray(events) ? events : [events])
|
|
(this.connections[event as string] || (this.connections[event as string] = [])).push(target as any);
|
|
}
|
|
|
|
disconnect<EOther, T extends keyof Events & keyof EOther>(events: T | T[], target: Registry<EOther>) {
|
|
for(const event of Array.isArray(events) ? events : [events])
|
|
(this.connections[event as string] || []).remove(target as any);
|
|
}
|
|
|
|
disconnect_all<EOther>(target: Registry<EOther>) {
|
|
for(const event of Object.keys(this.connections))
|
|
this.connections[event].remove(target as any);
|
|
}
|
|
|
|
fire<T extends keyof Events>(event_type: T, data?: Events[T], overrideTypeKey?: boolean) {
|
|
if(this.debug_prefix) console.log("[%s] Trigger event: %s", this.debug_prefix, event_type);
|
|
|
|
if(typeof data === "object" && 'type' in data && !overrideTypeKey) {
|
|
if((data as any).type !== event_type) {
|
|
debugger;
|
|
throw tr("The keyword 'type' is reserved for the event type and should not be passed as argument");
|
|
}
|
|
}
|
|
const event = Object.assign(typeof data === "undefined" ? SingletonEvent.instance : data, {
|
|
type: event_type,
|
|
as: function () { return this; }
|
|
});
|
|
|
|
this.fire_event(event_type as string, event);
|
|
}
|
|
|
|
private fire_event(type: string, data: any) {
|
|
let invoke_count = 0;
|
|
for(const handler of (this.handler[type]?.slice(0) || [])) {
|
|
handler(data);
|
|
invoke_count++;
|
|
|
|
const reg_data = handler[this.registry_uuid];
|
|
if(typeof reg_data === "object" && reg_data.singleshot)
|
|
this.handler[type].remove(handler);
|
|
}
|
|
|
|
for(const evhandler of (this.connections[type]?.slice(0) || [])) {
|
|
evhandler.fire_event(type, data);
|
|
invoke_count++;
|
|
}
|
|
if(this.warn_unhandled_events && invoke_count === 0) {
|
|
console.warn(tr("Event handler (%s) triggered event %s which has no consumers."), this.debug_prefix, type);
|
|
}
|
|
}
|
|
|
|
fire_async<T extends keyof Events>(event_type: T, data?: Events[T], callback?: () => void) {
|
|
setTimeout(() => {
|
|
this.fire(event_type, data);
|
|
if(typeof callback === "function")
|
|
callback();
|
|
});
|
|
}
|
|
|
|
destroy() {
|
|
this.handler = {};
|
|
this.connections = {};
|
|
this.event_handler_objects = [];
|
|
}
|
|
|
|
register_handler(handler: any) {
|
|
if(typeof handler !== "object")
|
|
throw "event handler must be an object";
|
|
const proto = Object.getPrototypeOf(handler);
|
|
if(typeof proto !== "object")
|
|
throw "event handler must have a prototype";
|
|
|
|
let registered_events = {};
|
|
for(const function_name of Object.getOwnPropertyNames(proto)) {
|
|
if(function_name === "constructor") continue;
|
|
if(typeof proto[function_name] !== "function") continue;
|
|
if(typeof proto[function_name][event_annotation_key] !== "object") continue;
|
|
|
|
const event_data = proto[function_name][event_annotation_key];
|
|
const ev_handler = event => proto[function_name].call(handler, event);
|
|
for(const event of event_data.events) {
|
|
registered_events[event] = registered_events[event] || [];
|
|
registered_events[event].push(ev_handler);
|
|
this.on(event, ev_handler);
|
|
}
|
|
}
|
|
if(Object.keys(registered_events).length === 0)
|
|
throw "no events found in event handler";
|
|
|
|
this.event_handler_objects.push({
|
|
handlers: registered_events,
|
|
object: handler
|
|
});
|
|
}
|
|
|
|
unregister_handler(handler: any) {
|
|
const data = this.event_handler_objects.find(e => e.object === handler);
|
|
if(!data) throw "unknown event handler";
|
|
this.event_handler_objects.remove(data);
|
|
|
|
for(const key of Object.keys(data.handlers)) {
|
|
for(const evhandler of data.handlers[key])
|
|
this.off(evhandler);
|
|
}
|
|
}
|
|
}
|
|
|
|
export function EventHandler<EventTypes>(events: (keyof EventTypes) | (keyof EventTypes)[]) {
|
|
return function (target: any,
|
|
propertyKey: string,
|
|
descriptor: PropertyDescriptor) {
|
|
if(typeof target[propertyKey] !== "function")
|
|
throw "Invalid event handler annotation. Expected to be on a function type.";
|
|
|
|
target[propertyKey][event_annotation_key] = {
|
|
events: Array.isArray(events) ? events : [events]
|
|
};
|
|
}
|
|
}
|
|
|
|
export function ReactEventHandler<ObjectClass = React.Component<any, any>, EventTypes = any>(registry_callback: (object: ObjectClass) => Registry<EventTypes>) {
|
|
return function (constructor: Function) {
|
|
if(!React.Component.prototype.isPrototypeOf(constructor.prototype))
|
|
throw "Class/object isn't an instance of React.Component";
|
|
|
|
const didMount = constructor.prototype.componentDidMount;
|
|
constructor.prototype.componentDidMount = function() {
|
|
const registry = registry_callback(this);
|
|
if(!registry) throw "Event registry returned for an event object is invalid";
|
|
registry.register_handler(this);
|
|
|
|
if(typeof didMount === "function")
|
|
didMount.call(this, arguments);
|
|
};
|
|
|
|
const willUnmount = constructor.prototype.componentWillUnmount;
|
|
constructor.prototype.componentWillUnmount = function () {
|
|
const registry = registry_callback(this);
|
|
if(!registry) throw "Event registry returned for an event object is invalid";
|
|
try {
|
|
registry.unregister_handler(this);
|
|
} catch (error) {
|
|
console.warn("Failed to unregister event handler: %o", error);
|
|
}
|
|
|
|
if(typeof willUnmount === "function")
|
|
willUnmount.call(this, arguments);
|
|
};
|
|
}
|
|
}
|
|
|
|
export namespace sidebar {
|
|
export interface music {
|
|
"open": {}, /* triggers when frame should be shown */
|
|
"close": {}, /* triggers when frame will be closed */
|
|
|
|
"bot_change": {
|
|
old: MusicClientEntry | undefined,
|
|
new: MusicClientEntry | undefined
|
|
},
|
|
"bot_property_update": {
|
|
properties: string[]
|
|
},
|
|
|
|
"action_play": {},
|
|
"action_pause": {},
|
|
"action_song_set": { song_id: number },
|
|
"action_forward": {},
|
|
"action_rewind": {},
|
|
"action_forward_ms": {
|
|
units: number;
|
|
},
|
|
"action_rewind_ms": {
|
|
units: number;
|
|
},
|
|
"action_song_add": {},
|
|
"action_song_delete": { song_id: number },
|
|
"action_playlist_reload": {},
|
|
|
|
"playtime_move_begin": {},
|
|
"playtime_move_end": {
|
|
canceled: boolean,
|
|
target_time?: number
|
|
},
|
|
|
|
"reorder_begin": { song_id: number; entry: JQuery },
|
|
"reorder_end": { song_id: number; canceled: boolean; entry: JQuery; previous_entry?: number },
|
|
|
|
"player_time_update": ClientEvents["music_status_update"],
|
|
"player_song_change": ClientEvents["music_song_change"],
|
|
|
|
"playlist_song_add": ClientEvents["playlist_song_add"] & { insert_effect?: boolean },
|
|
"playlist_song_remove": ClientEvents["playlist_song_remove"],
|
|
"playlist_song_reorder": ClientEvents["playlist_song_reorder"],
|
|
"playlist_song_loaded": ClientEvents["playlist_song_loaded"] & { html_entry?: JQuery },
|
|
}
|
|
}
|
|
|
|
export namespace modal {
|
|
export type BotStatusType = "name" | "description" | "volume" | "country_code" | "channel_commander" | "priority_speaker";
|
|
export type PlaylistStatusType = "replay_mode" | "finished" | "delete_played" | "max_size" | "notify_song_change";
|
|
export interface music_manage {
|
|
show_container: { container: "settings" | "permissions"; };
|
|
|
|
/* setting relevant */
|
|
query_bot_status: {},
|
|
bot_status: {
|
|
status: "success" | "error";
|
|
error_msg?: string;
|
|
data?: {
|
|
name: string,
|
|
description: string,
|
|
volume: number,
|
|
|
|
country_code: string,
|
|
default_country_code: string,
|
|
|
|
channel_commander: boolean,
|
|
priority_speaker: boolean,
|
|
|
|
client_version: string,
|
|
client_platform: string,
|
|
|
|
uptime_mode: number,
|
|
bot_type: number
|
|
}
|
|
},
|
|
set_bot_status: {
|
|
key: BotStatusType,
|
|
value: any
|
|
},
|
|
set_bot_status_result: {
|
|
key: BotStatusType,
|
|
status: "success" | "error" | "timeout",
|
|
error_msg?: string,
|
|
value?: any
|
|
}
|
|
|
|
query_playlist_status: {},
|
|
playlist_status: {
|
|
status: "success" | "error",
|
|
error_msg?: string,
|
|
data?: {
|
|
replay_mode: number,
|
|
finished: boolean,
|
|
delete_played: boolean,
|
|
max_size: number,
|
|
notify_song_change: boolean
|
|
}
|
|
},
|
|
set_playlist_status: {
|
|
key: PlaylistStatusType,
|
|
value: any
|
|
},
|
|
set_playlist_status_result: {
|
|
key: PlaylistStatusType,
|
|
status: "success" | "error" | "timeout",
|
|
error_msg?: string,
|
|
value?: any
|
|
}
|
|
|
|
/* permission relevant */
|
|
show_client_list: {},
|
|
hide_client_list: {},
|
|
|
|
filter_client_list: { filter: string | undefined },
|
|
|
|
"refresh_permissions": {},
|
|
|
|
query_special_clients: {},
|
|
special_client_list: {
|
|
status: "success" | "error" | "error-permission",
|
|
error_msg?: string,
|
|
clients?: {
|
|
name: string,
|
|
unique_id: string,
|
|
database_id: number
|
|
}[]
|
|
},
|
|
|
|
search_client: { text: string },
|
|
search_client_result: {
|
|
status: "error" | "timeout" | "empty" | "success",
|
|
error_msg?: string,
|
|
client?: {
|
|
name: string,
|
|
unique_id: string,
|
|
database_id: number
|
|
}
|
|
},
|
|
|
|
/* sets a client to set the permission for */
|
|
special_client_set: {
|
|
client?: {
|
|
name: string,
|
|
unique_id: string,
|
|
database_id: number
|
|
}
|
|
},
|
|
|
|
"query_general_permissions": {},
|
|
"general_permissions": {
|
|
status: "error" | "timeout" | "success",
|
|
error_msg?: string,
|
|
permissions?: {[key: string]:number}
|
|
},
|
|
"set_general_permission_result": {
|
|
status: "error" | "success",
|
|
key: string,
|
|
value?: number,
|
|
error_msg?: string
|
|
},
|
|
"set_general_permission": { /* try to change a permission for the server */
|
|
key: string,
|
|
value: number
|
|
},
|
|
|
|
|
|
"query_client_permissions": { client_database_id: number },
|
|
"client_permissions": {
|
|
status: "error" | "timeout" | "success",
|
|
client_database_id: number,
|
|
error_msg?: string,
|
|
permissions?: {[key: string]:number}
|
|
},
|
|
"set_client_permission_result": {
|
|
status: "error" | "success",
|
|
client_database_id: number,
|
|
key: string,
|
|
value?: number,
|
|
error_msg?: string
|
|
},
|
|
"set_client_permission": { /* try to change a permission for the server */
|
|
client_database_id: number,
|
|
key: string,
|
|
value: number
|
|
},
|
|
|
|
"query_group_permissions": { permission_name: string },
|
|
"group_permissions": {
|
|
permission_name: string;
|
|
status: "error" | "timeout" | "success"
|
|
groups?: {
|
|
name: string,
|
|
value: number,
|
|
id: number
|
|
}[],
|
|
error_msg?: string
|
|
}
|
|
}
|
|
|
|
export interface newcomer {
|
|
"show_step": {
|
|
"step": "welcome" | "microphone" | "identity" | "finish"
|
|
},
|
|
"exit_guide": {
|
|
ask_yesno: boolean
|
|
},
|
|
|
|
"modal-shown": {},
|
|
|
|
|
|
"step-status": {
|
|
next_button: boolean,
|
|
previous_button: boolean
|
|
}
|
|
}
|
|
|
|
export namespace settings {
|
|
export type ProfileInfo = {
|
|
id: string,
|
|
name: string,
|
|
nickname: string,
|
|
identity_type: "teaforo" | "teamspeak" | "nickname",
|
|
|
|
identity_forum?: {
|
|
valid: boolean,
|
|
fallback_name: string
|
|
},
|
|
identity_nickname?: {
|
|
name: string,
|
|
fallback_name: string
|
|
},
|
|
identity_teamspeak?: {
|
|
unique_id: string,
|
|
fallback_name: string
|
|
}
|
|
}
|
|
|
|
export interface profiles {
|
|
"reload-profile": { profile_id?: string },
|
|
"select-profile": { profile_id: string },
|
|
|
|
"query-profile-list": { },
|
|
"query-profile-list-result": {
|
|
status: "error" | "success" | "timeout",
|
|
|
|
error?: string;
|
|
profiles?: ProfileInfo[]
|
|
}
|
|
|
|
"query-profile": { profile_id: string },
|
|
"query-profile-result": {
|
|
status: "error" | "success" | "timeout",
|
|
profile_id: string,
|
|
|
|
error?: string;
|
|
info?: ProfileInfo
|
|
},
|
|
|
|
"select-identity-type": {
|
|
profile_id: string,
|
|
identity_type: "teamspeak" | "teaforo" | "nickname" | "unset"
|
|
},
|
|
|
|
"query-profile-validity": { profile_id: string },
|
|
"query-profile-validity-result": {
|
|
profile_id: string,
|
|
status: "error" | "success" | "timeout",
|
|
|
|
error?: string,
|
|
valid?: boolean
|
|
}
|
|
|
|
"create-profile": { name: string },
|
|
"create-profile-result": {
|
|
status: "error" | "success" | "timeout",
|
|
name: string;
|
|
|
|
profile_id?: string;
|
|
error?: string;
|
|
},
|
|
|
|
"delete-profile": { profile_id: string },
|
|
"delete-profile-result": {
|
|
status: "error" | "success" | "timeout",
|
|
profile_id: string,
|
|
error?: string
|
|
}
|
|
|
|
"set-default-profile": { profile_id: string },
|
|
"set-default-profile-result": {
|
|
status: "error" | "success" | "timeout",
|
|
|
|
/* the profile which now has the id "default" */
|
|
old_profile_id: string,
|
|
|
|
/* the "default" profile which now has a new id */
|
|
new_profile_id?: string
|
|
|
|
error?: string;
|
|
}
|
|
|
|
/* profile name events */
|
|
"set-profile-name": {
|
|
profile_id: string,
|
|
name: string
|
|
},
|
|
"set-profile-name-result": {
|
|
status: "error" | "success" | "timeout",
|
|
profile_id: string,
|
|
name?: string
|
|
},
|
|
|
|
/* profile nickname events */
|
|
"set-default-name": {
|
|
profile_id: string,
|
|
name: string | null
|
|
},
|
|
"set-default-name-result": {
|
|
status: "error" | "success" | "timeout",
|
|
profile_id: string,
|
|
name?: string | null
|
|
},
|
|
|
|
"query-identity-teamspeak": { profile_id: string },
|
|
"query-identity-teamspeak-result": {
|
|
status: "error" | "success" | "timeout",
|
|
profile_id: string,
|
|
|
|
error?: string,
|
|
level?: number
|
|
}
|
|
|
|
"set-identity-name-name": { profile_id: string, name: string },
|
|
"set-identity-name-name-result": {
|
|
status: "error" | "success" | "timeout",
|
|
profile_id: string,
|
|
|
|
error?: string,
|
|
name?: string
|
|
},
|
|
|
|
"generate-identity-teamspeak": { profile_id: string },
|
|
"generate-identity-teamspeak-result": {
|
|
profile_id: string,
|
|
status: "error" | "success" | "timeout",
|
|
|
|
error?: string,
|
|
|
|
level?: number
|
|
unique_id?: string
|
|
},
|
|
|
|
"improve-identity-teamspeak-level": { profile_id: string },
|
|
"improve-identity-teamspeak-level-update": {
|
|
profile_id: string,
|
|
new_level: number
|
|
},
|
|
|
|
"import-identity-teamspeak": { profile_id: string },
|
|
"import-identity-teamspeak-result": {
|
|
profile_id: string,
|
|
|
|
level?: number
|
|
unique_id?: string
|
|
}
|
|
|
|
"export-identity-teamspeak": {
|
|
profile_id: string,
|
|
filename: string
|
|
},
|
|
|
|
|
|
"setup-forum-connection": {}
|
|
}
|
|
|
|
export type MicrophoneSettings = "volume" | "vad-type" | "ppt-key" | "ppt-release-delay" | "ppt-release-delay-active" | "threshold-threshold";
|
|
export interface microphone {
|
|
"query-devices": { refresh_list: boolean },
|
|
"query-device-result": {
|
|
status: "success" | "error" | "timeout",
|
|
|
|
error?: string,
|
|
devices?: {
|
|
id: string,
|
|
name: string,
|
|
driver: string
|
|
}[]
|
|
active_device?: string;
|
|
},
|
|
|
|
"query-settings": {},
|
|
"query-settings-result": {
|
|
status: "success" | "error" | "timeout",
|
|
|
|
error?: string,
|
|
info?: {
|
|
volume: number,
|
|
vad_type: string,
|
|
|
|
vad_ppt: {
|
|
key: any, /* ppt.KeyDescriptor */
|
|
release_delay: number,
|
|
release_delay_active: boolean
|
|
},
|
|
vad_threshold: {
|
|
threshold: number
|
|
}
|
|
}
|
|
},
|
|
|
|
"set-device": { device_id: string },
|
|
"set-device-result": {
|
|
device_id: string,
|
|
status: "success" | "error" | "timeout",
|
|
|
|
error?: string
|
|
},
|
|
|
|
"set-setting": {
|
|
setting: MicrophoneSettings;
|
|
value: any;
|
|
},
|
|
"set-setting-result": {
|
|
setting: MicrophoneSettings,
|
|
status: "success" | "error" | "timeout",
|
|
|
|
error?: string,
|
|
value?: any
|
|
},
|
|
|
|
"update-device-level": {
|
|
devices: {
|
|
device_id: string,
|
|
status: "success" | "error",
|
|
|
|
level?: number,
|
|
error?: string
|
|
}[]
|
|
},
|
|
|
|
"audio-initialized": {},
|
|
"deinitialize": {}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Some test code
|
|
/*
|
|
const eclient = new Registry<ClientEvents>();
|
|
const emusic = new Registry<sidebar.music>();
|
|
|
|
eclient.on("property_update", event => { event.as<"playlist_song_loaded">(); });
|
|
eclient.connect("playlist_song_loaded", emusic);
|
|
eclient.connect("playlist_song_loaded", emusic);
|
|
*/ |