@scml-dol-maplebirch/types 5.0.4 → 5.1.1

package/modules/DoL/Patches/Foodstuff.d.ts

@@ -0,0 +1,64 @@
+type FoodstuffSeason = 'spring' | 'summer' | 'autumn' | 'winter';
+type FoodstuffPlantingBed = 'earth' | 'water';
+type FoodstuffStallSize = 'small' | 'large';
+export interface FoodstuffConfig {
+    key?: string;
+    index?: number;
+    is_fishing_bait?: boolean;
+    name?: string;
+    singular?: string;
+    plural?: string;
+    icon?: string;
+    category?: string;
+    kitchen_item_type_icon?: string;
+    prop_folder?: string;
+    ingredient_alternatives?: Partial<Record<'normal' | 'lewd', string[]>>;
+    tending?: {
+        planting_bed?: FoodstuffPlantingBed;
+        growth_days?: number;
+        featCost?: number;
+        yield_multiplier?: number;
+        has_seeds?: boolean;
+        seed_name?: string;
+        seasons?: FoodstuffSeason[];
+        affected_by_tending_skill?: boolean;
+        tags?: string[];
+        [key: string]: unknown;
+    };
+    shop?: {
+        sell_price?: number;
+        available_in?: string[];
+        bought_in_bulk?: number;
+        stall_size?: FoodstuffStallSize;
+        [key: string]: unknown;
+    };
+    recipe?: {
+        recipe_name?: string;
+        difficulty?: number;
+        cook_minutes?: number;
+        servings?: number;
+        ingredients?: string[];
+        ingredient_alternatives?: Partial<Record<'normal' | 'lewd', Record<string, string[]>>>;
+        tags?: string[];
+        [key: string]: unknown;
+    };
+    food?: {
+        handheld_gift?: boolean;
+        tags?: string[];
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export type FoodstuffItem = FoodstuffConfig & Required<Pick<FoodstuffConfig, 'index' | 'name' | 'singular' | 'plural' | 'icon' | 'category' | 'kitchen_item_type_icon' | 'prop_folder'>>;
+export declare const foodstuffData: Record<string, FoodstuffConfig>;
+declare class Foodstuff {
+    static add(key: string, config: FoodstuffConfig): void;
+    static apply(): void;
+    static syncState(): void;
+    static applySetup(): void;
+    private static set;
+    private static nextIndex;
+    private static sort;
+    private static ensureState;
+}
+export default Foodstuff;

package/modules/DoL/Patches/Location.d.ts

@@ -0,0 +1,36 @@
+export interface LocationConfigOptions {
+    overwrite?: boolean;
+    layer?: string;
+    element?: string;
+}
+export interface LocationElement {
+    condition?: () => boolean;
+    image?: string;
+    frame?: number | (() => number);
+    animation?: {
+        frameDelay?: number;
+        cycleDelay?: number | (() => number);
+    };
+    [key: string]: unknown;
+}
+export interface LocationConfig extends LocationElement {
+    folder?: string;
+    base?: Record<string, LocationElement> | LocationElement;
+    emissive?: Record<string, LocationElement> | LocationElement;
+    reflective?: Record<string, LocationElement> | LocationElement;
+    layerTop?: Record<string, LocationElement> | LocationElement;
+    weather?: Record<string, unknown>;
+    particles?: Record<string, unknown>[];
+    customMapping?: () => string;
+}
+export interface LocationUpdate {
+    overwrite: boolean;
+    config: LocationConfig;
+    customMapping: (() => string) | null;
+}
+export declare const locationData: Record<string, LocationUpdate>;
+declare class Location {
+    static configure(locationId: string, config: LocationConfig, options?: LocationConfigOptions): boolean;
+    static apply(): void;
+}
+export default Location;

package/modules/DoL/Patches/Tips.d.ts

@@ -0,0 +1,7 @@
+export declare const tipsData: Record<string, string[]>;
+declare class Tips {
+    static add(category: string, ...tips: string[]): void;
+    static apply(): void;
+    static inject(data: string[]): string[];
+}
+export default Tips;

package/modules/DoL/Patches/Traits.d.ts

@@ -0,0 +1,24 @@
+export interface TraitCategory {
+    title: string;
+    traits: Trait[];
+}
+interface Trait {
+    name: string;
+    colour: string;
+    has: boolean;
+    text: string;
+}
+export interface TraitConfig {
+    title: string;
+    name: string | (() => string);
+    colour: string | (() => string);
+    has: boolean | (() => boolean);
+    text: string | (() => string);
+}
+export declare const traitsData: TraitConfig[];
+declare class Traits {
+    static add(...traits: Partial<TraitConfig>[]): void;
+    static inject(data: TraitCategory[], translate: (text: string) => string): TraitCategory[];
+    private static resolve;
+}
+export default Traits;

package/modules/DoL/Patches/config.d.ts

@@ -0,0 +1,2 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isKey(key: unknown): key is string;

package/modules/DoL/Patches/index.d.ts

@@ -0,0 +1,86 @@
+import type { MaplebirchCore } from '../../../core.js';
+import Patch from '../../Frameworks/Patch.js';
+import Traits from './Traits.js';
+import Location from './Location.js';
+import Bodywriting from './Bodywriting.js';
+import Foodstuff from './Foodstuff.js';
+import Antiques from './Antiques.js';
+import Tips from './Tips.js';
+import Fishing from './Fishing.js';
+declare function register(core: MaplebirchCore, patch: Patch): (Patch<Record<never, never>> & {
+    traitsData: import("./Traits.js").TraitConfig[];
+    addTraits: typeof Traits.add;
+    injectTraits: (data: Parameters<typeof Traits.inject>[0]) => import("./Traits.js").TraitCategory[];
+} & {
+    locationData: Record<string, import("./Location.js").LocationUpdate>;
+    configureLocation: typeof Location.configure;
+    applyLocation: typeof Location.apply;
+} & {
+    bodywritingData: Record<string, import("./Bodywriting.js").BodywritingData>;
+    addBodywriting: typeof Bodywriting.add;
+    deleteBodywriting: typeof Bodywriting.delete;
+    applyBodywriting: typeof Bodywriting.apply;
+} & {
+    fishData: Record<string, import("./Fishing.js").FishConfig>;
+    fishingLocationData: Partial<Record<import("./Fishing.js").FishingLocation, Record<string, number>>>;
+    addFish: typeof Fishing.addFish;
+    addBait: typeof Fishing.addBait;
+    configureFishingLocation: typeof Fishing.configureLocation;
+    applyFishing: typeof Fishing.apply;
+} & {
+    foodstuffData: Record<string, import("./Foodstuff.js").FoodstuffConfig>;
+    addFoodstuff: typeof Foodstuff.add;
+    applyFoodstuff: typeof Foodstuff.apply;
+} & {
+    antiquesData: Record<string, import("./Antiques.js").AntiqueConfig>;
+    addAntiques: typeof Antiques.add;
+    injectAntiques: typeof Antiques.inject;
+} & {
+    tipsData: Record<string, string[]>;
+    addTips: typeof Tips.add;
+    applyTips: typeof Tips.apply;
+    injectTips: typeof Tips.inject;
+}) & {
+    traits: {
+        data: import("./Traits.js").TraitConfig[];
+        add: typeof Traits.add;
+        inject: (data: Parameters<typeof Traits.inject>[0]) => import("./Traits.js").TraitCategory[];
+    };
+    location: {
+        data: Record<string, import("./Location.js").LocationUpdate>;
+        configure: typeof Location.configure;
+        apply: typeof Location.apply;
+    };
+    bodywriting: {
+        data: Record<string, import("./Bodywriting.js").BodywritingData>;
+        add: typeof Bodywriting.add;
+        delete: typeof Bodywriting.delete;
+        apply: typeof Bodywriting.apply;
+    };
+    fishing: {
+        data: Record<string, import("./Fishing.js").FishConfig>;
+        locations: Partial<Record<import("./Fishing.js").FishingLocation, Record<string, number>>>;
+        add: typeof Fishing.addFish;
+        addBait: typeof Fishing.addBait;
+        configure: typeof Fishing.configureLocation;
+        apply: typeof Fishing.apply;
+    };
+    foodstuff: {
+        data: Record<string, import("./Foodstuff.js").FoodstuffConfig>;
+        add: typeof Foodstuff.add;
+        apply: typeof Foodstuff.apply;
+    };
+    antiques: {
+        data: Record<string, import("./Antiques.js").AntiqueConfig>;
+        add: typeof Antiques.add;
+        inject: typeof Antiques.inject;
+    };
+    tips: {
+        data: Record<string, string[]>;
+        add: typeof Tips.add;
+        apply: typeof Tips.apply;
+        inject: typeof Tips.inject;
+    };
+};
+export type Patches = ReturnType<typeof register>;
+export default register;

package/modules/DoL/Replacements.d.ts

@@ -0,0 +1,189 @@
+declare const specialWidget: string[];
+declare const defaultData: {
+    Init: string;
+    Header: string;
+    Footer: string;
+    Information: string;
+    Options: string;
+    Cheats: string;
+    NPCinit: string;
+    NPCinject: string;
+};
+declare const locationPassage: {
+    Start: {
+        src: string;
+        applybefore: string;
+    }[];
+    StoryCaption: ({
+        src: string;
+        applyafter: string;
+        applybefore?: undefined;
+        to?: undefined;
+    } | {
+        applyafter?: undefined;
+        src: string;
+        applybefore: string;
+        to?: undefined;
+    } | {
+        applyafter?: undefined;
+        applybefore?: undefined;
+        src: string;
+        to: string;
+    })[];
+};
+declare const widgetPassage: {
+    MuseumAntiques: {
+        src: string;
+        applybefore: string;
+        expected: number;
+    }[];
+    'Widgets Museum': {
+        src: string;
+        applybefore: string;
+        expected: number;
+    }[];
+    'Widgets Tips': {
+        src: string;
+        applybefore: string;
+        expected: number;
+    }[];
+    Characteristics: ({
+        applybefore?: undefined;
+        src: string;
+        applyafter: string;
+    } | {
+        applyafter?: undefined;
+        src: string;
+        applybefore: string;
+    })[];
+    overlayReplace: {
+        src: string;
+        applybefore: string;
+    }[];
+    'Options Overlay': {
+        src: string;
+        applybefore: string;
+    }[];
+    npcNamed: {
+        src: string;
+        applybefore: string;
+    }[];
+    Social: ({
+        applyafter?: undefined;
+        src: string;
+        applybefore: string;
+    } | {
+        applybefore?: undefined;
+        src: string;
+        applyafter: string;
+    })[];
+    'Widgets Named Npcs': ({
+        applybefore?: undefined;
+        srcmatch: RegExp;
+        to: string;
+        src?: undefined;
+    } | {
+        applybefore?: undefined;
+        srcmatch?: undefined;
+        src: string;
+        to: string;
+    } | {
+        to?: undefined;
+        srcmatch?: undefined;
+        src: string;
+        applybefore: string;
+    })[];
+    'Widgets Settings': ({
+        applyafter?: undefined;
+        src?: undefined;
+        srcmatch: RegExp;
+        to: string;
+        srcmatchgroup?: undefined;
+    } | {
+        applyafter?: undefined;
+        srcmatch?: undefined;
+        src?: undefined;
+        srcmatchgroup: RegExp;
+        to: string;
+    } | {
+        to?: undefined;
+        src?: undefined;
+        srcmatchgroup?: undefined;
+        srcmatch: RegExp;
+        applyafter: string;
+    } | {
+        to?: undefined;
+        srcmatch?: undefined;
+        srcmatchgroup?: undefined;
+        src: string;
+        applyafter: string;
+    })[];
+    Widgets: ({
+        to?: undefined;
+        srcmatchgroup?: undefined;
+        src: string;
+        applybefore: string;
+    } | {
+        applybefore?: undefined;
+        src?: undefined;
+        srcmatchgroup: RegExp;
+        to: string;
+    })[];
+    'Widgets Effects Man': {
+        src: string;
+        applybefore: string;
+    }[];
+    'Widgets Actions Speak': {
+        src: string;
+        applyafter: string;
+    }[];
+    'Widgets Struggle': {
+        src: string;
+        applyafter: string;
+    }[];
+    'Widgets Swarm Effects': {
+        src: string;
+        applyafter: string;
+    }[];
+    'Widgets Vore Effects': {
+        src: string;
+        applyafter: string;
+    }[];
+    'Machine Effects': {
+        src: string;
+        applyafter: string;
+    }[];
+    'Widgets Tentacles': {
+        src: string;
+        applyafter: string;
+    }[];
+    Traits: {
+        src: string;
+        applybefore: string;
+    }[];
+    'Widgets Journal': ({
+        applybefore?: undefined;
+        src?: undefined;
+        srcmatch: RegExp;
+        to: string;
+    } | {
+        to?: undefined;
+        srcmatch?: undefined;
+        src: string;
+        applybefore: string;
+    })[];
+    'Widgets Mirror': ({
+        src?: undefined;
+        srcmatch: RegExp;
+        to: string;
+    } | {
+        srcmatch?: undefined;
+        src: string;
+        to: string;
+    })[];
+    'Widgets NPCs': {
+        src: string;
+        to: string;
+    }[];
+};
+export { specialWidget, defaultData, locationPassage, widgetPassage };

package/modules/DoL/ToolCollection.d.ts

@@ -0,0 +1,17 @@
+import type { MaplebirchCore } from '../../core.js';
+import ToolCollection from '../ToolCollection.js';
+import DoLConsole from '../Frameworks/DoLConsole.js';
+import DoLMacros from '../Frameworks/DoLMacros.js';
+import { type Patches } from './Patches/index.js';
+declare class DoLToolCollection extends ToolCollection {
+    readonly console: DoLConsole;
+    readonly macro: DoLMacros;
+    readonly patch: Patches;
+    private readonly macros;
+    private readonly optionEvents;
+    private readonly modI18N;
+    constructor(core: MaplebirchCore);
+    preInit(): void;
+    Init(): void;
+}
+export default DoLToolCollection;

package/modules/DoL/index.d.ts

@@ -0,0 +1 @@
+export {};

package/modules/DoL/types.d.ts

@@ -0,0 +1,20 @@
+import type DoLDynamic from './Dynamic.js';
+import type DoLToolCollection from './ToolCollection.js';
+import type Audio from '../Audio.js';
+import type Variables from '../Variables.js';
+import type Character from '../Character.js';
+import type NPCManager from '../NamedNPC.js';
+import type Combat from '../Combat.js';
+export interface CoreModules {
+    readonly dynamic: DoLDynamic;
+    readonly tool: DoLToolCollection;
+    readonly audio: Audio;
+    readonly var: Variables;
+    readonly char: Character;
+    readonly npc: NPCManager;
+    readonly combat: Combat;
+}
+declare global {
+    interface MaplebirchExtensions extends CoreModules {
+    }
+}

package/modules/Dynamic.d.ts

@@ -0,0 +1,10 @@
+import type { MaplebirchCore } from '../core.js';
+import type { ScopedLog } from '../infra/Diagnostics.js';
+import Lifecycle, { type LifecycleTarget } from '../infra/Lifecycle.js';
+declare class Dynamic extends Lifecycle<string, LifecycleTarget> {
+    readonly core: MaplebirchCore;
+    readonly log: ScopedLog;
+    constructor(core: MaplebirchCore);
+    Init(): void;
+}
+export default Dynamic;

package/modules/Event.d.ts

@@ -0,0 +1,16 @@
+import type { ScopedLog } from '../infra/Diagnostics.js';
+export interface EventOptions {
+    priority?: number;
+    once?: boolean;
+}
+declare abstract class Event {
+    readonly id: string;
+    protected readonly log: ScopedLog;
+    readonly priority: number;
+    readonly once: boolean;
+    protected abstract readonly eventName: string;
+    protected constructor(id: string, options: EventOptions, log: ScopedLog);
+    protected evaluate<T extends unknown[]>(label: string, callback: (...args: T) => boolean, ...args: T): boolean;
+    protected invoke<T extends unknown[]>(label: string, callback: ((...args: T) => void) | undefined, ...args: T): void;
+}
+export default Event;

package/modules/Frameworks/ApplyLinkZone.d.ts

@@ -0,0 +1,40 @@
+import type { ScopedLog } from '../../infra/Diagnostics.js';
+interface CustomZone {
+    position: number;
+    macro: string;
+}
+interface LinkZoneConfig {
+    containerId: string;
+    linkSelector: string;
+    beforeMacro: () => string;
+    afterMacro: () => string;
+    customMacro: () => CustomZone[];
+    zoneStyle: Partial<CSSStyleDeclaration>;
+    onBeforeApply?: (() => void) | null;
+    onAfterApply?: ((result: boolean, config: LinkZoneConfig) => void) | null;
+    debug: boolean;
+}
+declare class LinkZoneManager {
+    readonly containerId: string;
+    readonly linkSelector: string;
+    static readonly apply: (config?: Partial<LinkZoneConfig>) => boolean;
+    static readonly add: (config: LinkZoneConfig, customZones: CustomZone[]) => void;
+    static readonly defaultConfig: LinkZoneConfig;
+    firstLink: Element | null;
+    lastLink: Element | null;
+    links: Element[];
+    readonly log: ScopedLog;
+    constructor(containerId: string | undefined, linkSelector: string | undefined, logger: ScopedLog);
+    detect(): boolean;
+    applyZones(config: LinkZoneConfig, customZones: CustomZone[]): boolean;
+    private applyBefore;
+    private applyAfter;
+    private applyCustom;
+    private zone;
+    private insertAfterBreak;
+    private findBefore;
+    private isBreak;
+    private visible;
+}
+declare const applyLinkZone: typeof LinkZoneManager;
+export default applyLinkZone;

package/modules/Frameworks/ConsoleCheat.d.ts

@@ -0,0 +1,43 @@
+import type ToolCollection from '../ToolCollection.js';
+interface JSExecutionResult {
+    success: boolean;
+    result?: any;
+    error?: string;
+    message: string;
+    globals?: Record<string, any>;
+}
+interface TwineExecutionResult {
+    success: boolean;
+    error?: string;
+    message: string;
+    hasNavigation?: boolean;
+    parsedContent?: string;
+}
+interface ExecutionResult {
+    success: boolean;
+    result?: any;
+    error?: string;
+    message: string;
+    globals?: Record<string, any>;
+    hasNavigation?: boolean;
+    parsedContent?: string;
+}
+declare class CheatConsole {
+    readonly manager: ToolCollection;
+    private readonly log;
+    private readonly core;
+    private readonly globals;
+    private readonly jsStatus;
+    private readonly twineStatus;
+    private readonly twineOutputs;
+    constructor(manager: ToolCollection);
+    executeJS(code?: string): JSExecutionResult;
+    executeTwine(code?: string): TwineExecutionResult;
+    execute(type: 'javascript' | 'twine', code?: string): ExecutionResult;
+    private runJavaScript;
+    private linkTarget;
+    private html;
+    private format;
+    private showStatus;
+}
+export default CheatConsole;

package/modules/Frameworks/DoLConsole.d.ts

@@ -0,0 +1,8 @@
+import type ToolCollection from '../ToolCollection.js';
+import Console from './ConsoleCheat.js';
+import TimeTravelCheat from './TimeTravelCheat.js';
+declare class DoLConsole extends Console {
+    readonly timeTravel: TimeTravelCheat;
+    constructor(manager: ToolCollection);
+}
+export default DoLConsole;

package/modules/Frameworks/DoLMacros.d.ts

@@ -0,0 +1,6 @@
+import defineMacros from './macros.js';
+declare class DoLMacros extends defineMacros {
+    statChange(statType: string, amount: number, colorClass: string, condition?: () => boolean): DocumentFragment;
+    grace(amount: number, expectedRank?: string): DocumentFragment;
+}
+export default DoLMacros;

package/modules/Frameworks/HtmlTools.d.ts

@@ -0,0 +1,49 @@
+import { type MaplebirchCore } from '../../core.js';
+import type { ScopedLog } from '../../infra/Diagnostics.js';
+import type { MacroFunction } from './macros.js';
+import type { MacroContext } from '../../macros/index.js';
+export type HtmlRoot = Element | DocumentFragment;
+export interface TextContext {
+    readonly macro?: MacroContext;
+    readonly args?: readonly unknown[];
+    readonly name?: string;
+    readonly widgetName?: string;
+    readonly passageTitle?: string;
+    readonly [key: string]: unknown;
+}
+type TextContent = string | number | boolean | null | undefined;
+type RawContent = TextContent | Node;
+declare class Builder {
+    readonly parent: htmlTools;
+    readonly auto: (text: string) => string;
+    readonly fragment: HtmlRoot;
+    readonly context: TextContext;
+    constructor(parent: htmlTools, fragment: HtmlRoot, context?: TextContext);
+    text(content: TextContent, style?: string): this;
+    line(content?: TextContent, style?: string): this;
+    wikify(content: TextContent): this;
+    raw(content: RawContent): this;
+    box(content: RawContent, style?: string): this;
+}
+declare class htmlTools {
+    readonly core: MaplebirchCore;
+    readonly log: ScopedLog;
+    private uid;
+    private readonly store;
+    constructor(core: MaplebirchCore);
+    get Wikifier(): ReturnType<MaplebirchCore['host']['sugarcube']['require']>['Wikifier'];
+    replaceText(oldText: string, newText: string, root?: HtmlRoot | null): number;
+    renameLink(target: string | Element, label: string, root?: HtmlRoot | null): boolean;
+    replaceLink(target: string | Element, source: string, root?: HtmlRoot | null): boolean;
+    private findLink;
+    add(key: string, handler: (tools: Builder) => void, id?: string): string | false;
+    delete(key: string, idOrHandler?: string | ((tools: Builder) => void)): boolean;
+    clear(): void;
+    renderFragment(keys: string | string[], context?: TextContext): DocumentFragment;
+    renderInto(root: HtmlRoot, keys: string | string[], context?: TextContext): void;
+    render(macro: MacroContext, keys: string | string[]): void;
+    makeTextOutput(options?: {
+        CSV?: boolean;
+    }): MacroFunction;
+}
+export default htmlTools;

package/modules/Frameworks/ImageLoader.d.ts

@@ -0,0 +1,6 @@
+declare class ImageLoader {
+    private static refreshTimer;
+    static load(src: string): string | false | Promise<string | false>;
+    private static queueRefresh;
+}
+export default ImageLoader;

package/modules/Frameworks/OptionEvents.d.ts

@@ -0,0 +1,15 @@
+import type { MaplebirchCore } from '../../core.js';
+declare class OptionEvents {
+    private readonly core;
+    private relationTimer;
+    private installed;
+    constructor(core: MaplebirchCore);
+    install(): void;
+    private get ready();
+    private report;
+    private refreshOptions;
+    private updateSidebar;
+    private updatePet;
+    private updateRelation;
+}
+export default OptionEvents;