@scml-dol-maplebirch/types 5.0.4 → 5.1.1

package/services/CredentialVault.d.ts

@@ -0,0 +1,80 @@
+import type ModLoader from '../host/ModLoader.js';
+import Diagnostics from '../infra/Diagnostics.js';
+import type Emitter from '../infra/Emitter.js';
+import type IndexedDB from './IndexedDB.js';
+import type { InputFileFormat } from '@scml/types/sugarcube-2-ModLoader/JSZipLikeReadOnlyInterface';
+export type CredentialPeriod = 'day' | 'month';
+export interface AuthConfig {
+    key: string;
+    subject?: string;
+    name?: string;
+    publicKey: JsonWebKey | string;
+    prompt?: {
+        title?: string;
+        label?: string;
+        placeholder?: string;
+        hint?: string;
+    };
+    date?: {
+        period?: CredentialPeriod;
+        timezone?: string;
+        graceDays?: number;
+    };
+}
+export interface AuthPayload {
+    subject: string;
+    key: string;
+    date?: string;
+    password: string;
+    expiresAt?: number;
+}
+export interface CryptContext {
+    modName: string;
+    credential?: string;
+    payload?: AuthPayload;
+}
+export interface CryptResult {
+    data: Awaited<InputFileFormat>;
+    auth?: AuthConfig | boolean | void;
+}
+export interface CryptOptions {
+    modName?: string;
+    cache?: {
+        subject: string;
+        key: string;
+    };
+    password?: string;
+    prompt?: AuthConfig['prompt'] & {
+        name?: string;
+    };
+    lazyOptions?: unknown;
+    decrypt(password: string, context: CryptContext): Promise<CryptResult | Awaited<InputFileFormat>>;
+}
+export declare class CredentialVault {
+    readonly idb: IndexedDB;
+    readonly modloader: ModLoader;
+    readonly events: Emitter;
+    readonly diagnostics: Diagnostics;
+    readonly translate: (key: string) => string;
+    private static readonly STORE;
+    private static readonly TOKEN_PREFIX;
+    private dialogQueue;
+    private storageKey;
+    constructor(idb: IndexedDB, modloader: ModLoader, events: Emitter, diagnostics: Diagnostics, translate: (key: string) => string);
+    loadCrypt(options: CryptOptions): Promise<boolean>;
+    private loadCredential;
+    private decryptAndLoad;
+    private decodeCredential;
+    private verify;
+    private credentialDate;
+    private readStored;
+    private storeStored;
+    private forget;
+    private ensurePromptStyle;
+    private promptCredential;
+    private ensureStorageKey;
+    private loadStorageKey;
+    private encryptRecord;
+    private decryptRecord;
+}
+export default CredentialVault;

package/services/GUIControl.d.ts

@@ -0,0 +1,54 @@
+import type ModLoader from '../host/ModLoader.js';
+import type Emitter from '../infra/Emitter.js';
+import type IndexedDB from './IndexedDB.js';
+import Modules from './Modules.js';
+import type Translator from './Translator.js';
+type ModuleType = 'protected' | 'mounted' | 'exposed' | 'module';
+interface ModuleInfo {
+    name: string;
+    type: ModuleType;
+    source: string;
+    protected: boolean;
+    lifecycle: boolean;
+    dependencies: string[];
+}
+interface ModulesSettings {
+    enabled: ModuleInfo[];
+    disabled: ModuleInfo[];
+}
+interface ScriptSource {
+    jsFiles: Array<{
+        modName: string;
+        filePath: string;
+    }>;
+}
+export declare class GUIControl {
+    readonly idb: IndexedDB;
+    readonly modloader: ModLoader;
+    readonly events: Emitter;
+    readonly modules: Modules;
+    readonly translator: Translator;
+    private readonly addon;
+    enabledModules: ModuleInfo[];
+    disabledModules: ModuleInfo[];
+    enabledScripts: string[];
+    disabledScripts: string[];
+    private modSubUiAngularJsService;
+    constructor(idb: IndexedDB, modloader: ModLoader, events: Emitter, modules: Modules, translator: Translator, addon: () => ScriptSource | undefined);
+    private initSettings;
+    init(): Promise<void>;
+    private loadSettings;
+    private modNames;
+    private currentModules;
+    typeLabel(type: ModuleType): string;
+    private modulesStore;
+    private scriptsStore;
+    saveModules(enabled: ModuleInfo[], disabled: ModuleInfo[]): Promise<void>;
+    setModuleStates(states: Readonly<Record<string, boolean>>): Promise<boolean>;
+    saveScripts(enabled: string[], disabled: string[]): Promise<void>;
+    cascadeModules(action: 'enable' | 'disable', moduleName: string, modules: ModulesSettings): string[];
+    private moduleLinks;
+    get moduleList(): string;
+    private whenCreate;
+}
+export default GUIControl;

