@scml/sc2-modloader 1.0.0

package/type-dist/ModLoader.d.ts

@@ -0,0 +1,210 @@
+import { SimulateMergeResult } from "./SimulateMerge.js";
+import { JSZipLikeReadOnlyInterface } from "./JSZipLikeReadOnlyInterface.js";
+import { IndexDBLoader, LazyLoader, LoaderKeyConfig, LocalLoader, LocalStorageLoader, ModZipReader, RemoteLoader } from "./ModZipReader.js";
+import { ModLoadFromSourceType, ModOrderContainer, ModOrderContainer_OneAlias_ReadonlyMap, ModOrderContainer_One_ReadonlyMap, ModOrderItem } from "./ModOrderContainer.js";
+import { SC2DataManager } from "./SC2DataManager.js";
+import { LogWrapper, ModLoadControllerCallback } from "./ModLoadController.js";
+import { SC2DataInfo } from "./SC2DataInfoCache.js";
+import { ReplacePatcher } from "./ReplacePatcher.js";
+import { LRUCache } from "lru-cache";
+
+//#region remote/BeforeSC2/ModLoader.d.ts
+interface IModImgGetter {
+  /**
+   * @return Promise<string>   base64 img string
+   */
+  getBase64Image(): Promise<string | undefined>;
+  imgCache?: string;
+  invalid: boolean;
+  forceCache(): Promise<any>;
+}
+interface ImgLruCacheItemType {
+  imageBase64: string;
+  invalid: boolean;
+}
+declare const StaticModImgLruCache: LRUCache<string, ImgLruCacheItemType, unknown>;
+interface IModImgGetterLRUCache {
+  get(path: string): ImgLruCacheItemType | undefined;
+  set(path: string, data: ImgLruCacheItemType): IModImgGetterLRUCache;
+}
+declare class ModImgGetterDefault implements IModImgGetter {
+  modName: string;
+  zip: ModZipReader;
+  imgPath: string;
+  logger: LogWrapper;
+  constructor(modName: string, zip: ModZipReader, imgPath: string, logger: LogWrapper);
+  invalid: boolean;
+  imgCache?: string;
+  forceCache(): Promise<void>;
+  getBase64Image(): Promise<string | undefined>;
+}
+interface ModImg {
+  getter: IModImgGetter;
+  path: string;
+}
+interface ModBootJsonAddonPlugin {
+  modName: string;
+  addonName: string;
+  modVersion: string;
+  params?: any[] | {
+    [key: string]: any;
+  };
+}
+declare function checkModBootJsonAddonPlugin(v: any): v is ModBootJsonAddonPlugin;
+interface DependenceInfo {
+  modName: string;
+  version: string;
+}
+declare function checkDependenceInfo(v: any): v is DependenceInfo;
+type ModNickName = ({ [key in string]?: string } & {
+  cn?: string;
+  en?: string;
+}) | string | undefined;
+interface ModBootJson {
+  name: string;
+  nickName?: ModNickName;
+  alias?: string[];
+  version: string;
+  styleFileList: string[];
+  scriptFileList: string[];
+  scriptFileList_preload?: string[];
+  scriptFileList_earlyload?: string[];
+  scriptFileList_inject_early?: string[];
+  tweeFileList: string[];
+  imgFileList: string[];
+  replacePatchList?: string[];
+  additionFile: string[];
+  additionBinaryFile?: string[];
+  addonPlugin?: ModBootJsonAddonPlugin[];
+  dependenceInfo?: DependenceInfo[];
+}
+interface ModInfo {
+  name: string;
+  nickName?: ModNickName;
+  alias: string[];
+  version: string;
+  cache: SC2DataInfo;
+  imgs: ModImg[];
+  /**
+   * origin path, replace path
+   *
+   * @deprecated the imgFileReplaceList not work and never implemented, don't use it.
+   *             Please use `ImageLoaderAddon` or `BeautySelectorAddon` instead.
+   * @see `ImageLoaderAddon` https://github.com/Lyoko-Jeremie/DoL_ImgLoaderHooker
+   * @see `BeautySelectorAddon` https://github.com/Lyoko-Jeremie/DoL_BeautySelectorAddonMod
+   */
+  imgFileReplaceList: [string, string][];
+  /**
+   * file name, file content
+   */
+  scriptFileList_preload: [string, string][];
+  /**
+   * file name, file content
+   */
+  scriptFileList_earlyload: [string, string][];
+  /**
+   * file name, file content
+   */
+  scriptFileList_inject_early: [string, string][];
+  replacePatcher: ReplacePatcher[];
+  bootJson: ModBootJson;
+  modRef: {
+    [key: string]: any;
+  } | undefined;
+}
+declare enum ModDataLoadType {
+  'Remote' = "Remote",
+  'Local' = "Local",
+  'LocalStorage' = "LocalStorage",
+  'IndexDB' = "IndexDB"
+}
+declare class ModLoader {
+  gSC2DataManager: SC2DataManager;
+  modLoadControllerCallback: ModLoadControllerCallback;
+  thisWin: Window;
+  logger: LogWrapper;
+  constructor(gSC2DataManager: SC2DataManager, modLoadControllerCallback: ModLoadControllerCallback, thisWin: Window);
+  /**
+   * 已读取的mod列表（加载但没有初始化）
+   * The mod list that already read (load but not init)
+   */
+  private modReadCache;
+  /**
+   * 已加载的mod列表（加载并完成初始化）
+   * The mod list that already loaded (load and init)
+   */
+  private modCache;
+  /**
+   * 已加载的Lazy mod列表（使用 `lazyRegisterNewMod` 加载但未完成初始化）
+   * The Lazy mod list that already loaded (load use `lazyRegisterNewMod` but not init)
+   */
+  private modLazyCache;
+  modLoadRecord: ModOrderItem[];
+  /**
+   * O(2n)
+   */
+  getModCacheOneArray(): ModOrderItem[];
+  /**
+   O(n)
+   */
+  getModCacheArray(): ModOrderItem[];
+  getModAllName(): string[];
+  /**
+   O(1)
+   */
+  getModCacheMap(): ModOrderContainer_One_ReadonlyMap;
+  getModCacheMapWithAlias(): ModOrderContainer_OneAlias_ReadonlyMap;
+  /**
+   * O(n+2log(n))
+   */
+  checkModCacheData(): boolean;
+  /**
+   O(n)
+   */
+  checkModCacheUniq(): boolean;
+  /**
+   O(1)
+   */
+  getModCacheByNameOne(modName: string): ModOrderItem | undefined;
+  getModCacheByAliseOne(modName: string): ModOrderItem | undefined;
+  getModCacheByFromType(from: ModLoadFromSourceType): ModOrderItem[];
+  getModReadCache(): ModOrderContainer;
+  checkModConflictList(): {
+    mod: SC2DataInfo;
+    result: SimulateMergeResult;
+  }[];
+  private modLoaderKeyConfig?;
+  private modIndexDBLoader?;
+  private modLocalStorageLoader?;
+  private modLocalLoader?;
+  private modRemoteLoader?;
+  private modLazyLoader?;
+  getLoaderKeyConfig(): LoaderKeyConfig;
+  getIndexDBLoader(): IndexDBLoader;
+  getLocalStorageLoader(): LocalStorageLoader;
+  getLocalLoader(): LocalLoader;
+  getRemoteLoader(): RemoteLoader;
+  getLazyLoader(): LazyLoader;
+  loadOrder: ModDataLoadType[];
+  private addModReadZip;
+  loadMod(loadOrder: ModDataLoadType[]): Promise<boolean>;
+  private registerMod2Addon;
+  protected triggerAfterModLoad(): Promise<void>;
+  protected filterModCanLoad(modeC: ModOrderContainer): Promise<ModOrderContainer>;
+  lazyRegisterNewMod(modeZip: JSZipLikeReadOnlyInterface): Promise<boolean>;
+  private do_initModInjectEarlyLoadInDomScript;
+  private initModInjectEarlyLoadInDomScript;
+  private do_initModEarlyLoadScript;
+  private initModEarlyLoadScript;
+  getModEarlyLoadCache(): ModOrderContainer;
+  getModByNameOne(modName: string): ModOrderItem | undefined;
+  getModZip(modName: string): ModZipReader | undefined;
+  private loadEndModList?;
+  private toLoadModList?;
+  private nowLoadedMod?;
+  private newNowMod?;
+  private replacedNowMod?;
+  private tryInitWaitingLazyLoadMod;
+}
+//#endregion
+export { DependenceInfo, IModImgGetter, IModImgGetterLRUCache, ImgLruCacheItemType, ModBootJson, ModBootJsonAddonPlugin, ModDataLoadType, ModImg, ModImgGetterDefault, ModInfo, ModLoader, ModNickName, StaticModImgLruCache, checkDependenceInfo, checkModBootJsonAddonPlugin };

