bc-deeplib 1.0.5 → 1.1.0

package/dist/deeplib.d.ts

@@ -0,0 +1,538 @@
+declare module 'bc-deeplib/base/base_module' {
+  import { BaseSettingsModel, Subscreen } from 'bc-deeplib/deeplib';
+  export abstract class BaseModule {
+      get settingsScreen(): Subscreen | null;
+      get settingsStorage(): string | null;
+      get settings(): BaseSettingsModel;
+      set settings(value: BaseSettingsModel);
+      init(): void;
+      registerDefaultSettings(): void;
+      get defaultSettings(): BaseSettingsModel | null;
+      load(): void;
+      run(): void;
+      unload(): void;
+  }
+
+}
+declare module 'bc-deeplib/base/base_subscreen' {
+  import { BaseModule, BaseSettingsModel } from 'bc-deeplib/deeplib';
+  import { SettingElement } from 'bc-deeplib/base/elements_typings';
+  type SubscreenOptions = {
+      drawCharacter?: boolean;
+  };
+  export type Subscreen = new (subscreenOptions?: SubscreenOptions, module?: BaseModule) => BaseSubscreen;
+  export function getCurrentSubscreen(): BaseSubscreen | null;
+  export function setSubscreen(subscreen: BaseSubscreen | string | null): BaseSubscreen | null;
+  export abstract class BaseSubscreen {
+      static currentElements: [HTMLElement, SettingElement][];
+      static currentPage: number;
+      readonly options: SubscreenOptions;
+      readonly module: BaseModule;
+      constructor(subscreenOptions?: SubscreenOptions, module?: BaseModule);
+      get name(): string;
+      get icon(): string;
+      get subscreenName(): string;
+      setSubscreen(screen: BaseSubscreen | string | null): BaseSubscreen | null;
+      get settings(): BaseSettingsModel;
+      set settings(value: BaseSettingsModel);
+      get pageStructure(): SettingElement[][];
+      get currentPage(): SettingElement[];
+      changePage(page: number, setLabel: (label: string) => void): void;
+      managePageElementsVisibility(): void;
+      load(): void;
+      run(): void;
+      click(): void;
+      exit(): void;
+      resize(onLoad?: boolean): void;
+      unload(): void;
+  }
+  export {};
+
+}
+declare module 'bc-deeplib/base/elements_typings' {
+  export type SettingElement = Button | Checkbox | Input | Label | Custom;
+  export type BaseElementModel = {
+      id: string;
+      size?: [width: number | null, height: number | null] | (() => [width: number | null, height: number | null]);
+      position?: [x: number, y: number] | (() => [x: number, y: number]);
+      disabled?: boolean | (() => boolean);
+  };
+  type CustomButtonOptions = {
+      id?: Parameters<typeof ElementButton.Create>[0];
+      onClick?: Parameters<typeof ElementButton.Create>[1];
+      options?: Parameters<typeof ElementButton.Create>[2];
+      htmlOptions?: Parameters<typeof ElementButton.Create>[3];
+  };
+  export type Button = BaseElementModel & {
+      type: 'button';
+      image?: string;
+      label?: string;
+      tooltip?: string;
+      onClick?: () => void;
+      htmlOptions?: CustomButtonOptions;
+  };
+  export type Checkbox = BaseElementModel & {
+      type: 'checkbox';
+      label?: string;
+      description?: string;
+      setElementValue?: () => boolean;
+      setSettingValue?: (val: boolean) => void;
+      htmlOptions?: Omit<HTMLOptions<any>, 'tag'>;
+  };
+  export type Input = BaseElementModel & {
+      type: 'text' | 'number' | 'color';
+      label?: string;
+      description?: string;
+      setElementValue?: () => string;
+      setSettingValue?: (val: string) => void;
+      htmlOptions?: Omit<HTMLOptions<any>, 'tag'>;
+  };
+  export type Label = BaseElementModel & {
+      type: 'label';
+      label?: string;
+      description?: string;
+      htmlOptions?: Omit<HTMLOptions<any>, 'tag'>;
+  };
+  export type Custom = BaseElementModel & {
+      type: 'custom';
+      htmlOptions: HTMLOptions<keyof HTMLElementTagNameMap>;
+  };
+  export {};
+
+}
+declare module 'bc-deeplib/base/initialization' {
+  import { BaseModule, ModSdkManager, BaseMigrator, ModStorage, MainMenuOptions } from 'bc-deeplib/deeplib';
+  interface InitOptions {
+      modInfo: {
+          info: ModSDKModInfo;
+          options?: ModSDKModOptions;
+      };
+      modules?: BaseModule[];
+      migrators?: BaseMigrator[];
+      mainMenuOptions?: MainMenuOptions;
+      beforeLogin?: () => (void);
+      initFunction?: () => (void | Promise<void>);
+      pathToTranslationsFolder?: string;
+  }
+  export let modStorage: ModStorage;
+  export function initMod(options: InitOptions): {
+      sdk: ModSdkManager;
+  };
+  export function init(options: InitOptions): Promise<void>;
+  export function unloadMod(): true;
+  export {};
+
+}
+declare module 'bc-deeplib/base/modules' {
+  import { BaseModule } from 'bc-deeplib/deeplib';
+  export const modulesMap: Map<string, BaseModule>;
+  export function modules(): BaseModule[];
+  export function registerModule<T extends BaseModule>(module: T): T;
+  export function getModule<T extends BaseModule>(moduleType: string): T;
+
+}
+declare module 'bc-deeplib/deeplib' {
+  export * from 'bc-deeplib/base/base_module';
+  export * from 'bc-deeplib/base/base_subscreen';
+  export * from 'bc-deeplib/base/initialization';
+  export * from 'bc-deeplib/base/modules';
+  export * from 'bc-deeplib/migrators/base_migrator';
+  export * from 'bc-deeplib/models/base';
+  export * from 'bc-deeplib/models/settings';
+  export * from 'bc-deeplib/modules/gui';
+  export * from 'bc-deeplib/modules/version';
+  export * from 'bc-deeplib/screens/debug';
+  export * from 'bc-deeplib/screens/main_menu';
+  export * from 'bc-deeplib/screens/import_export';
+  export * from 'bc-deeplib/utilities/data';
+  export * from 'bc-deeplib/utilities/elements/advanced_elements';
+  export * from 'bc-deeplib/utilities/elements/element_helpers';
+  export * from 'bc-deeplib/utilities/elements/layout_elements';
+  export * from 'bc-deeplib/utilities/common';
+  export * from 'bc-deeplib/utilities/logger';
+  export * from 'bc-deeplib/utilities/messages';
+  export * from 'bc-deeplib/utilities/sdk';
+  export * from 'bc-deeplib/utilities/style';
+  export * from 'bc-deeplib/utilities/translation';
+
+}
+declare module 'bc-deeplib/migrators/base_migrator' {
+  export abstract class BaseMigrator {
+      abstract get MigrationVersion(): string;
+      abstract Migrate(): boolean;
+  }
+
+}
+declare module 'bc-deeplib/models/base' {
+  export type BaseSettingsModel = {
+      modEnabled: boolean;
+      doShowNewVersionMessage: boolean;
+  };
+
+}
+declare module 'bc-deeplib/models/settings' {
+  import { BaseSettingsModel } from 'bc-deeplib/deeplib';
+  export type SettingsModel = {
+      [x: string]: any;
+      GlobalModule: BaseSettingsModel;
+      Version: string;
+  };
+
+}
+declare module 'bc-deeplib/modules/gui' {
+  import { BaseModule, BaseSubscreen, MainMenu } from 'bc-deeplib/deeplib';
+  type ModButtonOptions = {
+      Identifier: string;
+      ButtonText: string | (() => string);
+      Image: string | (() => string);
+      load?: () => void;
+      click?: () => void;
+      run?: () => void;
+      unload?: () => void;
+      exit?: () => boolean | void;
+  };
+  export class GUI extends BaseModule {
+      static instance: GUI | null;
+      private _subscreens;
+      private _mainMenu;
+      private _currentSubscreen;
+      private _modButtonOptions;
+      get subscreens(): BaseSubscreen[];
+      get mainMenu(): MainMenu;
+      get currentSubscreen(): BaseSubscreen | null;
+      set currentSubscreen(subscreen: BaseSubscreen | string | null);
+      constructor(modButtonOptions: ModButtonOptions);
+      get defaultSettings(): null;
+      load(): void;
+  }
+  export {};
+
+}
+declare module 'bc-deeplib/modules/version' {
+  import { BaseMigrator, BaseModule } from 'bc-deeplib/deeplib';
+  export class VersionModule extends BaseModule {
+      private static isItNewVersion;
+      static Version: string;
+      static NewVersionMessage: string;
+      private static Migrators;
+      load(): void;
+      static checkVersionUpdate(): void;
+      private static checkVersionMigration;
+      static registerMigrator(migrator: BaseMigrator): void;
+      static setNewVersionMessage(newVersionMessage: string): void;
+      static sendNewVersionMessage(): void;
+      private static isNewVersion;
+      private static saveVersion;
+      private static loadVersion;
+  }
+
+}
+declare module 'bc-deeplib/screens/debug' {
+  import { SettingElement } from 'bc-deeplib/base/elements_typings';
+  import { BaseSubscreen } from 'bc-deeplib/deeplib';
+  export class GuiDebug extends BaseSubscreen {
+      get name(): string;
+      get pageStructure(): SettingElement[][];
+  }
+
+}
+declare module 'bc-deeplib/screens/import_export' {
+  import { BaseSubscreen } from 'bc-deeplib/deeplib';
+  export type ImportExportOptions = {
+      customFileExtension: string;
+      onImport?: () => void;
+      onExport?: () => void;
+  };
+  type DataTransferMethod = 'clipboard' | 'file';
+  export class GuiImportExport extends BaseSubscreen {
+      private importExportOptions;
+      get name(): string;
+      constructor(importExportOptions: ImportExportOptions);
+      load(): void;
+      resize(): void;
+      dataExport(transferMethod: DataTransferMethod): Promise<void>;
+      dataImport(transferMethod: DataTransferMethod): Promise<void>;
+      exportToFile(data: string, defaultFileName: string): Promise<void>;
+      importFromFile(): Promise<string | null>;
+      exportToClipboard(data: string): Promise<void>;
+      importFromClipboard(): Promise<string | null>;
+  }
+  export {};
+
+}
+declare module 'bc-deeplib/screens/main_menu' {
+  import { BaseSubscreen, GUI } from 'bc-deeplib/deeplib';
+  import { GuiImportExport } from 'bc-deeplib/screens/import_export';
+  export type MainMenuOptions = {
+      repoLink?: string;
+      wikiLink?: string;
+      resetSubscreen?: BaseSubscreen;
+      importExportSubscreen?: GuiImportExport;
+  };
+  export class MainMenu extends BaseSubscreen {
+      subscreens: BaseSubscreen[];
+      private static options;
+      get name(): string;
+      constructor(module: GUI);
+      load(): void;
+      run(): void;
+      click(): void;
+      exit(): void;
+      resize(): void;
+      static setOptions(mainMenuOptions: MainMenuOptions): void;
+  }
+
+}
+declare module 'bc-deeplib/utilities/common' {
+  export function deepMerge(target: any, source: any): any;
+  export function shuffleArray(array: string[]): string[];
+  export function exportToGlobal(name: string, value: any): void;
+  export function deepMergeMatchingProperties<T extends object>(mergeTo: T, mergeFrom: T): T;
+  export function hasGetter<T extends object>(obj: T, prop: keyof T | string): boolean;
+  export function hasSetter<T extends object>(obj: T, prop: keyof T | string): boolean;
+
+}
+declare module 'bc-deeplib/utilities/data' {
+  import { SettingsModel } from 'bc-deeplib/deeplib';
+  export class ModStorage<T extends SettingsModel = SettingsModel> {
+      private static _instance;
+      private modName;
+      constructor(modName: string);
+      get playerStorage(): T;
+      set playerStorage(value: T);
+      get extensionStorage(): string;
+      set extensionStorage(value: string);
+      setLocalStorage(key: string, value: object): void;
+      getLocalStorage(key: string): object | null;
+      load(): void;
+      save(): void;
+      static dataDecompress<T = object>(string: string): T | null;
+      static dataCompress(object: object): string;
+  }
+
+}
+declare module 'bc-deeplib/utilities/elements/advanced_elements' {
+  import { Button, Checkbox, Custom, Input, Label } from 'bc-deeplib/base/elements_typings';
+  export const advancedElement: {
+      createButton: typeof elementCreateButton;
+      createCheckbox: typeof elementCreateCheckbox;
+      createInput: typeof elementCreateInput;
+      createLabel: typeof elementCreateLabel;
+      createCustom: typeof elementCreateCustom;
+      createTooltip: typeof elementCreateTooltip;
+      getTooltip: typeof elementGetTooltip;
+      setTooltip: typeof elementSetTooltip;
+      createBackNext: typeof elementPrevNext;
+  };
+  function elementCreateButton(options: Omit<Button, 'type'>): HTMLButtonElement;
+  function elementCreateCheckbox(options: Omit<Checkbox, 'type'>): HTMLElement;
+  function elementCreateCustom(options: Omit<Custom, 'type'>): HTMLElement;
+  function elementCreateInput(options: Input): HTMLElement;
+  function elementCreateLabel(options: Omit<Label, 'type'>): HTMLElement;
+  function elementCreateTooltip(): HTMLDivElement;
+  function elementGetTooltip(): HTMLElement | undefined;
+  function elementSetTooltip(text: string): boolean;
+  interface PrevNext {
+      id: string;
+      initialLabel?: string;
+      back: (arg0: PrevNextCallbacks) => void;
+      initialPrevTooltip?: string;
+      next: (arg0: PrevNextCallbacks) => void;
+      initialNextTooltip?: string;
+  }
+  interface PrevNextCallbacks {
+      setLabel: (label: string) => void;
+      setBackTooltip: (tooltip: string) => void;
+      setNextTooltip: (tooltip: string) => void;
+  }
+  function elementPrevNext(options: PrevNext): HTMLElement;
+  export type ModalButton<T extends string = string> = {
+      text: string;
+      action: T;
+      disabled?: boolean;
+  };
+  export type ModalInputOptions = {
+      defaultValue?: string;
+      readOnly?: boolean;
+      placeholder?: string;
+      type: 'input' | 'textarea';
+      validate?: (value: string) => string | null;
+  };
+  export type ModalOptions<T extends string = string> = {
+      prompt: string | Node;
+      input?: ModalInputOptions;
+      buttons?: ModalButton<T>[];
+      custom?: readonly (string | Node | HTMLOptions<keyof HTMLElementTagNameMap> | null | undefined)[] | undefined;
+      closeOnBackdrop?: boolean;
+      timeoutMs?: number;
+  };
+  export class Modal<T extends string = string> {
+      private opts;
+      private dialog;
+      private blocker;
+      private inputEl?;
+      private timeoutId?;
+      private static queue;
+      private static processing;
+      constructor(opts: ModalOptions<T>);
+      show(): Promise<[T, string | null]>;
+      static alert(msg: string, timeoutMs?: number): Promise<void>;
+      static confirm(msg: string): Promise<boolean>;
+      static prompt(msg: string, defaultValue?: string): Promise<string | null>;
+      private renderInput;
+      private renderButtons;
+      private createBlocker;
+      private setupFocusTrap;
+      private close;
+      private resolve;
+      private static enqueue;
+      private static dequeue;
+  }
+  export {};
+
+}
+declare module 'bc-deeplib/utilities/elements/element_helpers' {
+  import { SettingElement } from 'bc-deeplib/base/elements_typings';
+  export const domUtil: {
+      autoSetPosition: typeof autoSetPosition;
+      autoSetSize: typeof autoSetSize;
+      hide: typeof hide;
+      unhide: typeof unhide;
+      hasOverflow: typeof hasOverflow;
+  };
+  function autoSetPosition(_: ElementHelp.ElementOrId, position: SettingElement['position']): void;
+  function autoSetSize(_: ElementHelp.ElementOrId, size: SettingElement['size']): void;
+  function hide(_: ElementHelp.ElementOrId): void;
+  function unhide(_: ElementHelp.ElementOrId): void;
+  function hasOverflow(el: ElementHelp.ElementOrId): {
+      any: boolean;
+      vertical: boolean;
+      horizontal: boolean;
+  } | null;
+  export {};
+
+}
+declare module 'bc-deeplib/utilities/elements/layout_elements' {
+  export const layoutElement: {
+      createSubscreenDiv: typeof elementCreateSubscreenDiv;
+      getSubscreenDiv: typeof elementGetSubscreenDiv;
+      appendToSubscreenDiv: typeof elementAppendToSubscreenDiv;
+      removeSubscreenDiv: typeof elementRemoveSubscreenDiv;
+      createSettingsDiv: typeof elementCreateSettingsDiv;
+      getSettingsDiv: typeof elementGetSettingsDiv;
+      appendToSettingsDiv: typeof elementAppendToSettingsDiv;
+      removeSettingsDiv: typeof elementRemoveSettingsDiv;
+      createMiscDiv: typeof elementCreateMiscDiv;
+      getMiscDiv: typeof elementGetMiscDiv;
+      appendToMiscDiv: typeof elementAppendToMiscDiv;
+      removeMiscDiv: typeof elementRemoveMiscDiv;
+  };
+  function elementCreateSubscreenDiv(): HTMLElement;
+  function elementGetSubscreenDiv(): HTMLElement | undefined;
+  function elementRemoveSubscreenDiv(): void | undefined;
+  function elementAppendToSubscreenDiv(...element: HTMLElement[]): void | undefined;
+  function elementCreateSettingsDiv(): HTMLElement;
+  function elementGetSettingsDiv(): HTMLElement | undefined;
+  function elementAppendToSettingsDiv(...element: HTMLElement[]): void | undefined;
+  function elementRemoveSettingsDiv(): void | undefined;
+  function elementCreateMiscDiv(): HTMLElement;
+  function elementGetMiscDiv(): HTMLElement | null;
+  function elementAppendToMiscDiv(...element: HTMLElement[]): void | undefined;
+  function elementRemoveMiscDiv(): void | undefined;
+  export {};
+
+}
+declare module 'bc-deeplib/utilities/logger' {
+  type LogLevel = 'info' | 'log' | 'warn' | 'error' | 'debug';
+  interface LogEntry {
+      readonly args: readonly any[];
+      readonly date: Date;
+      readonly logLevel: LogLevel;
+  }
+  export class Logger extends Array<LogEntry> {
+      private ModName;
+      constructor(modName?: string);
+      private _Log;
+      info(...args: any[]): void;
+      log(...args: any[]): void;
+      warn(...args: any[]): void;
+      error(...args: any[]): void;
+      debug(...args: any[]): void;
+      static colorizeLog(logLevel: LogLevel): string;
+  }
+  export const deepLibLogger: Logger;
+  export {};
+
+}
+declare module 'bc-deeplib/utilities/messages' {
+  export function sendLocalMessage(id: string | null, message: string, timeoutInSeconds?: number): void;
+  export function sendActionMessage(msg: string, target?: undefined | number, dictionary?: ChatMessageDictionaryEntry[]): void;
+
+}
+declare module 'bc-deeplib/utilities/sdk' {
+  export const HookPriority: {
+      Observe: number;
+      AddBehavior: number;
+      ModifyBehavior: number;
+      OverrideBehavior: number;
+      Top: number;
+  };
+  export type ModuleCategory = number | string;
+  interface IPatchedFunctionData {
+      name: string;
+      hooks: {
+          hook: PatchHook;
+          priority: number;
+          module: ModuleCategory | null;
+          removeCallback: () => void;
+      }[];
+  }
+  export class ModSdkManager {
+      private static SDK;
+      private static patchedFunctions;
+      static ModInfo: ModSDKModInfo;
+      constructor(info: ModSDKModInfo, options?: ModSDKModOptions);
+      initPatchableFunction(target: string): IPatchedFunctionData;
+      hookFunction<TargetName extends string>(target: TargetName, priority: number, hook: PatchHook<GetDotedPathType<typeof globalThis, TargetName>>, module?: ModuleCategory | null): () => void;
+      patchFunction(target: string, patches: Record<string, string>): void;
+      unpatchFunction(target: string): void;
+      removeHookByModule(target: string, module: ModuleCategory): boolean;
+      removeAllHooksByModule(module: ModuleCategory): boolean;
+  }
+  export {};
+
+}
+declare module 'bc-deeplib/utilities/style' {
+  export const Style: {
+      injectInline(styleId: string, styleSource: string): void;
+      injectEmbed(styleId: string, styleLink: string): void;
+      eject(id: string): void;
+      reload(styleId: string, styleSource: string): void;
+      fetch(link: string): Promise<string>;
+  };
+
+}
+declare module 'bc-deeplib/utilities/translation' {
+  interface InitOptions {
+      pathToTranslationsFolder: string;
+  }
+  export class Localization {
+      private static LibTranslation;
+      private static ModTranslation;
+      private static PathToModTranslation;
+      private static PathToLibTranslation;
+      private static initialized;
+      static init(initOptions: InitOptions): Promise<void>;
+      static getTextMod(srcTag: string): string | undefined;
+      static getTextLib(srcTag: string): string | undefined;
+      private static fetchLanguageFile;
+      private static parseLanguageFile;
+  }
+  export const getText: (srcTag: string) => string;
+  export {};
+
+}
+declare module 'bc-deeplib' {
+  import main = require('bc-deeplib/src/deeplib');
+  export = main;
+}