package/services/IndexedDB.d.ts

@@ -0,0 +1,28 @@
+import { type IDBPTransaction } from 'idb';
+import Catalog from '../infra/Catalog.js';
+import type ModLoader from '../host/ModLoader.js';
+export interface StoreIndex {
+    name: string;
+    keyPath: string | string[];
+    options?: IDBIndexParameters;
+}
+interface StoreDefinition {
+    options: IDBObjectStoreParameters;
+    indexes: StoreIndex[];
+}
+export type Transaction<Mode extends IDBTransactionMode = IDBTransactionMode> = IDBPTransaction<unknown, string[], Mode>;
+export declare class IndexedDB extends Catalog<string, StoreDefinition> {
+    static readonly DATABASE_NAME = "maplebirch";
+    static readonly DATABASE_VERSION: number;
+    private db;
+    private opening;
+    constructor(modloader?: ModLoader);
+    define(name: string, options?: IDBObjectStoreParameters, indexes?: StoreIndex[]): boolean;
+    loadLogLevel(): Promise<string | boolean | undefined>;
+    init(): Promise<void>;
+    private open;
+    with<T, Mode extends IDBTransactionMode>(storeNames: string | string[], mode: Mode, callback: (tx: Transaction<Mode>) => T | Promise<T>): Promise<T>;
+    clearStore(storeName: string): Promise<void>;
+    deleteDatabase(): Promise<boolean>;
+}
+export default IndexedDB;

package/services/Modules.d.ts

@@ -0,0 +1,75 @@
+import { ModuleState } from '../constants.js';
+import type ModLoader from '../host/ModLoader.js';
+import { type ScopedLog } from '../infra/Diagnostics.js';
+import Lifecycle from '../infra/Lifecycle.js';
+import type IndexedDB from './IndexedDB.js';
+export interface Module {
+    log?: ScopedLog;
+    dependencies?: string[];
+    exposed?: boolean | 'window';
+    preInit?(): void | Promise<void>;
+    Init?(): void;
+    loadInit?(): void;
+    postInit?(): void;
+}
+interface ModuleRegistry {
+    modules: Map<string, Module>;
+    states: Map<string, ModuleState>;
+    sources: Map<string, string>;
+    dependencies: Map<string, Set<string>>;
+    dependents: Map<string, Set<string>>;
+}
+export interface DependencyInfo {
+    protected: boolean;
+    mounted: boolean;
+    exposed: boolean;
+    lifecycle: boolean;
+    dependencies: string[];
+    dependents: string[];
+    allDependencies: string[];
+    state: string;
+    source: string;
+}
+export type DependencyGraph = Record<string, DependencyInfo>;
+export interface ModulesMeta {
+    core: readonly string[];
+    protected: readonly string[];
+}
+export declare class Modules extends Lifecycle<string, Module> {
+    readonly owner: Record<string, unknown>;
+    readonly meta: ModulesMeta;
+    readonly idb: IndexedDB;
+    readonly registry: ModuleRegistry;
+    readonly initPhase: {
+        preInitCompleted: boolean;
+        mainInitCompleted: boolean;
+    };
+    private readonly sourceStack;
+    private readonly preInitialized;
+    private disabledNames;
+    private preInitTask;
+    private late;
+    private preRunning;
+    private preQueued;
+    constructor(owner: Record<string, unknown>, meta: ModulesMeta, idb: IndexedDB, modloader?: ModLoader);
+    static traverse(roots: Iterable<string>, links: ReadonlyMap<string, Iterable<string>>, excluded?: ReadonlySet<string>): Set<string>;
+    with<T>(source: string, callback: () => T | Promise<T>): Promise<T>;
+    register<T extends object>(name: string, module: T & Module, dependencies?: string[]): boolean;
+    get(name: string): Module | undefined;
+    get dependencyGraph(): DependencyGraph;
+    run(phase: 'pre'): Promise<void>;
+    run(phase: 'init' | 'load' | 'post'): void;
+    private prepare;
+    private queuePre;
+    private disable;
+    private pre;
+    private init;
+    private phase;
+    private ready;
+    private flush;
+    private topologicalOrder;
+    private collect;
+    private circular;
+    private hasLifecycle;
+}
+export default Modules;

