things

.eslintignore

+webpack.config.js
+dist/*
+build/*
+*.js
+generated/*

.gitignore

-/.idea
+# compiled output
+/dist
 /node_modules
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# OS
+.DS_Store
+
+# Tests
+/coverage
+/.nyc_output
+
+# IDEs and editors
+/.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+/data
+/output
+/config.yaml

.npmignore

+/install-npm.sh
+.git*
+/data
+/output
+/config.yaml
+.idea
+.dockerignore
+Dockerfile
+/src
+/coverage
+/tests
+/dist/tests

index.d.ts → index.ts

 import moment from "moment";
+import { Socket } from "net";
+import Bunyan from "bunyan";
+import { DuelLog } from "./src/srvpro-entities/DuelLog";
+export {} from "./src/export-global";
 
-interface Client {
-    readonly pos: number;
-    readonly rid: any;
+export interface ToDo {
     [key: string]: any;
 }
 
-declare class Handler {
+export interface YGOProSocket extends Socket, ToDo {
+    had_new_reconnection: boolean;
+}
+
+export interface Client extends YGOProSocket {
+    pos: number;
+    rid: number;
+    abuse_count: number;
+    ban_mc: { banned: boolean; until: string; message: string };
+    rag: boolean;
+    is_post_watcher: boolean;
+    retry_count: number;
+    name: string;
+    pass: string;
+    name_vpass: string;
+    is_first: boolean;
+    lp: number;
+    card_count: number;
+    is_host: boolean;
+    surrend_confirm: boolean;
+    kick_count: number;
+    deck_saved: boolean;
+    main: number[];
+    side: number[];
+    side_interval: number;
+    side_tcount: number;
+    selected_preduel: boolean;
+    last_game_msg: Buffer;
+    last_game_msg_title: string;
+    last_hint_msg: Buffer;
+    start_deckbuf: Buffer;
+    challonge_info: any;
+    ready_trap: boolean;
+    join_time: string;
+    arena_quit_free: boolean;
+    replays_sent: boolean;
+    victory_words: string;
+    server: ServerSocket;
+    playLines(lines: string): void;
+}
+
+export interface ServerSocket extends YGOProSocket {
+    client: Client;
+    system_kicked: boolean;
+}
+
+export declare class Handler {
     private readonly handler: (buffer: Buffer, info: any, datas: Buffer[], params: any) => Promise<boolean>;
     public readonly synchronous: boolean;
 
@@ -14,27 +62,27 @@ declare class Handler {
     handle(buffer: Buffer, info: any, datas: Buffer[], params: any): Promise<boolean> | boolean;
 }
 
-interface HandlerList {
+export interface HandlerList {
     STOC: Map<number, Handler[]>[];
     CTOS: Map<number, Handler[]>[];
 }
 
-interface DirectionAndProto {
+export interface DirectionAndProto {
     direction: string;
     proto: string;
 }
 
-interface Feedback {
+export interface Feedback {
     type: string;
     message: string;
 }
 
-interface HandleResult {
+export interface HandleResult {
     datas: Buffer[];
     feedback: Feedback;
 }
 
-interface Constants {
+export interface Constants {
     TYPES: Record<string, number>;
     RACES: Record<string, number>;
     ATTRIBUTES: Record<string, number>;
@@ -52,7 +100,7 @@ interface Constants {
     MSG: Record<string, string>;
 }
 
-interface YGOProMessagesHelperInstance {
+export interface YGOProMessagesHelperInstance {
     handlers: HandlerList;
     structs: Map<string, any>;
     structs_declaration: Record<string, any>;
@@ -82,47 +130,118 @@ interface YGOProMessagesHelperInstance {
     handleBuffer(messageBuffer: Buffer, direction: string, protoFilter?: string[], params?: any): Promise<HandleResult>;
 }
 
-interface Room {
+export interface WindbotData {
+    name: string;
+    deck: string;
+    dialog: string;
+}
+
+export interface HostInfo {
+    rule: number;
+    mode: number;
+    duel_rule: number;
+    no_check_deck: boolean;
+    no_shuffle_deck: boolean;
+    start_lp: number;
+    start_hand: number;
+    draw_count: number;
+    lflist: number;
+    time_limit: number;
+}
+
+export interface Room {
     duel_stage: number;
     name: string;
-    hostinfo: {
-        rule: number;
-        mode: number;
-        duel_rule: number;
-        no_check_deck: boolean;
-        no_shuffle_deck: boolean;
-        start_lp: number;
-        start_hand: number;
-        draw_count: number;
-        lflist: number;
-        time_limit: number;
-    };
+    hostinfo: HostInfo;
     winner_name: string;
     scores: { [userName: string]: number };
     winnerNames?: string[];
-    dueling_players: Array<{
-        ip: string;
-        name: string;
-        lang: string;
-        pass: string;
-        join_time: moment.Moment;
-        pos: number;
-        main: number[];
-        side: number[];
-    }>;
 
     replays: Array<Buffer>;
 
     arena?: "athletic" | "entertain";
     random_type?: string;
     windbot?: boolean;
+
+    title: string;
+    private: boolean;
+
+    add_windbot(data: WindbotData): void;
+    auto_death_triggered: boolean;
+    cancel_death(): boolean;
+    challonge_info: any;
+    check_athletic(): Promise<void>;
+    cloud_replay_id: number;
+    death: number;
+    decks: Record<string, string>;
+    deprecated: boolean;
+    determine_firstgo: Client;
+    disconnect(client: Client, error: string): void;
+    disconnector: "server" | undefined;
+    duel_count: number;
+    dueling_players: Record<number, Client>;
+    error: string;
+    established: boolean;
+    finished: boolean;
+    finished_by_death: boolean;
+    finish_recover(fail?: boolean);
+    first_list: string[];
+    get_challonge_score(): { winnerId: number | "tie"; scoresCsv: string };
+    get_disconnected_count(): number;
+    get_host(): Client;
+    get_playing_player(): Client[];
+    has_ygopro_error: boolean;
+    initialize_recover(): boolean;
+    join_game_buffer: Buffer;
+    join_player(client: Client): boolean;
+    join_post_watch(client: Client): boolean;
+    kicked: boolean;
+    last_active_time: string;
+    long_resolve_card: number;
+    long_resolve_chain: boolean[] | undefined;
+    match_kill: boolean;
+    max_player: number;
+    player_datas: { name: string; pos: number; key: string }[];
+    players: Client[];
+    watchers: Client[];
+    playLines(lines: string): void;
+    port: number;
+    process_pid: number;
+    ready_player_count: number;
+    ready_player_count_without_host: number;
+    recorder: Socket;
+    recorder_buffers: Buffer[];
+    recover_buffers: Buffer[];
+    recover_duel_log: DuelLog;
+    recover_duel_log_id: number;
+    recovered: boolean;
+    recover_from_turn: number;
+    recovering: boolean;
+    recover_replay: any; // TODO
+    refreshLastActiveTime(): void;
+    replays_sent_to_watchers: boolean;
+    selecting_tp: boolean;
+    send_replays(): boolean;
+    start_death(): boolean;
+    start_time: string;
+    terminate(): void;
+    turn: number;
+    waiting_for_player: Client;
+    waiting_for_player2: Client;
+    waiting_for_player_interval: number;
+    waiting_for_player_time: number;
+    watcher: Socket;
+    watcher_buffers: Buffer[];
+    welcome: string;
+    welcome2: string;
+    winner: number;
 }
 
-type Dictionary<T> = { [key: string]: T };
-type ReloadI18NResult = { regex: RegExp; text: string };
-type FollowHandler = (buffer: Buffer, info: Dictionary<any>, client: Client, server: any, data: Dictionary<any>) => Promise<boolean>;
+export type Dictionary<T> = { [key: string]: T };
+export type ReloadI18NResult = { regex: RegExp; text: string };
+export type FollowHandler = (buffer: Buffer, info: Dictionary<any>, client: Client, server: ServerSocket, data: Buffer[]) => Promise<boolean>;
 
-interface YGOPro {
+export interface YGOPro {
     i18ns: Dictionary<Dictionary<string>>;
     i18nR: Dictionary<Dictionary<string>>;
 
@@ -145,17 +264,30 @@ interface YGOPro {
     stoc_send(socket: any, proto: string, info: Dictionary<any>): any;
     ctos_send(socket: any, proto: string, info: Dictionary<any>): any;
 
-    stoc_send_chat(): void;
-    stoc_send_chat_to_room(): void;
-    stoc_send_hint_card_to_room(): void;
+    stoc_send_chat(client: Client, message: string, color?: number): void;
+    stoc_send_chat_to_room(room: Room, message: string, color?: number): void;
+    stoc_send_hint_card_to_room(room: Room, code: number): void;
 
-    stoc_die(): void;
+    stoc_die(client: Client, message: string): void;
 }
 
-declare const ygopro: YGOPro;
+declare global {
+    export const ygopro: YGOPro;
+
+    export const ROOM_all: Array<Room>;
 
-declare const ROOM_all: Array<Room>;
+    export const lflists: Array<Readonly<{ date: moment.Moment; tcg: boolean }>>;
+    export const log: Bunyan;
 
-declare const lflists: Array<Readonly<{ date: moment.Moment; tcg: boolean }>>;
+    export const import_datas: (keyof Client)[];
 
-declare const log: { warn(message: string): void; info(message: string): void };
+    export function setting_save(settings: { file: string }): Promise<void>;
+
+    export function setting_change(settings: { file: string }, path: string, val: any): Promise<void>;
+    export const auth: any;
+    export const moment_now: moment.Moment;
+    export const moment_now_string: string;
+    export const moment_long_ago_string: string;
+    export const settings: any;
+    export const tips: any;
+}

package.json

@@ -8,6 +8,7 @@
     "license": "MIT",
     "types": "./index.d.ts",
     "devDependencies": {
+        "@types/mustache": "^4.1.2",
         "@types/node": "^17.0.5",
         "@typescript-eslint/eslint-plugin": "^5.0.0",
         "@typescript-eslint/parser": "^5.0.0",
@@ -15,10 +16,13 @@
         "eslint-config-prettier": "^8.3.0",
         "eslint-plugin-import": "^2.25.2",
         "eslint-plugin-prettier": "^4.0.0",
+        "mustache": "^4.2.0",
         "prettier": "^2.4.1",
+        "ts-node": "^10.4.0",
         "typescript": "^4.4.4"
     },
     "dependencies": {
+        "@types/bunyan": "^1.8.8",
         "moment": "^2.29.1"
     }
 }

src/export-global.ts

+export = global;

src/srvpro-entities/DuelLog.ts

+export interface DuelLog {
+    id: number;
+
+    time: Date;
+
+    name: string;
+
+    roomId: number;
+
+    cloudReplayId: number; // not very needed to become a relation
+
+    replayFileName: string;
+
+    roomMode: number;
+
+    duelCount: number;
+
+    players: any[];
+
+    getViewString(): string;
+
+    getViewJSON(tournamentModeSettings: any): any;
+}

tsconfig.json

+{
+	"compilerOptions": {
+		"outDir": "dist",
+		"module": "commonjs",
+		"target": "es2021",
+		"esModuleInterop": true,
+		"emitDecoratorMetadata": true,
+		"experimentalDecorators": true,
+		"declaration": true,
+		"sourceMap": true
+	},
+	"compileOnSave": true,
+	"allowJs": true,
+	"include": [
+		"*.ts",
+		"src/**/*.ts",
+		"test/**/*.ts",
+		"tests/**/*.ts"
+	]
+}