@momoyu-ink/kit 0.4.2 → 0.5.1

package/dist/hooks/useStage.js

@@ -1,706 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.autoState = exports.skipState = void 0;
-exports.useIsSkipping = useIsSkipping;
-exports.useIsAutoing = useIsAutoing;
-exports.setDefaultAutoTailMs = setDefaultAutoTailMs;
-exports.createStage = createStage;
-exports.useStageContext = useStageContext;
-exports.StageContextProvider = StageContextProvider;
-exports.useSkipCallback = useSkipCallback;
-exports.useInterruptCallback = useInterruptCallback;
-exports.useSkipBlocker = useSkipBlocker;
-exports.useAutoBlocker = useAutoBlocker;
-exports.useAutoTicket = useAutoTicket;
-exports.useBeforeHandleCommandCallback = useBeforeHandleCommandCallback;
-const react_1 = require("react");
-const valtio_1 = require("valtio");
-const useScenario_1 = require("./useScenario");
-const events_1 = require("../events");
-const moyu_1 = require("../moyu");
-// ---------------------------------------------------------------------------
-// Skip state — independent valtio proxy (not serialized with game saves)
-// ---------------------------------------------------------------------------
-const SKIP_INTERVAL_MS = 80;
-const autoRuntime = {
-    defaultTailMs: 0,
-};
-/** Reactive skip state. Actors read via useIsSkipping(). */
-exports.skipState = (0, valtio_1.proxy)({ active: false });
-/** Reactive auto state. Actors read via useIsAutoing(). */
-exports.autoState = (0, valtio_1.proxy)({ active: false });
-/** Reactively returns whether skip (Ctrl fast-forward) is active. */
-function useIsSkipping() {
-    return (0, valtio_1.useSnapshot)(exports.skipState).active;
-}
-/** Reactively returns whether auto mode is active. */
-function useIsAutoing() {
-    return (0, valtio_1.useSnapshot)(exports.autoState).active;
-}
-/** Set the default tail delay in milliseconds for newly created auto tickets. */
-function setDefaultAutoTailMs(ms) {
-    if (!Number.isFinite(ms)) {
-        autoRuntime.defaultTailMs = 0;
-        return;
-    }
-    autoRuntime.defaultTailMs = Math.max(0, ms);
-}
-// ---------------------------------------------------------------------------
-// createStage — module-level infrastructure
-// ---------------------------------------------------------------------------
-function createStage() {
-    // --- registries ---
-    let commandSchema = null;
-    const commandHandlers = new Map();
-    const textLineHandlers = [];
-    const skipCallbacks = [];
-    const interruptCallbacks = [];
-    const skipBlockers = [];
-    const autoBlockers = [];
-    const beforeHandleCommandCallbacks = [];
-    // --- registration functions ---
-    /** Push `item` to `registry` and return a function that removes it. */
-    function addToRegistry(registry, item) {
-        registry.push(item);
-        return () => {
-            const idx = registry.indexOf(item);
-            if (idx !== -1)
-                registry.splice(idx, 1);
-        };
-    }
-    /**
-     * Register command schema.
-     * Returns an unregister function.
-     */
-    function registerCommandSchema(schema) {
-        if (commandSchema !== null) {
-            console.warn('[Stage] Command schema is already registered — overwriting.');
-        }
-        commandSchema = schema;
-        return () => {
-            if (commandSchema === schema) {
-                commandSchema = null;
-            }
-        };
-    }
-    /**
-     * Register a command handler for one or more command names.
-     * Returns an unregister function.
-     */
-    function registerCommand(commands, handler) {
-        const names = Array.isArray(commands) ? commands : [commands];
-        for (const name of names) {
-            if (commandHandlers.has(name)) {
-                console.warn(`[Stage] Command handler for "${name}" is already registered — overwriting.`);
-            }
-            commandHandlers.set(name, handler);
-        }
-        return () => {
-            for (const name of names) {
-                if (commandHandlers.get(name) === handler) {
-                    commandHandlers.delete(name);
-                }
-            }
-        };
-    }
-    /**
-     * Register a text line handler.
-     * Returns an unregister function.
-     */
-    function registerTextLine(handler) {
-        return addToRegistry(textLineHandlers, handler);
-    }
-    /**
-     * Add a skip callback (called when scenariowaitingcancelled fires).
-     * Returns a remove function.
-     */
-    function addSkipCallback(cb) {
-        return addToRegistry(skipCallbacks, cb);
-    }
-    /**
-     * Add an interrupt callback (called on user click, in order).
-     * Return `true` from the callback to consume the click.
-     * Returns a remove function.
-     */
-    function addInterruptCallback(cb) {
-        return addToRegistry(interruptCallbacks, cb);
-    }
-    /**
-     * Try to interrupt: iterate through interrupt callbacks until one returns true.
-     * Returns true if a callback consumed the event.
-     */
-    function tryInterrupt() {
-        for (const cb of interruptCallbacks) {
-            try {
-                if (cb())
-                    return true;
-            }
-            catch (err) {
-                console.error('Error in interrupt callback:', err);
-            }
-        }
-        return false;
-    }
-    // --- skip blocker ---
-    /**
-     * Add a skip blocker callback. Return `true` from the callback to block skipping.
-     * Returns a remove function.
-     */
-    function addSkipBlocker(cb) {
-        return addToRegistry(skipBlockers, cb);
-    }
-    /** Returns true if any registered skip blocker is active. */
-    function isAnyBlockerActive() {
-        for (const cb of skipBlockers) {
-            try {
-                if (cb())
-                    return true;
-            }
-            catch (err) {
-                console.error('Error in skip blocker callback:', err);
-            }
-        }
-        return false;
-    }
-    /**
-     * Add an auto blocker callback. Return `true` from the callback to block auto mode.
-     * Returns a remove function.
-     */
-    function addAutoBlocker(cb) {
-        return addToRegistry(autoBlockers, cb);
-    }
-    /** Returns true if any registered auto blocker is active. */
-    function isAnyAutoBlockerActive() {
-        for (const cb of autoBlockers) {
-            try {
-                if (cb())
-                    return true;
-            }
-            catch (err) {
-                console.error('Error in auto blocker callback:', err);
-            }
-        }
-        return false;
-    }
-    /** Add a callback to be invoked before handling each command. */
-    function addBeforeHandleCommandCallback(cb) {
-        return addToRegistry(beforeHandleCommandCallbacks, cb);
-    }
-    // --- skip (Ctrl fast-forward) management ---
-    let _skipTimer = null;
-    let _autoTimer = null;
-    let _autoBarrier = null;
-    let _autoResumeTimer = null;
-    let _autoCollectFrame = null;
-    let _autoBarrierSeq = 0;
-    let _autoTicketSeq = 0;
-    const _pendingAutoTickets = new Map();
-    function clearAutoResumeTimer() {
-        if (_autoResumeTimer !== null) {
-            clearTimeout(_autoResumeTimer);
-            _autoResumeTimer = null;
-        }
-    }
-    function clearAutoCollectFrame() {
-        if (_autoCollectFrame !== null) {
-            cancelAnimationFrame(_autoCollectFrame);
-            _autoCollectFrame = null;
-        }
-    }
-    function clearAutoBarrier() {
-        clearAutoCollectFrame();
-        clearAutoResumeTimer();
-        _autoBarrier = null;
-    }
-    function clearPendingAutoTickets() {
-        _pendingAutoTickets.clear();
-    }
-    function getActiveAutoBarrier(barrierId) {
-        if (_autoBarrier === null || _autoBarrier.id !== barrierId) {
-            return null;
-        }
-        return _autoBarrier;
-    }
-    function scheduleAutoResume(barrierId, delayMs) {
-        clearAutoResumeTimer();
-        const safeDelayMs = Number.isFinite(delayMs) ? Math.max(0, delayMs) : 0;
-        _autoResumeTimer = setTimeout(() => {
-            _autoResumeTimer = null;
-            if (!exports.autoState.active)
-                return;
-            if (_autoBarrier === null || _autoBarrier.id !== barrierId)
-                return;
-            _autoBarrier = null;
-            void (0, useScenario_1.nextLine)();
-        }, safeDelayMs);
-    }
-    function trySettleAutoBarrier(barrier) {
-        if (barrier.collecting || barrier.settled)
-            return;
-        const activeTickets = [...barrier.tickets.values()].filter((ticket) => !ticket.canceled);
-        const hasPending = activeTickets.some((ticket) => ticket.doneAt === null);
-        if (hasPending)
-            return;
-        const latestTicketReadyAt = activeTickets.reduce((maxReadyAt, ticket) => {
-            const ticketReadyAt = (ticket.doneAt ?? barrier.openedAt) + ticket.tailMs;
-            return Math.max(maxReadyAt, ticketReadyAt);
-        }, barrier.fallbackReadyAt);
-        barrier.settled = true;
-        scheduleAutoResume(barrier.id, latestTicketReadyAt - Date.now());
-    }
-    function closeAutoCollection(barrierId) {
-        const barrier = getActiveAutoBarrier(barrierId);
-        if (barrier === null || barrier.settled)
-            return;
-        barrier.collecting = false;
-        trySettleAutoBarrier(barrier);
-    }
-    function scheduleAutoCollectionClose(barrierId) {
-        queueMicrotask(() => {
-            const barrier = getActiveAutoBarrier(barrierId);
-            if (barrier === null || barrier.settled)
-                return;
-            _autoCollectFrame = requestAnimationFrame(() => {
-                _autoCollectFrame = null;
-                closeAutoCollection(barrierId);
-            });
-        });
-    }
-    function markAutoTicketDone(ticket) {
-        if (ticket.canceled || ticket.doneAt !== null)
-            return;
-        ticket.doneAt = Date.now();
-        if (ticket.barrierId === null)
-            return;
-        const barrier = getActiveAutoBarrier(ticket.barrierId);
-        if (barrier === null || barrier.settled)
-            return;
-        trySettleAutoBarrier(barrier);
-    }
-    function cancelAutoTicket(ticket) {
-        if (ticket.canceled)
-            return;
-        ticket.canceled = true;
-        if (ticket.barrierId === null) {
-            _pendingAutoTickets.delete(ticket.id);
-            return;
-        }
-        const barrier = getActiveAutoBarrier(ticket.barrierId);
-        if (barrier === null || barrier.settled)
-            return;
-        trySettleAutoBarrier(barrier);
-    }
-    function createAutoTicketHandle(ticket) {
-        return {
-            done() {
-                markAutoTicketDone(ticket);
-            },
-            cancel() {
-                cancelAutoTicket(ticket);
-            },
-        };
-    }
-    function schedulePendingAutoTicketExpiry(ticketId) {
-        queueMicrotask(() => {
-            requestAnimationFrame(() => {
-                _pendingAutoTickets.delete(ticketId);
-            });
-        });
-    }
-    function createPendingAutoTicket(options) {
-        const ticketId = ++_autoTicketSeq;
-        const ticket = {
-            id: ticketId,
-            label: options?.label,
-            tailMs: options?.tailMs ?? autoRuntime.defaultTailMs,
-            doneAt: null,
-            canceled: false,
-            barrierId: null,
-        };
-        _pendingAutoTickets.set(ticketId, ticket);
-        schedulePendingAutoTicketExpiry(ticketId);
-        return createAutoTicketHandle(ticket);
-    }
-    function adoptPendingAutoTickets(barrier) {
-        for (const [ticketId, ticket] of _pendingAutoTickets) {
-            _pendingAutoTickets.delete(ticketId);
-            if (ticket.canceled)
-                continue;
-            ticket.barrierId = barrier.id;
-            barrier.tickets.set(ticketId, ticket);
-        }
-    }
-    function openAutoBarrier(reason, fallbackMs) {
-        const safeFallbackMs = Number.isFinite(fallbackMs) ? Math.max(0, fallbackMs) : 0;
-        clearAutoBarrier();
-        _autoBarrier = {
-            id: ++_autoBarrierSeq,
-            reason,
-            collecting: true,
-            openedAt: Date.now(),
-            fallbackReadyAt: Date.now() + safeFallbackMs,
-            tickets: new Map(),
-            settled: false,
-        };
-        adoptPendingAutoTickets(_autoBarrier);
-        scheduleAutoCollectionClose(_autoBarrier.id);
-    }
-    function issueAutoTicket(options) {
-        if (!exports.autoState.active) {
-            return null;
-        }
-        if (_autoBarrier === null) {
-            return createPendingAutoTicket(options);
-        }
-        if (!_autoBarrier.collecting || _autoBarrier.settled) {
-            return null;
-        }
-        const ticketId = ++_autoTicketSeq;
-        const ticket = {
-            id: ticketId,
-            label: options?.label,
-            tailMs: options?.tailMs ?? autoRuntime.defaultTailMs,
-            doneAt: null,
-            canceled: false,
-            barrierId: _autoBarrier.id,
-        };
-        _autoBarrier.tickets.set(ticketId, ticket);
-        return createAutoTicketHandle(ticket);
-    }
-    /** Schedule a delayed nextLine() call for the auto. */
-    function scheduleAutoNextLine() {
-        if (_autoTimer !== null)
-            clearTimeout(_autoTimer);
-        _autoTimer = setTimeout(() => {
-            _autoTimer = null;
-            if (!exports.autoState.active)
-                return;
-            if (isAnyAutoBlockerActive()) {
-                stopAuto();
-                return;
-            }
-            if (_autoBarrier === null) {
-                void (0, useScenario_1.nextLine)();
-            }
-        }, autoRuntime.defaultTailMs);
-    }
-    /** Schedule a delayed nextLine() call for the skip chain. */
-    function scheduleSkipNextLine() {
-        if (_skipTimer !== null)
-            clearTimeout(_skipTimer);
-        _skipTimer = setTimeout(() => {
-            _skipTimer = null;
-            if (exports.skipState.active)
-                (0, useScenario_1.nextLine)();
-        }, SKIP_INTERVAL_MS);
-    }
-    /** Enter skip mode. Called when Ctrl is pressed. */
-    function startSkip() {
-        if (exports.skipState.active)
-            return;
-        if (isAnyBlockerActive())
-            return;
-        exports.skipState.active = true;
-        invokeSkipCallbacks(); // finish current animations
-        tryInterrupt(); // finish current printing
-        scheduleSkipNextLine(); // kick off the chain
-    }
-    /** Exit skip mode. Called when Ctrl is released, window blurs, or Stage unmounts. */
-    function stopSkip() {
-        exports.skipState.active = false;
-        if (_skipTimer !== null) {
-            clearTimeout(_skipTimer);
-            _skipTimer = null;
-            // ensure engine continues normally
-            (0, useScenario_1.nextLine)();
-        }
-    }
-    function isSkipping() {
-        return exports.skipState.active;
-    }
-    function startAuto() {
-        if (exports.autoState.active)
-            return;
-        if (isAnyAutoBlockerActive())
-            return;
-        exports.autoState.active = true;
-        tryInterrupt(); // finish current printing
-        scheduleAutoNextLine(); // kick off the chain
-    }
-    function stopAuto() {
-        exports.autoState.active = false;
-        if (_autoTimer !== null) {
-            clearTimeout(_autoTimer);
-            _autoTimer = null;
-        }
-        clearAutoBarrier();
-        clearPendingAutoTickets();
-    }
-    function isAutoing() {
-        return exports.autoState.active;
-    }
-    // --- internal helpers ---
-    /** Build a one-shot GameControl for a single dispatch cycle. */
-    function buildControl() {
-        let handled = false;
-        let unskippableFlag = false;
-        const control = {
-            setWaiting(time, skippable) {
-                handled = true;
-                if (exports.skipState.active) {
-                    // Skip mode: finish residual animations and continue the chain
-                    invokeSkipCallbacks();
-                    scheduleSkipNextLine();
-                }
-                else if (exports.autoState.active) {
-                    if (isAnyAutoBlockerActive()) {
-                        stopAuto();
-                        (0, useScenario_1.setWaiting)(time, skippable);
-                    }
-                    else {
-                        openAutoBarrier('wait', time);
-                    }
-                }
-                else {
-                    (0, useScenario_1.setWaiting)(time, skippable);
-                }
-            },
-            hold() {
-                handled = true;
-                if (exports.skipState.active && !unskippableFlag) {
-                    if (isAnyBlockerActive()) {
-                        stopSkip();
-                    }
-                    else {
-                        scheduleSkipNextLine();
-                    }
-                }
-                else if (exports.skipState.active && unskippableFlag) {
-                    stopSkip();
-                }
-                else if (exports.autoState.active) {
-                    if (isAnyAutoBlockerActive()) {
-                        stopAuto();
-                    }
-                    else {
-                        openAutoBarrier('hold', 0);
-                    }
-                }
-                // When not skipping: do nothing (normal hold behavior)
-            },
-            nextLine() {
-                handled = true;
-                void (0, useScenario_1.nextLine)();
-            },
-            unskippable() {
-                unskippableFlag = true;
-            },
-            record(meta) {
-                const result = (0, moyu_1.executePluginCommand)('scenario', {
-                    subCommand: 'record',
-                    meta,
-                });
-                if (result && typeof result.then === 'function') {
-                    throw new Error('Scenario record command unexpectedly returned a Promise');
-                }
-                return result;
-            },
-        };
-        return { control, wasHandled: () => handled };
-    }
-    // Transform actual command object to a more convenient format
-    function transformCommand(command) {
-        if (commandSchema === null) {
-            throw new Error('No command schema registered in Stage');
-        }
-        const parsed = commandSchema.safeParse({
-            command: command.command,
-            ...Object.fromEntries(command.arguments.map((arg) => [arg.name, arg.value])),
-        });
-        if (!parsed.success) {
-            throw new Error(`Invalid command: ${command.command} with arguments ${JSON.stringify(command.arguments)}`);
-        }
-        return parsed.data;
-    }
-    /** Dispatch a scenariocommandline event. */
-    function dispatchCommand(e) {
-        for (const cb of beforeHandleCommandCallbacks) {
-            try {
-                cb(e);
-            }
-            catch (err) {
-                console.error('Error in beforeHandleCommand callback:', err);
-            }
-        }
-        let cmd;
-        try {
-            cmd = transformCommand(e);
-        }
-        catch (err) {
-            console.error('Failed to transform scenario command:', err);
-            void (0, useScenario_1.nextLine)();
-            return;
-        }
-        const handler = commandHandlers.get(cmd.command);
-        if (!handler) {
-            console.warn(`[Stage] No handler registered for command "${cmd.command}". Auto-advancing.`);
-            void (0, useScenario_1.nextLine)();
-            return;
-        }
-        const { control, wasHandled } = buildControl();
-        handler(cmd, control);
-        // Default: auto-advance if handler didn't explicitly control flow
-        if (!wasHandled()) {
-            void (0, useScenario_1.nextLine)();
-        }
-    }
-    /** Dispatch a scenariotext event. */
-    function dispatchTextLine(e) {
-        const { control, wasHandled } = buildControl();
-        for (const handler of textLineHandlers) {
-            handler(e, control);
-        }
-        if (!wasHandled()) {
-            void (0, useScenario_1.nextLine)();
-        }
-    }
-    /** Invoke all skip callbacks. */
-    function invokeSkipCallbacks() {
-        for (const cb of skipCallbacks) {
-            try {
-                cb();
-            }
-            catch (err) {
-                console.error('Error in skip callback:', err);
-            }
-        }
-    }
-    // --- bind engine events (called inside StageContextProvider's useEffect) ---
-    function bindEvents() {
-        const cleanups = [
-            (0, events_1.addEventListener)('scenariocommandline', (e) => {
-                dispatchCommand(e);
-            }),
-            (0, events_1.addEventListener)('scenariotext', (e) => {
-                dispatchTextLine(e);
-            }),
-            (0, events_1.addEventListener)('scenariowaiting', () => {
-                console.log('still waiting...');
-            }),
-            (0, events_1.addEventListener)('scenariowaitingcancelled', () => {
-                invokeSkipCallbacks();
-            }),
-        ];
-        return () => {
-            for (const cleanup of cleanups)
-                cleanup();
-        };
-    }
-    return {
-        registerCommandSchema,
-        registerCommand,
-        registerTextLine,
-        addSkipCallback,
-        addInterruptCallback,
-        addSkipBlocker,
-        addAutoBlocker,
-        addBeforeHandleCommandCallback,
-        issueAutoTicket,
-        tryInterrupt,
-        startSkip,
-        stopSkip,
-        isSkipping,
-        startAuto,
-        stopAuto,
-        isAutoing,
-        bindEvents,
-    };
-}
-const StageContext = (0, react_1.createContext)(null);
-/** Access the stage instance from within StageContextProvider. */
-function useStageContext() {
-    const ctx = (0, react_1.useContext)(StageContext);
-    if (!ctx)
-        throw new Error('useStageContext must be used within StageContextProvider');
-    return ctx;
-}
-// ---------------------------------------------------------------------------
-// StageContextProvider — binds engine events within React lifecycle
-// ---------------------------------------------------------------------------
-function StageContextProvider({ stage, children }) {
-    // Bind engine events on mount, unbind on unmount
-    (0, react_1.useEffect)(() => {
-        return stage.bindEvents();
-    }, [stage]);
-    return (0, react_1.createElement)(StageContext.Provider, { value: stage }, children);
-}
-// ---------------------------------------------------------------------------
-// Actor hooks — register skip / interrupt callbacks
-// ---------------------------------------------------------------------------
-/**
- * Register a skip callback that fires when scenariowaitingcancelled is received.
- * Automatically removed on unmount.
- */
-function useSkipCallback(callback) {
-    const stage = useStageContext();
-    (0, react_1.useEffect)(() => {
-        return stage.addSkipCallback(callback);
-    }, [stage, callback]);
-}
-/**
- * Register an interrupt callback for user click handling.
- * Return `true` from the callback to consume the click.
- * Automatically removed on unmount.
- */
-function useInterruptCallback(callback) {
-    const stage = useStageContext();
-    (0, react_1.useEffect)(() => {
-        return stage.addInterruptCallback(callback);
-    }, [stage, callback]);
-}
-/**
- * Register a skip blocker callback. Return `true` to block skipping.
- * When any blocker is active, skip mode cannot start or will be stopped.
- * Automatically removed on unmount.
- *
- * NOTE: `callback` must be a stable reference (wrap with `useCallback`).
- */
-function useSkipBlocker(callback) {
-    const stage = useStageContext();
-    (0, react_1.useEffect)(() => {
-        return stage.addSkipBlocker(callback);
-    }, [stage, callback]);
-}
-/**
- * Register an auto blocker callback. Return `true` to block auto mode.
- * Automatically removed on unmount.
- *
- * NOTE: `callback` must be a stable reference (wrap with `useCallback`).
- */
-function useAutoBlocker(callback) {
-    const stage = useStageContext();
-    (0, react_1.useEffect)(() => {
-        return stage.addAutoBlocker(callback);
-    }, [stage, callback]);
-}
-/**
- * Get a function that issues an auto ticket for the current active barrier.
- * Returns `null` when auto is inactive or the collection window has closed.
- */
-function useAutoTicket() {
-    const stage = useStageContext();
-    return (0, react_1.useCallback)((options) => {
-        return stage.issueAutoTicket(options);
-    }, [stage]);
-}
-/**
- * Register a callback to be invoked before handling each command.
- * The callback receives the upcoming command object, allowing conditional logic.
- * Automatically removed on unmount.
- */
-function useBeforeHandleCommandCallback(callback) {
-    const stage = useStageContext();
-    (0, react_1.useEffect)(() => {
-        return stage.addBeforeHandleCommandCallback(callback);
-    }, [stage, callback]);
-}

package/dist/hooks.d.ts

@@ -1,4 +0,0 @@
-export * from './hooks/useFadeInOut';
-export * from './hooks/useScenario';
-export * from './hooks/useSoundEffect';
-export * from './hooks/useStage';