@luna-editor/engine 0.1.0 → 0.3.0

package/dist/contexts/DataContext.js

@@ -2,6 +2,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, } from "react";
 const DataContextInstance = createContext(null);
 const SubscribersContext = createContext(null);
+const SettingsUpdaterContext = createContext(null);
 /**
  * データプロバイダー
  * プラグインがシナリオ情報にリアクティブにアクセスするためのProvider
@@ -15,9 +16,8 @@ const SubscribersContext = createContext(null);
  * </DataProvider>
  * ```
  */
-export const DataProvider = ({ data, children }) => {
-    const subscribers = useMemo(() => new Map(), // eslint-disable-line @typescript-eslint/no-explicit-any
-    []);
+export const DataProvider = ({ data, onSettingsUpdate, children }) => {
+    const subscribers = useMemo(() => new Map(), []);
     const previousDataRef = useRef(data);
     // データ変更時に購読者に通知
     useEffect(() => {
@@ -31,16 +31,20 @@ export const DataProvider = ({ data, children }) => {
             if (prevValue !== currentValue) {
                 // カテゴリ全体の購読者に通知
                 const categorySubscribers = subscribers.get(key);
-                categorySubscribers === null || categorySubscribers === void 0 ? void 0 : categorySubscribers.forEach((callback) => callback(currentValue));
+                categorySubscribers === null || categorySubscribers === void 0 ? void 0 : categorySubscribers.forEach((callback) => {
+                    callback(currentValue);
+                });
                 // 個別プロパティの変更をチェック
                 if (typeof currentValue === "object" && currentValue !== null) {
                     for (const prop of Object.keys(currentValue)) {
-                        const prevPropValue = prevValue === null || prevValue === void 0 ? void 0 : prevValue[prop]; // eslint-disable-line @typescript-eslint/no-explicit-any
-                        const currentPropValue = currentValue[prop]; // eslint-disable-line @typescript-eslint/no-explicit-any
+                        const prevPropValue = prevValue === null || prevValue === void 0 ? void 0 : prevValue[prop];
+                        const currentPropValue = currentValue[prop];
                         if (prevPropValue !== currentPropValue) {
                             const propKey = `${key}.${prop}`;
                             const propSubscribers = subscribers.get(propKey);
-                            propSubscribers === null || propSubscribers === void 0 ? void 0 : propSubscribers.forEach((callback) => callback(currentPropValue));
+                            propSubscribers === null || propSubscribers === void 0 ? void 0 : propSubscribers.forEach((callback) => {
+                                callback(currentPropValue);
+                            });
                         }
                     }
                 }
@@ -48,7 +52,7 @@ export const DataProvider = ({ data, children }) => {
         }
         previousDataRef.current = data;
     }, [data, subscribers]);
-    return (_jsx(SubscribersContext.Provider, { value: subscribers, children: _jsx(DataContextInstance.Provider, { value: data, children: children }) }));
+    return (_jsx(SubscribersContext.Provider, { value: subscribers, children: _jsx(SettingsUpdaterContext.Provider, { value: onSettingsUpdate !== null && onSettingsUpdate !== void 0 ? onSettingsUpdate : null, children: _jsx(DataContextInstance.Provider, { value: data, children: children }) }) }));
 };
 /**
  * DataAPI実装を提供するフック
@@ -57,13 +61,17 @@ export const DataProvider = ({ data, children }) => {
 export function useDataAPI() {
     const data = useContext(DataContextInstance);
     const subscribers = useContext(SubscribersContext);
+    const settingsUpdater = useContext(SettingsUpdaterContext);
     if (!data || !subscribers) {
         throw new Error("useDataAPI must be used within DataProvider");
     }
     const get = useCallback((key, property) => {
-        var _a;
         if (property !== undefined) {
-            return (_a = data[key]) === null || _a === void 0 ? void 0 : _a[property];
+            const value = data[key];
+            if (value && typeof value === "object" && property in value) {
+                return value[property];
+            }
+            return undefined;
         }
         return data[key];
     }, [data]);
@@ -77,7 +85,8 @@ export function useDataAPI() {
         // unsubscribe関数を返す
         return () => {
             var _a;
-            (_a = subscribers.get(subscriberKey)) === null || _a === void 0 ? void 0 : _a.delete(callback);
+            (_a = subscribers
+                .get(subscriberKey)) === null || _a === void 0 ? void 0 : _a.delete(callback);
         };
     }, [subscribers]);
     const watch = useCallback((key, property, callback) => {
@@ -90,12 +99,72 @@ export function useDataAPI() {
         // unsubscribe関数を返す
         return () => {
             var _a;
-            (_a = subscribers.get(subscriberKey)) === null || _a === void 0 ? void 0 : _a.delete(callback);
+            (_a = subscribers
+                .get(subscriberKey)) === null || _a === void 0 ? void 0 : _a.delete(callback);
         };
     }, [subscribers]);
+    const updateSettings = useCallback((settings) => {
+        if (settingsUpdater) {
+            settingsUpdater(settings);
+        }
+        else {
+            console.warn("updateSettings called but no settings updater provided");
+        }
+    }, [settingsUpdater]);
+    const setBgmVolume = useCallback((volume) => {
+        const clampedVolume = Math.max(0, Math.min(1, volume));
+        updateSettings({ bgmVolume: clampedVolume });
+    }, [updateSettings]);
+    const setSeVolume = useCallback((volume) => {
+        const clampedVolume = Math.max(0, Math.min(1, volume));
+        updateSettings({ seVolume: clampedVolume });
+    }, [updateSettings]);
+    const setVoiceVolume = useCallback((volume) => {
+        const clampedVolume = Math.max(0, Math.min(1, volume));
+        updateSettings({ voiceVolume: clampedVolume });
+    }, [updateSettings]);
+    const setVolumes = useCallback((volumes) => {
+        const settings = {};
+        if (volumes.bgm !== undefined) {
+            settings.bgmVolume = Math.max(0, Math.min(1, volumes.bgm));
+        }
+        if (volumes.se !== undefined) {
+            settings.seVolume = Math.max(0, Math.min(1, volumes.se));
+        }
+        if (volumes.voice !== undefined) {
+            settings.voiceVolume = Math.max(0, Math.min(1, volumes.voice));
+        }
+        if (Object.keys(settings).length > 0) {
+            updateSettings(settings);
+        }
+    }, [updateSettings]);
+    const getBlockOption = useCallback((key) => {
+        var _a;
+        const currentBlock = (_a = data.playback) === null || _a === void 0 ? void 0 : _a.currentBlock;
+        if (!(currentBlock === null || currentBlock === void 0 ? void 0 : currentBlock.options)) {
+            return undefined;
+        }
+        return currentBlock.options[key];
+    }, [data]);
     return useMemo(() => ({
         get,
         subscribe,
         watch,
-    }), [get, subscribe, watch]);
+        updateSettings,
+        setBgmVolume,
+        setSeVolume,
+        setVoiceVolume,
+        setVolumes,
+        getBlockOption,
+    }), [
+        get,
+        subscribe,
+        watch,
+        updateSettings,
+        setBgmVolume,
+        setSeVolume,
+        setVoiceVolume,
+        setVolumes,
+        getBlockOption,
+    ]);
 }

package/dist/hooks/useBacklog.js

@@ -37,6 +37,7 @@ export function useBacklog({ scenario, currentBlockIndex, currentBlock, }) {
                     content: block.content,
                     speakerName: (_a = block.speaker) === null || _a === void 0 ? void 0 : _a.name,
                     speakerState: (_b = block.speakerState) === null || _b === void 0 ? void 0 : _b.name,
+                    options: block.options,
                 };
                 addLogEntry(logEntry);
                 processedBlocks.current.add(realIndex);
@@ -63,6 +64,7 @@ export function useBacklog({ scenario, currentBlockIndex, currentBlock, }) {
                     content: currentBlock.content,
                     speakerName: (_a = currentBlock.speaker) === null || _a === void 0 ? void 0 : _a.name,
                     speakerState: (_b = currentBlock.speakerState) === null || _b === void 0 ? void 0 : _b.name,
+                    options: currentBlock.options,
                 };
                 addLogEntry(logEntry);
                 processedBlocks.current.add(currentBlockIndex);
@@ -70,6 +72,7 @@ export function useBacklog({ scenario, currentBlockIndex, currentBlock, }) {
         }
     }, [currentBlock, currentBlockIndex, addLogEntry]);
     // シナリオ変更時にリセット
+    // biome-ignore lint/correctness/useExhaustiveDependencies: scenario.idの変更を検知してログをクリアする意図的な依存
     useEffect(() => {
         clearLogs();
     }, [scenario.id, clearLogs]);

package/dist/hooks/useConversationBranch.d.ts

@@ -0,0 +1,16 @@
+import type { ConversationBranchState, ConversationChoice, PublishedScenario } from "../types";
+import type { VariableManager } from "../utils/variableManager";
+interface UseConversationBranchProps {
+    apiBaseUrl: string;
+    variableManager?: VariableManager | null;
+    scenario?: PublishedScenario;
+}
+interface UseConversationBranchReturn {
+    branchState: ConversationBranchState;
+    loadBranch: (blockId: string) => Promise<void>;
+    selectChoice: (choiceId: string) => void;
+    getSelectedChoiceFullData: (choiceId?: string) => ConversationChoice | null;
+    resetBranch: () => void;
+}
+export declare function useConversationBranch({ apiBaseUrl, variableManager, scenario, }: UseConversationBranchProps): UseConversationBranchReturn;
+export {};

package/dist/hooks/useConversationBranch.js

@@ -0,0 +1,125 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useCallback, useRef, useState } from "react";
+import { fetchConversationBranch } from "../api/conversationBranch";
+function validateBranchStructure(branch) {
+    if (!branch.branchChoices || branch.branchChoices.length === 0) {
+        return "DATA_MISSING";
+    }
+    if (branch.branchChoices.length < 2 || branch.branchChoices.length > 3) {
+        return "INVALID_STRUCTURE";
+    }
+    for (const choice of branch.branchChoices) {
+        if (!choice.id) {
+            return "INVALID_STRUCTURE";
+        }
+        if (branch.branchType === "choice" && !choice.choiceText) {
+            return "INVALID_STRUCTURE";
+        }
+    }
+    return null;
+}
+export function useConversationBranch({ apiBaseUrl, variableManager, scenario, }) {
+    const [branchState, setBranchState] = useState({
+        isActive: false,
+        currentChoices: [],
+        selectedChoiceId: null,
+        errorState: null,
+    });
+    const fullBranchDataRef = useRef(null);
+    const loadBranch = useCallback((blockId) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        try {
+            const branchData = yield fetchConversationBranch(blockId, apiBaseUrl);
+            fullBranchDataRef.current = branchData;
+            const validationError = validateBranchStructure(branchData);
+            if (validationError) {
+                setBranchState({
+                    isActive: false,
+                    currentChoices: [],
+                    selectedChoiceId: null,
+                    errorState: validationError,
+                });
+                return;
+            }
+            if (branchData.branchType === "variable" &&
+                variableManager &&
+                scenario) {
+                const conditions = ((_a = scenario.variableBranchConditions) === null || _a === void 0 ? void 0 : _a.filter((c) => c.branchId === branchData.id).sort((a, b) => a.order - b.order)) || [];
+                let selectedChoiceId = null;
+                for (const condition of conditions) {
+                    if (variableManager.evaluateCondition(condition)) {
+                        selectedChoiceId = condition.choiceId;
+                        break;
+                    }
+                }
+                setBranchState({
+                    isActive: true,
+                    branchType: "variable",
+                    currentChoices: [],
+                    selectedChoiceId,
+                    errorState: selectedChoiceId ? null : "NO_MATCHING_CONDITION",
+                });
+            }
+            else {
+                const choices = branchData.branchChoices
+                    .map((choice) => ({
+                    id: choice.id,
+                    text: choice.choiceText,
+                    order: choice.order,
+                    isDisabled: false,
+                }))
+                    .sort((a, b) => a.order - b.order);
+                setBranchState({
+                    isActive: true,
+                    branchType: "choice",
+                    currentChoices: choices,
+                    selectedChoiceId: null,
+                    errorState: null,
+                });
+            }
+        }
+        catch (_b) {
+            setBranchState({
+                isActive: false,
+                currentChoices: [],
+                selectedChoiceId: null,
+                errorState: "NETWORK_ERROR",
+            });
+        }
+    }), [apiBaseUrl, variableManager, scenario]);
+    const selectChoice = useCallback((choiceId) => {
+        setBranchState((prev) => (Object.assign(Object.assign({}, prev), { selectedChoiceId: choiceId })));
+    }, []);
+    const getSelectedChoiceFullData = useCallback((choiceId) => {
+        const targetChoiceId = choiceId || branchState.selectedChoiceId;
+        if (!fullBranchDataRef.current || !targetChoiceId) {
+            return null;
+        }
+        const choice = fullBranchDataRef.current.branchChoices.find((c) => c.id === targetChoiceId);
+        return choice || null;
+    }, [branchState.selectedChoiceId]);
+    const resetBranch = useCallback(() => {
+        setBranchState({
+            isActive: false,
+            currentChoices: [],
+            selectedChoiceId: null,
+            errorState: null,
+        });
+        fullBranchDataRef.current = null;
+    }, []);
+    return {
+        branchState,
+        loadBranch,
+        selectChoice,
+        getSelectedChoiceFullData,
+        resetBranch,
+    };
+}

package/dist/hooks/useFontLoader.d.ts

@@ -0,0 +1,23 @@
+import type { WorkFont } from "../types";
+/**
+ * フォントを読み込むカスタムフック
+ * - Googleフォント: <link>タグで読み込み + document.fonts.load()でプリロード
+ * - カスタムフォント: FontFace APIで読み込み
+ * - すべてのフォントがプリロード&キャッシュされてからisLoaded=trueになる
+ */
+export declare function useFontLoader(fonts: WorkFont[] | undefined): {
+    isLoaded: boolean;
+    loadedFonts: string[];
+};
+/**
+ * フォントファミリーに基づいてCSSのfont-family値を生成
+ */
+export declare function getFontFamilyStyle(selectedFontFamily: string | undefined, fonts: WorkFont[] | undefined): string;
+/**
+ * フォントがキャッシュに存在するかチェック
+ */
+export declare function isFontCached(fontFamily: string): boolean;
+/**
+ * キャッシュをクリア（主にテスト用）
+ */
+export declare function clearFontCache(): void;

package/dist/hooks/useFontLoader.js

@@ -0,0 +1,153 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useEffect, useRef, useState } from "react";
+// グローバルなフォントキャッシュ（ページ内で共有）
+const fontCache = new Set();
+/**
+ * フォントを読み込むカスタムフック
+ * - Googleフォント: <link>タグで読み込み + document.fonts.load()でプリロード
+ * - カスタムフォント: FontFace APIで読み込み
+ * - すべてのフォントがプリロード&キャッシュされてからisLoaded=trueになる
+ */
+export function useFontLoader(fonts) {
+    const [isLoaded, setIsLoaded] = useState(false);
+    const [loadedFonts, setLoadedFonts] = useState([]);
+    const loadingRef = useRef(false);
+    useEffect(() => {
+        if (!fonts || fonts.length === 0) {
+            setIsLoaded(true);
+            return;
+        }
+        // 既に読み込み中の場合はスキップ
+        if (loadingRef.current)
+            return;
+        loadingRef.current = true;
+        const loadFonts = () => __awaiter(this, void 0, void 0, function* () {
+            const loadedFontFamilies = [];
+            const fontLoadPromises = [];
+            for (const font of fonts) {
+                // キャッシュにあればスキップ
+                if (fontCache.has(font.fontFamily)) {
+                    loadedFontFamilies.push(font.fontFamily);
+                    continue;
+                }
+                try {
+                    if (font.type === "google") {
+                        // Googleフォントを<link>タグで読み込み
+                        const existingLink = document.querySelector(`link[data-font-family="${font.fontFamily}"]`);
+                        if (!existingLink) {
+                            const link = document.createElement("link");
+                            link.rel = "stylesheet";
+                            link.href = `https://fonts.googleapis.com/css2?family=${encodeURIComponent(font.fontFamily)}:wght@400;700&display=swap`;
+                            link.setAttribute("data-font-family", font.fontFamily);
+                            document.head.appendChild(link);
+                            // CSSファイルの読み込み完了を待つ
+                            yield new Promise((resolve) => {
+                                link.onload = () => resolve();
+                                link.onerror = () => {
+                                    console.warn(`Failed to load Google font CSS: ${font.fontFamily}`);
+                                    resolve();
+                                };
+                            });
+                        }
+                        // フォントの実際の読み込み（プリロード）を開始
+                        // document.fonts.load()でフォントデータを事前にダウンロード
+                        const preloadPromise = document.fonts
+                            .load(`16px "${font.fontFamily}"`)
+                            .then(() => {
+                            fontCache.add(font.fontFamily);
+                            loadedFontFamilies.push(font.fontFamily);
+                        })
+                            .catch((error) => {
+                            console.warn(`Failed to preload Google font: ${font.fontFamily}`, error);
+                            // エラーでもキャッシュに追加（再試行防止）
+                            fontCache.add(font.fontFamily);
+                            loadedFontFamilies.push(font.fontFamily);
+                        });
+                        fontLoadPromises.push(preloadPromise);
+                    }
+                    else if (font.type === "custom" && font.url) {
+                        // カスタムフォントをFontFace APIで読み込み
+                        const loadCustomFont = () => __awaiter(this, void 0, void 0, function* () {
+                            try {
+                                // 既にdocument.fontsに登録されているかチェック
+                                let fontExists = false;
+                                for (const existingFont of document.fonts) {
+                                    if (existingFont.family === font.fontFamily) {
+                                        fontExists = true;
+                                        break;
+                                    }
+                                }
+                                if (!fontExists) {
+                                    const fontFace = new FontFace(font.fontFamily, `url(${font.url})`);
+                                    // フォントデータをダウンロード&パース
+                                    yield fontFace.load();
+                                    // document.fontsに追加（キャッシュとして機能）
+                                    document.fonts.add(fontFace);
+                                }
+                                fontCache.add(font.fontFamily);
+                                loadedFontFamilies.push(font.fontFamily);
+                            }
+                            catch (error) {
+                                console.warn(`Failed to load custom font: ${font.name}`, error);
+                                // エラーでもキャッシュに追加（再試行防止）
+                                fontCache.add(font.fontFamily);
+                                loadedFontFamilies.push(font.fontFamily);
+                            }
+                        });
+                        fontLoadPromises.push(loadCustomFont());
+                    }
+                }
+                catch (error) {
+                    console.warn(`Failed to load font: ${font.name}`, error);
+                }
+            }
+            // すべてのフォント読み込みを並列で待つ
+            yield Promise.all(fontLoadPromises);
+            // document.fonts.readyで全フォントの準備完了を確認
+            yield document.fonts.ready;
+            setLoadedFonts(loadedFontFamilies);
+            setIsLoaded(true);
+            loadingRef.current = false;
+        });
+        loadFonts();
+    }, [fonts]);
+    return { isLoaded, loadedFonts };
+}
+/**
+ * フォントファミリーに基づいてCSSのfont-family値を生成
+ */
+export function getFontFamilyStyle(selectedFontFamily, fonts) {
+    if (!fonts || fonts.length === 0) {
+        // フォントが設定されていない場合はデフォルトフォント
+        return "sans-serif";
+    }
+    // 選択されたフォントファミリーが指定されている場合
+    if (selectedFontFamily) {
+        const selectedFont = fonts.find((f) => f.fontFamily === selectedFontFamily);
+        if (selectedFont) {
+            return `"${selectedFontFamily}", sans-serif`;
+        }
+    }
+    // 選択されていない、または見つからない場合はデフォルト（最初の）フォントを使用
+    return `"${fonts[0].fontFamily}", sans-serif`;
+}
+/**
+ * フォントがキャッシュに存在するかチェック
+ */
+export function isFontCached(fontFamily) {
+    return fontCache.has(fontFamily);
+}
+/**
+ * キャッシュをクリア（主にテスト用）
+ */
+export function clearFontCache() {
+    fontCache.clear();
+}

package/dist/hooks/useFullscreenText.d.ts

@@ -0,0 +1,17 @@
+import type { ScenarioBlock } from "../types";
+export interface UseFullscreenTextOptions {
+    textSpeed?: number;
+    onParagraphComplete?: (index: number) => void;
+    onAllComplete?: () => void;
+}
+export interface UseFullscreenTextReturn {
+    paragraphs: string[];
+    currentParagraphIndex: number;
+    displayText: string;
+    isTyping: boolean;
+    isComplete: boolean;
+    advanceParagraph: () => boolean;
+    skipTypewriter: () => void;
+    reset: () => void;
+}
+export declare function useFullscreenText(block: ScenarioBlock | null, options?: UseFullscreenTextOptions): UseFullscreenTextReturn;

package/dist/hooks/useFullscreenText.js

@@ -0,0 +1,120 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+export function useFullscreenText(block, options = {}) {
+    const { textSpeed = 80, onParagraphComplete, onAllComplete } = options;
+    const [paragraphs, setParagraphs] = useState([]);
+    const [currentParagraphIndex, setCurrentParagraphIndex] = useState(0);
+    const [displayText, setDisplayText] = useState("");
+    const [isTyping, setIsTyping] = useState(false);
+    const [completedParagraphs, setCompletedParagraphs] = useState(new Set());
+    const typingTimeoutRef = useRef(null);
+    // Parse content into paragraphs
+    useEffect(() => {
+        if (!block || block.blockType !== "fullscreen_text") {
+            setParagraphs([]);
+            setCurrentParagraphIndex(0);
+            setDisplayText("");
+            setCompletedParagraphs(new Set());
+            return;
+        }
+        const content = block.content || "";
+        const parsed = content.split(/\n\n+/).filter((p) => p.trim());
+        setParagraphs(parsed);
+        setCurrentParagraphIndex(0);
+        setDisplayText("");
+        setCompletedParagraphs(new Set());
+    }, [block]);
+    // Typewriter effect
+    useEffect(() => {
+        if (paragraphs.length === 0)
+            return;
+        if (currentParagraphIndex >= paragraphs.length)
+            return;
+        if (completedParagraphs.has(currentParagraphIndex)) {
+            setDisplayText(paragraphs[currentParagraphIndex]);
+            return;
+        }
+        if (textSpeed <= 0) {
+            setDisplayText(paragraphs[currentParagraphIndex]);
+            setCompletedParagraphs((prev) => new Set(prev).add(currentParagraphIndex));
+            onParagraphComplete === null || onParagraphComplete === void 0 ? void 0 : onParagraphComplete(currentParagraphIndex);
+            return;
+        }
+        setIsTyping(true);
+        const text = paragraphs[currentParagraphIndex];
+        let charIndex = 0;
+        const typeChar = () => {
+            if (charIndex < text.length) {
+                setDisplayText(text.slice(0, charIndex + 1));
+                charIndex++;
+                typingTimeoutRef.current = setTimeout(typeChar, textSpeed);
+            }
+            else {
+                setIsTyping(false);
+                setCompletedParagraphs((prev) => new Set(prev).add(currentParagraphIndex));
+                onParagraphComplete === null || onParagraphComplete === void 0 ? void 0 : onParagraphComplete(currentParagraphIndex);
+            }
+        };
+        typeChar();
+        return () => {
+            if (typingTimeoutRef.current) {
+                clearTimeout(typingTimeoutRef.current);
+            }
+        };
+    }, [
+        paragraphs,
+        currentParagraphIndex,
+        textSpeed,
+        completedParagraphs,
+        onParagraphComplete,
+    ]);
+    const skipTypewriter = useCallback(() => {
+        if (typingTimeoutRef.current) {
+            clearTimeout(typingTimeoutRef.current);
+        }
+        if (paragraphs[currentParagraphIndex]) {
+            setDisplayText(paragraphs[currentParagraphIndex]);
+            setIsTyping(false);
+            setCompletedParagraphs((prev) => new Set(prev).add(currentParagraphIndex));
+            onParagraphComplete === null || onParagraphComplete === void 0 ? void 0 : onParagraphComplete(currentParagraphIndex);
+        }
+    }, [paragraphs, currentParagraphIndex, onParagraphComplete]);
+    const advanceParagraph = useCallback(() => {
+        if (isTyping) {
+            skipTypewriter();
+            return true;
+        }
+        if (currentParagraphIndex < paragraphs.length - 1) {
+            setCurrentParagraphIndex((prev) => prev + 1);
+            return true;
+        }
+        onAllComplete === null || onAllComplete === void 0 ? void 0 : onAllComplete();
+        return false;
+    }, [
+        isTyping,
+        currentParagraphIndex,
+        paragraphs.length,
+        skipTypewriter,
+        onAllComplete,
+    ]);
+    const reset = useCallback(() => {
+        setCurrentParagraphIndex(0);
+        setDisplayText("");
+        setCompletedParagraphs(new Set());
+        setIsTyping(false);
+        if (typingTimeoutRef.current) {
+            clearTimeout(typingTimeoutRef.current);
+        }
+    }, []);
+    return {
+        paragraphs,
+        currentParagraphIndex,
+        displayText,
+        isTyping,
+        isComplete: currentParagraphIndex >= paragraphs.length - 1 &&
+            !isTyping &&
+            paragraphs.length > 0,
+        advanceParagraph,
+        skipTypewriter,
+        reset,
+    };
+}

package/dist/hooks/usePlayerLogic.d.ts

@@ -1,16 +1,23 @@
-import type { DisplayedCharacter, PlayerState, PublishedScenario, ScenarioBlock } from "../types";
+import type { ConversationBranchState, DisplayedCharacter, PlayerState, PublishedScenario, ScenarioBlock } from "../types";
+import type { BranchNavigator } from "../utils/branchNavigator";
+import type { VariableManager } from "../utils/variableManager";
 interface UsePlayerLogicProps {
     state: PlayerState;
     setState: React.Dispatch<React.SetStateAction<PlayerState>>;
     scenario: PublishedScenario;
     isTyping: boolean;
     currentBlock: ScenarioBlock;
-    skipTyping: (text: string) => void;
+    skipTyping: () => void;
     onEnd?: () => void;
     onScenarioEnd?: () => void;
     autoplay: boolean;
+    branchState?: ConversationBranchState;
+    branchNavigator?: BranchNavigator;
+    customRestart?: () => void;
+    variableManager?: VariableManager | null;
+    disableKeyboardNavigation?: boolean;
 }
-export declare const usePlayerLogic: ({ state, setState, scenario, isTyping, currentBlock, skipTyping, onEnd, onScenarioEnd, autoplay, }: UsePlayerLogicProps) => {
+export declare const usePlayerLogic: ({ state, setState, scenario, isTyping, currentBlock, skipTyping, onEnd, onScenarioEnd, autoplay, branchState, branchNavigator: _branchNavigator, customRestart, variableManager, disableKeyboardNavigation, }: UsePlayerLogicProps) => {
     handleNext: () => void;
     handlePrevious: () => void;
     togglePlay: () => void;