package/services/Translator.d.ts

@@ -0,0 +1,60 @@
+import { type LanguageCode } from '../constants.js';
+import type ModLoader from '../host/ModLoader.js';
+import Catalog from '../infra/Catalog.js';
+import type Emitter from '../infra/Emitter.js';
+import type IndexedDB from './IndexedDB.js';
+export type Translation = Record<string, string>;
+interface ImportProgress {
+    type: 'process' | 'complete' | 'error' | 'not_found';
+    language: LanguageCode;
+    progress?: number;
+    current?: number;
+    total?: number;
+    count?: number;
+    error?: Error | null;
+}
+interface TranslationAddon {
+    hook<T>(name: string, handler: (task: {
+        modName: string;
+        config: T;
+    }) => void | Promise<void>): boolean;
+}
+export declare class Translator extends Catalog<string, Translation> {
+    readonly idb: IndexedDB;
+    readonly events: Emitter;
+    private readonly addon;
+    static readonly DEFAULT_LANGS: readonly LanguageCode[];
+    static readonly BATCH_SIZE = 500;
+    language: LanguageCode;
+    private readonly STORE;
+    private readonly cache;
+    private readonly sourceOrders;
+    private preloaded;
+    constructor(idb: IndexedDB, modloader: ModLoader, events: Emitter, addon: () => TranslationAddon | undefined);
+    private initDB;
+    setLanguage(language?: string): Promise<LanguageCode>;
+    import(modName: string, languages?: readonly LanguageCode[]): AsyncGenerator<ImportProgress>;
+    importFile(modName: string, language: LanguageCode, paths: string | readonly string[]): AsyncGenerator<ImportProgress>;
+    t(translationKey: string, space?: boolean): string;
+    auto(text: string): string;
+    has(translationKey: string): boolean;
+    set(translationKey: string, translations: Record<string, unknown>): boolean;
+    preload(): Promise<void>;
+    clearStorage(): Promise<void>;
+    private loadBundledTranslations;
+    private writeTranslations;
+    private writeBatch;
+    private removeOldTranslations;
+    private updateSource;
+    private activeSources;
+    private visibleTranslations;
+    private syncTranslation;
+    private readFileRecord;
+    private writeFileRecord;
+    private loadTranslation;
+    private parseTranslations;
+    private computeHash;
+    private getModFile;
+    private rebuild;
+}
+export default Translator;

package/types/global.d.ts