package/type-dist/ModOrderContainer.d.ts

@@ -0,0 +1,190 @@
+import { ModZipReader } from "./ModZipReader.js";
+import { ModInfo } from "./ModLoader.js";
+
+//#region remote/BeforeSC2/ModOrderContainer.d.ts
+declare enum ModLoadFromSourceType {
+  'Remote' = "Remote",
+  'Local' = "Local",
+  'LocalStorage' = "LocalStorage",
+  'IndexDB' = "IndexDB",
+  'SideLazy' = "SideLazy"
+}
+declare function isModOrderItem(a: any): a is ModOrderItem;
+interface ModOrderItem {
+  name: string;
+  from: ModLoadFromSourceType;
+  mod: ModInfo;
+  zip: ModZipReader;
+}
+declare abstract class CustomReadonlyMapHelper<K, V> implements ReadonlyMap<K, V> {
+  abstract get size(): number;
+  abstract get(key: K): V | undefined;
+  abstract has(key: K): boolean;
+  abstract entries(): IterableIterator<[K, V]>;
+  [Symbol.iterator](): IterableIterator<[K, V]>;
+  forEach(callback: (value: V, key: K, map: ReadonlyMap<K, V>) => void, thisArg?: any): void;
+  keys(): IterableIterator<K>;
+  values(): IterableIterator<V>;
+}
+declare class ModOrderContainer_One_ReadonlyMap extends CustomReadonlyMapHelper<string, ModOrderItem> {
+  parent: ModOrderContainer;
+  constructor(parent: ModOrderContainer);
+  get size(): number;
+  entries(): IterableIterator<[string, ModOrderItem]>;
+  get(key: string): ModOrderItem | undefined;
+  has(key: string): boolean;
+}
+declare class ModOrderContainer_OneAlias_ReadonlyMap extends CustomReadonlyMapHelper<string, ModOrderItem> {
+  parent: ModOrderContainer;
+  constructor(parent: ModOrderContainer);
+  get size(): number;
+  entries(): IterableIterator<[string, ModOrderItem]>;
+  get(key: string): ModOrderItem | undefined;
+  has(key: string): boolean;
+}
+declare function isModOrderContainer(a: any): a is ModOrderContainer;
+/**
+ * a multi-index container designed for mod load cache list. work like a C++ Boost.MultiIndexContainer
+ * can keep mod `order` , optional keep mod `unique` , remember mod load `from source`
+ */
+declare class ModOrderContainer {
+  container: Map<string, Map<ModLoadFromSourceType, ModOrderItem>>;
+  order: ModOrderItem[];
+  nameRefWithAlias: Map<string, string>;
+  constructor();
+  /**
+   * O(1)
+   *
+   * add addition limit that keep mod name unique
+   */
+  get_One_Map(): ModOrderContainer_One_ReadonlyMap;
+  get_One_Map_WithAlias(): ModOrderContainer_OneAlias_ReadonlyMap;
+  /**
+   * O(2n)
+   *
+   * add addition limit that keep mod name unique
+   */
+  get_One_Array(): ModOrderItem[];
+  /**
+   * O(n)
+   */
+  get_Array(): ModOrderItem[];
+  /**
+   * O(n)
+   */
+  getAllName(): string[];
+  /**
+   * O(1)
+   */
+  getHasByName(name: string): boolean;
+  /**
+   * O(1)
+   */
+  getHasByNameWithAlias(name: string): boolean;
+  /**
+   * O(1)
+   */
+  getHasByNameFrom(name: string, from: ModLoadFromSourceType): boolean;
+  /**
+   * O(1)
+   */
+  getByName(name: string): Map<ModLoadFromSourceType, ModOrderItem> | undefined;
+  /**
+   * O(1)
+   */
+  getModOrderItemByNameWithAlias(name: string): Map<ModLoadFromSourceType, ModOrderItem> | undefined;
+  /**
+   * O(1)
+   */
+  getByNameOne(name: string, noError?: boolean): ModOrderItem | undefined;
+  /**
+   * O(1)
+   */
+  getByNameOneWithAlias(name: string, noError?: boolean): ModOrderItem | undefined;
+  /**
+   * O(n)
+   */
+  getByFromTypeByOrder(from: ModLoadFromSourceType): ModOrderItem[];
+  /**
+   * O(n)
+   */
+  getByOrder(name: string): ModOrderItem[];
+  /**
+   * O(n)
+   */
+  checkNameUniq(): boolean;
+  /**
+   * O(n)
+   */
+  checkAlias(): boolean;
+  /**
+   * O(n+2log(n))
+   */
+  checkData(): boolean;
+  /**
+   * O(n)
+   */
+  delete(name: string, from: ModLoadFromSourceType): boolean;
+  /**
+   * O(n)
+   */
+  deleteAll(name: string): boolean;
+  /**
+   * O(1)
+   */
+  createModOrderItem(zip: ModZipReader, from: ModLoadFromSourceType): ModOrderItem | undefined;
+  /**
+   * O(2n)
+   */
+  pushFront(zip: ModZipReader, from: ModLoadFromSourceType): boolean;
+  /**
+   * O(2n)
+   */
+  pushBack(zip: ModZipReader, from: ModLoadFromSourceType): boolean;
+  /**
+   * O(2n)
+   */
+  insertReplace(zip: ModZipReader, from: ModLoadFromSourceType): boolean;
+  /**
+   * O(n)
+   */
+  popOut(name: string, from: ModLoadFromSourceType): ModOrderItem | undefined;
+  /**
+   * O(n)
+   */
+  popOutAll(name: string): ModOrderItem[] | undefined;
+  /**
+   * O(1)
+   */
+  popFront(): ModOrderItem | undefined;
+  /**
+   * O(1)
+   */
+  clear(): void;
+  /**
+   * O(1)
+   */
+  get size(): number;
+  /**
+   * O(2n)
+   */
+  clone(): ModOrderContainer;
+  private rebuildNameRefWithAlias;
+  private addModNameRefWithAlias;
+  private removeModNameRefWithAlias;
+  /**
+   * O(n)
+   */
+  private rebuildContainerFromOrder;
+  /**
+   * O(2n)
+   */
+  splitCloneInArray(name: string, from: ModLoadFromSourceType): {
+    before: ModOrderContainer;
+    current: ModOrderItem;
+    after: ModOrderContainer;
+  } | undefined;
+  static mergeModOrderContainer(nnn: (ModOrderContainer | ModOrderItem)[]): ModOrderContainer;
+}
+//#endregion
+export { ModLoadFromSourceType, ModOrderContainer, ModOrderContainer_OneAlias_ReadonlyMap, ModOrderContainer_One_ReadonlyMap, ModOrderItem, isModOrderContainer, isModOrderItem };

