@luna-editor/engine 0.2.0 → 0.3.1

package/dist/hooks/useBacklog.js

@@ -25,7 +25,6 @@ export function useBacklog({ scenario, currentBlockIndex, currentBlock, }) {
             .slice(0, upToIndex + 1)
             .map((block, index) => ({ block, realIndex: index }))
             .filter(({ block }) => block.blockType === "dialogue" || block.blockType === "narration");
-        console.log(`Building conversation history up to index ${upToIndex}, found ${conversationBlocks.length} conversation blocks`);
         conversationBlocks.forEach(({ block, realIndex }) => {
             var _a, _b;
             if (!processedBlocks.current.has(realIndex)) {
@@ -37,6 +36,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 +63,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 +71,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,30 @@
+import type { WorkFont } from "../types";
+/**
+ * フォントを読み込むカスタムフック
+ * - Googleフォント: <link>タグで読み込み + document.fonts.load()でプリロード
+ * - カスタムフォント: FontFace APIで読み込み
+ * - すべてのフォントが完全にダウンロード&キャッシュされてからisLoaded=trueになる
+ * - 再生開始前に全フォントを一括ダウンロードし、再生中のフォントスワップを防止する
+ * - preloadText: シナリオ内の全テキストを渡すと、使用される全ての文字でフォントをプリロード
+ */
+export declare function useFontLoader(fonts: WorkFont[] | undefined, preloadText?: string): {
+    isLoaded: boolean;
+    loadedFonts: string[];
+};
+/**
+ * フォントファミリーに基づいてCSSのfont-family値を生成
+ */
+export declare function getFontFamilyStyle(selectedFontFamily: string | undefined, fonts: WorkFont[] | undefined): string;
+/**
+ * UIフォントファミリーに基づいてCSSのfont-family値を生成
+ * メニュー、ボタン、ラベルなどのUI要素に使用
+ */
+export declare function getUIFontFamilyStyle(selectedUIFontFamily: 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,192 @@
+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>タグを挿入し、CSSの読み込み完了を待つ
+ */
+function loadGoogleFontCSS(fontFamily) {
+    const existingLink = document.querySelector(`link[data-font-family="${fontFamily}"]`);
+    if (existingLink) {
+        return Promise.resolve();
+    }
+    const link = document.createElement("link");
+    link.rel = "stylesheet";
+    // display=blockでフォント読み込みまでテキストを非表示にする（FOUTを防止）
+    link.href = `https://fonts.googleapis.com/css2?family=${encodeURIComponent(fontFamily)}:wght@400;700&display=block`;
+    link.setAttribute("data-font-family", fontFamily);
+    document.head.appendChild(link);
+    return new Promise((resolve) => {
+        link.onload = () => resolve();
+        link.onerror = () => {
+            console.warn(`Failed to load Google font CSS: ${fontFamily}`);
+            resolve();
+        };
+    });
+}
+/**
+ * Googleフォントのフォントデータを事前にダウンロード
+ * 400/700両方のウェイトをプリロードする
+ */
+function preloadGoogleFont(fontFamily, textToPreload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // 400と700両方のウェイトをプリロード
+            yield Promise.all([
+                document.fonts.load(`400 16px "${fontFamily}"`, textToPreload),
+                document.fonts.load(`700 16px "${fontFamily}"`, textToPreload),
+            ]);
+        }
+        catch (error) {
+            console.warn(`Failed to preload Google font: ${fontFamily}`, error);
+        }
+    });
+}
+/**
+ * カスタムフォントをFontFace APIで読み込み
+ */
+function loadCustomFont(fontFamily, url, fontName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // 既にdocument.fontsに登録されているかチェック
+            let fontExists = false;
+            for (const existingFont of document.fonts) {
+                if (existingFont.family === fontFamily) {
+                    fontExists = true;
+                    break;
+                }
+            }
+            if (!fontExists) {
+                const fontFace = new FontFace(fontFamily, `url(${url})`);
+                yield fontFace.load();
+                document.fonts.add(fontFace);
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to load custom font: ${fontName}`, error);
+        }
+    });
+}
+/**
+ * フォントを読み込むカスタムフック
+ * - Googleフォント: <link>タグで読み込み + document.fonts.load()でプリロード
+ * - カスタムフォント: FontFace APIで読み込み
+ * - すべてのフォントが完全にダウンロード&キャッシュされてからisLoaded=trueになる
+ * - 再生開始前に全フォントを一括ダウンロードし、再生中のフォントスワップを防止する
+ * - preloadText: シナリオ内の全テキストを渡すと、使用される全ての文字でフォントをプリロード
+ */
+export function useFontLoader(fonts, preloadText) {
+    const [isLoaded, setIsLoaded] = useState(false);
+    const [loadedFonts, setLoadedFonts] = useState([]);
+    // 現在のロード処理をキャンセルするための世代カウンター
+    const generationRef = useRef(0);
+    useEffect(() => {
+        if (!fonts || fonts.length === 0) {
+            setIsLoaded(true);
+            return;
+        }
+        // 新しいロード処理を開始する際、前回の結果を無効化
+        const generation = ++generationRef.current;
+        setIsLoaded(false);
+        const loadFonts = () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const loadedFontFamilies = [];
+            const textToPreload = preloadText || "あいうえおABCabc123";
+            // すべてのGoogle FontsのCSS読み込みを並列で開始
+            const googleFonts = fonts.filter((f) => f.type === "google" && !fontCache.has(f.fontFamily));
+            const customFonts = fonts.filter((f) => f.type === "custom" && f.url && !fontCache.has(f.fontFamily));
+            const cachedFonts = fonts.filter((f) => fontCache.has(f.fontFamily));
+            // キャッシュ済みフォントは即座に追加
+            for (const font of cachedFonts) {
+                loadedFontFamilies.push(font.fontFamily);
+            }
+            // Google FontsのCSS読み込みを並列実行
+            yield Promise.all(googleFonts.map((font) => loadGoogleFontCSS(font.fontFamily)));
+            // キャンセルチェック
+            if (generation !== generationRef.current)
+                return;
+            // Google Fontsのフォントデータプリロード + カスタムフォント読み込みを並列実行
+            const allFontPromises = [];
+            for (const font of googleFonts) {
+                allFontPromises.push(preloadGoogleFont(font.fontFamily, textToPreload).then(() => {
+                    fontCache.add(font.fontFamily);
+                    loadedFontFamilies.push(font.fontFamily);
+                }));
+            }
+            for (const font of customFonts) {
+                allFontPromises.push(loadCustomFont(font.fontFamily, (_a = font.url) !== null && _a !== void 0 ? _a : "", font.name).then(() => {
+                    fontCache.add(font.fontFamily);
+                    loadedFontFamilies.push(font.fontFamily);
+                }));
+            }
+            yield Promise.all(allFontPromises);
+            // キャンセルチェック
+            if (generation !== generationRef.current)
+                return;
+            // document.fonts.readyで全フォントの準備完了を確認
+            yield document.fonts.ready;
+            // キャンセルチェック
+            if (generation !== generationRef.current)
+                return;
+            setLoadedFonts(loadedFontFamilies);
+            setIsLoaded(true);
+        });
+        loadFonts();
+    }, [fonts, preloadText]);
+    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`;
+}
+/**
+ * UIフォントファミリーに基づいてCSSのfont-family値を生成
+ * メニュー、ボタン、ラベルなどのUI要素に使用
+ */
+export function getUIFontFamilyStyle(selectedUIFontFamily, fonts) {
+    if (!fonts || fonts.length === 0) {
+        return "sans-serif";
+    }
+    if (selectedUIFontFamily) {
+        const selectedFont = fonts.find((f) => f.fontFamily === selectedUIFontFamily);
+        if (selectedFont) {
+            return `"${selectedUIFontFamily}", 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/useImagePreloader.d.ts

@@ -0,0 +1,5 @@
+import type { DisplayedCharacter } from "../types";
+export declare const useImagePreloader: (
+  displayedCharacters: DisplayedCharacter[],
+  singleImageUrl?: string
+) => boolean;

package/dist/hooks/useImagePreloader.js

@@ -0,0 +1,53 @@
+import { useEffect, useState } from "react";
+export var useImagePreloader = function (displayedCharacters, singleImageUrl) {
+  var _a = useState(true),
+    isLoading = _a[0],
+    setIsLoading = _a[1];
+  useEffect(
+    function () {
+      var imageUrls = [];
+      // 複数キャラクター表示の場合
+      if (displayedCharacters.length > 0) {
+        displayedCharacters.forEach(function (char) {
+          if (char.entityState.imageUrl) {
+            imageUrls.push(char.entityState.imageUrl);
+          }
+        });
+      } else if (singleImageUrl) {
+        // 単一キャラクター表示の場合
+        imageUrls.push(singleImageUrl);
+      }
+      // 画像がない場合は即座に完了
+      if (imageUrls.length === 0) {
+        setIsLoading(false);
+        return;
+      }
+      setIsLoading(true);
+      // すべての画像を並列でプリロード
+      var loadPromises = imageUrls.map(function (url) {
+        return new Promise(function (resolve, reject) {
+          var img = new Image();
+          img.onload = function () {
+            return resolve();
+          };
+          img.onerror = function () {
+            return reject(new Error("Failed to load image: ".concat(url)));
+          };
+          img.src = url;
+        });
+      });
+      // すべての画像の読み込みを待つ
+      Promise.all(loadPromises)
+        .then(function () {
+          setIsLoading(false);
+        })
+        .catch(function (error) {
+          console.error("Image preload error:", error);
+          // エラーが発生しても続行
+          setIsLoading(false);
+        });
+    },
+    [displayedCharacters, singleImageUrl]
+  );
+  return isLoading;
+};

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;