@@ -0,0 +1,123 @@
+import type { LinksAPI } from '@scml/sc2-verlnir/src/links';
+import { SC2DataManager } from '@scml/types/sugarcube-2-ModLoader/SC2DataManager';
+import { GameOriginalImagePack } from '@scml/types/GameOriginalImagePackMod/GameOriginalImagePack';
+import { BeautySelectorAddon } from '@scml/types/AddonMod_BeautySelector/BeautySelectorAddon';
+import { ImgLoaderHooker } from '@scml/types/Hook_ImgLoader/ImgLoaderHooker';
+import { Gui } from '@scml/types/Mod_LoaderGui/Gui';
+import { ModUtils } from '@scml/types/sugarcube-2-ModLoader/Utils';
+import { _languageSwitch } from '../macros/index.js';
+import ImageLoader from '../modules/Frameworks/ImageLoader.js';
+import type { ActionType, ActionValue } from '../modules/CombatAddon/CombatAction.js';
+import type { NPCChildRecord, NPCPregnancyOrifice, NPCPregnancyRecord, NPCPregnancySpecies, NPCTryConceiveOptions } from '../modules/NamedNPCAddon/NPCPregnancy.js';
+declare global {
+    interface Window {
+        modSC2DataManager: SC2DataManager;
+        modGameOriginalImagePack: GameOriginalImagePack;
+        modImgLoaderHooker: ImgLoaderHooker;
+        modLoaderGui: Gui;
+        modUtils: ModUtils;
+        addonBeautySelectorAddon: BeautySelectorAddon;
+        readonly Time: typeof Time;
+        DateTime: typeof DateTime;
+        closeOverlay(): void;
+        updateOptions(): void;
+        lanSwitch: typeof _languageSwitch;
+        readonly loadImage: typeof ImageLoader.load;
+        readonly V: typeof V;
+        readonly C: typeof C;
+        readonly T: typeof T;
+        DefaultActions: {
+            get(type: unknown, person: unknown, part: ActionType): ActionValue[];
+        };
+        pregnancyDaysEta: typeof pregnancyDaysEta;
+        getChildDays: typeof getChildDays;
+    }
+    const lanSwitch: typeof _languageSwitch;
+    const Links: LinksAPI;
+    const StartConfig: {
+        version: string;
+    };
+    interface ErrorsConfig {
+        debug: boolean;
+        maxLogs: number;
+        showReporterSelector: string;
+    }
+    interface ErrorLogEntry {
+        message: string;
+        copyData?: unknown;
+    }
+    interface ErrorsReporter {
+        visible(): boolean;
+        reporterContainer(): HTMLElement;
+        messagesContainer(): HTMLElement;
+        paneContainer(): HTMLElement;
+        copyArea(): HTMLTextAreaElement;
+        toggle(): void;
+        show(): void;
+        update(): void;
+        hide(andClear?: boolean): void;
+        createEntry(error: ErrorLogEntry): HTMLElement;
+        copyAll(): void;
+    }
+    interface Errors {
+        config: ErrorsConfig;
+        log: ErrorLogEntry[];
+        registerMessage(message: string, copyData?: unknown, noClone?: boolean): ErrorLogEntry;
+        report(message: string, copyData?: unknown, noClone?: boolean): void;
+        Reporter: ErrorsReporter;
+    }
+    const Errors: Errors;
+    const Weather: {
+        rain: boolean;
+        thunder: boolean;
+        snow: boolean;
+        cloud: boolean;
+        windy: boolean;
+        fog: boolean;
+        [key: string]: any;
+    };
+    function getFormattedDate(date: any, includeWeekday?: boolean): string;
+    function getShortFormattedDate(date: any): string;
+    function ordinalSuffixOf(i: number): string;
+    const Dynamic: {
+        [key: string]: any;
+    };
+    function hairLengthStringToNumber(lengthStr: string): number;
+    const Renderer: {
+        CanvasModels: {
+            main: any;
+        };
+        [key: string]: any;
+    };
+    const ZIndices: {
+        [key: string]: number;
+    };
+    function wikifier(widget: string, ...args: any): DocumentFragment;
+    function playerNormalPregnancyType(): string;
+    function getActivePregnancies(carrier: string): NPCPregnancyRecord[];
+    function getChildrenOf(pregnancyId: number): NPCChildRecord[];
+    function pregnancyProgress(record: NPCPregnancyRecord): number;
+    function getDueDate(record: NPCPregnancyRecord): number;
+    function npcMenstrualFertility(npcName: string): number;
+    function npcBellySize(npcName: string): number;
+    function pregnancyDaysEta(record: NPCPregnancyRecord): number;
+    function pregnancyDaysEta(record: null | undefined): null;
+    function getChildDays(childId: number): number;
+    function setKnowsPregnancy(pregnancyId: number, who: string): void;
+    function setKnowsDonor(pregnancyId: number, who: string): void;
+    function npcPregnancyRoll(carrier: string, carrierSpecies: NPCPregnancySpecies, donor: string, donorSpecies: NPCPregnancySpecies, orifice: NPCPregnancyOrifice, depth?: NPCTryConceiveOptions['depth'], location?: string, donorFertility?: number, slot?: number | null): number | null;
+    function hasSexStat(input: string, required: number, modifiers?: boolean): boolean;
+    function clothesIndex(slot: string, itemToIndex: object): number;
+    function integrityKeyword(worn: object, slot: string): string;
+    function between(value: number, min: number, max: number): boolean;
+    let isPossibleLoveInterest: (name: string) => boolean;
+    let combatListColor: (name: any, value: any, type?: any) => any;
+    const combatActionColours: CombatActionColours;
+    function gwylanSchedule(): string;
+    interface CombatActionColours {
+        [category: string]: {
+            [attitude: string]: string[];
+        };
+    }
+}
+export {};