package/type-dist/ModPack/ModMeta.d.ts

@@ -0,0 +1,25 @@
+//#region remote/BeforeSC2/ModPack/ModMeta.d.ts
+interface FileMeta {
+  b: number;
+  e: number;
+  l: number;
+}
+interface CryptoInfo {
+  Xchacha20NonceBase64: string;
+  PwhashSaltBase64: string;
+}
+declare const MagicNumber: Uint8Array<ArrayBuffer>;
+declare const ModMetaProtocolVersion = 1;
+declare const BlockSize = 64;
+interface ModMeta {
+  magicNumber: string;
+  name: string;
+  protocolVersion: number;
+  blockSize: number;
+  cryptoInfo?: CryptoInfo;
+  fileTreeBlock: FileMeta;
+  bootJsonFile: FileMeta;
+  fileMeta: Record<string, FileMeta>;
+}
+//#endregion
+export { BlockSize, CryptoInfo, FileMeta, MagicNumber, ModMeta, ModMetaProtocolVersion };

package/type-dist/ModPack/ModPack.d.ts

@@ -0,0 +1,46 @@
+import { FileMeta, ModMeta } from "./ModMeta.js";
+import { ModPackFileReaderInterface } from "./ModPackFileReaderInterface.js";
+import xxhash from "xxhash-wasm";
+
+//#region remote/BeforeSC2/ModPack/ModPack.d.ts
+declare function XxHashH64Bigint2String(h64: bigint): string;
+declare function XxHashH32Number2String(h32: bigint): string;
+declare function calcXxHash64(data: Uint8Array, xxhashApi: Awaited<ReturnType<typeof xxhash>>): bigint;
+declare function covertFromZipMod(modName: string, filePathList: string[], fileReaderFunc: (filePath: string) => Promise<Uint8Array | undefined>, password?: string | undefined, progressCallback?: (progress: number) => any | Promise<any>, bootFilePath?: string): Promise<{
+  modMeta: ModMeta;
+  modPackBuffer: Uint8Array<ArrayBuffer>;
+  ext: string;
+  hash: bigint;
+  hashString: string;
+}>;
+declare class ModPackFileReader implements ModPackFileReaderInterface {
+  constructor();
+  get isInit(): boolean;
+  private password?;
+  private modMeta;
+  private fileDataStartPos;
+  private xchacha20Key?;
+  private xchacha20Nonce?;
+  private modPackBuffer;
+  private fileTree?;
+  static xxhashApi?: Awaited<ReturnType<typeof xxhash>>;
+  private xxHashValue?;
+  protected _progressCallback?: (progress: number) => any | Promise<any>;
+  set progressCallback(callback: (progress: number) => any | Promise<any>);
+  get modPackBufferSize(): number;
+  get modMetaInfo(): ModMeta;
+  get hash(): bigint;
+  get hashString(): string;
+  checkHash(modPackBuffer: Uint8Array): Promise<boolean>;
+  load(modPackBuffer: Uint8Array, password?: string): Promise<ModMeta>;
+  getFileList(): string[];
+  protected getFileByMeta(fileMeta: FileMeta, filePath: string): Promise<Uint8Array | undefined>;
+  getFile(filePath: string): Promise<Uint8Array | undefined>;
+  readFile(filePath: string): Promise<Uint8Array | undefined>;
+  getBootJson(): Promise<Uint8Array | undefined>;
+  getFileTree(): Promise<Record<string, any> | undefined>;
+  get fileTreeRef(): Record<string, any> | undefined;
+  checkValid(): Promise<boolean>;
+}
+//#endregion
+export { ModPackFileReader, XxHashH32Number2String, XxHashH64Bigint2String, calcXxHash64, covertFromZipMod };

package/type-dist/ModPack/ModPackFileReaderInterface.d.ts

@@ -0,0 +1,22 @@
+import { ModMeta } from "./ModMeta.js";
+
+//#region remote/BeforeSC2/ModPack/ModPackFileReaderInterface.d.ts
+interface ModPackFileReaderInterface {
+  isInit: boolean;
+  modPackBufferSize: number;
+  modMetaInfo: ModMeta;
+  hash: bigint;
+  hashString: string;
+  fileTreeRef: Record<string, any> | undefined;
+  progressCallback?: (progress: number) => any | Promise<any>;
+  load(modPackBuffer: Uint8Array, password?: string): Promise<ModMeta>;
+  checkHash(modPackBuffer: Uint8Array): Promise<boolean>;
+  getFileTree(): Record<string, any> | undefined;
+  getFileList(): string[];
+  getFile(filePath: string): Promise<Uint8Array | undefined>;
+  readFile(filePath: string): Promise<Uint8Array | undefined>;
+  getBootJson(): Promise<Uint8Array | undefined>;
+  checkValid(): Promise<boolean>;
+}
+//#endregion
+export { ModPackFileReaderInterface };

package/type-dist/ModPack/ModPackJsZipAdaptor.d.ts

@@ -0,0 +1,75 @@
+import { ModPackFileReader } from "./ModPack.js";
+
+//#region remote/BeforeSC2/ModPack/ModPackJsZipAdaptor.d.ts
+interface OutputByType {
+  base64: string;
+  string: string;
+  text: string;
+  binarystring: string;
+  array: number[];
+  uint8array: Uint8Array;
+  arraybuffer: ArrayBuffer;
+  blob: Blob;
+}
+interface InputByType {
+  base64: string;
+  string: string;
+  text: string;
+  binarystring: string;
+  array: number[];
+  uint8array: Uint8Array;
+  arraybuffer: ArrayBuffer;
+  blob: Blob;
+}
+type InputFileFormat = InputByType[keyof InputByType] | Promise<InputByType[keyof InputByType]>;
+interface JSZipSupport {
+  arraybuffer: boolean;
+  uint8array: boolean;
+  blob: boolean;
+  nodebuffer: boolean;
+}
+type Compression = 'STORE' | 'DEFLATE';
+interface JSZipObjectOptions {
+  compression: Compression;
+}
+declare class ModPackJsZipObjectAdaptor {
+  protected readonly ref: ModPackFileReader;
+  protected readonly parent: ModPackJsZipObjectAdaptor | undefined;
+  protected myPathInFileTree: string[];
+  protected treeLevelRef: Record<string, any>;
+  protected _isFile: boolean;
+  protected _isFolder: boolean;
+  protected _isValid: boolean;
+  constructor(filePath: string, ref: ModPackFileReader, parent: ModPackJsZipObjectAdaptor | undefined);
+  get dir(): boolean;
+  get name(): string;
+  get path(): string;
+  async<T extends keyof OutputByType>(type: T, onUpdate_Useless?: any): Promise<OutputByType[T]>;
+  protected _files?: Record<string, ModPackJsZipObjectAdaptor>;
+  get files(): Record<string, ModPackJsZipObjectAdaptor>;
+  get isFile(): boolean;
+  get isFolder(): boolean;
+  get isValid(): boolean;
+  get options(): JSZipObjectOptions;
+}
+declare class ModPackFileReaderJsZipAdaptor extends ModPackFileReader {
+  get is_JeremieModLoader_ModPack(): boolean;
+  protected _files?: Record<string, ModPackJsZipObjectAdaptor>;
+  protected _isPrepared: boolean;
+  protected zipAdaptorPassword?: string;
+  prepareSetPassword(password: string | undefined): void;
+  prepareForZipAdaptor(): Promise<void>;
+  get files(): Record<string, ModPackJsZipObjectAdaptor>;
+  file(path: string): ModPackJsZipObjectAdaptor | null;
+  file(path: RegExp): ModPackJsZipObjectAdaptor[] | null;
+  forEach(callback: (relativePath: string, file: ModPackJsZipObjectAdaptor) => void): void;
+  filter(predicate: (relativePath: string, file: ModPackJsZipObjectAdaptor) => boolean): ModPackJsZipObjectAdaptor[];
+  get support(): JSZipSupport;
+  static checkByHash(modPackBuffer: Uint8Array): Promise<boolean>;
+  loadAsync(data: InputFileFormat, options?: any & {
+    password?: string;
+    base64?: boolean;
+  }): Promise<ModPackFileReaderJsZipAdaptor | undefined>;
+}
+//#endregion
+export { ModPackFileReaderJsZipAdaptor, ModPackJsZipObjectAdaptor };