@elvishscout/mdstory 0.1.4 → 0.2.0

package/dist/core/story.js

@@ -0,0 +1,247 @@
+import { Chapter } from "./chapter.js";
+import { renderTemplate } from "./render.js";
+import { parseStorySource, resolveParseOptions } from "./parser.js";
+import { getScriptModuleId, importScriptModule, normalizePath } from "./utils.js";
+function parstInput(type, text) {
+    switch (type) {
+        case "boolean": {
+            return text === "on";
+        }
+        case "number": {
+            return text ? Number(text) : null;
+        }
+        default: {
+            return text;
+        }
+    }
+}
+function parseFormData(formData, { inputs }) {
+    const target = formData.get("@target") || null;
+    const parsedInputs = Object.fromEntries(inputs.map(({ name, type }) => {
+        const value = formData.get(name);
+        try {
+            return [name, parstInput(type, value)];
+        }
+        catch {
+            throw new Error(`Invalid input from FormData: ${name}, ${value}`);
+        }
+    }));
+    return { target, inputs: parsedInputs };
+}
+function applyInputScopes(targets, inputs) {
+    for (const [name, value] of Object.entries(inputs)) {
+        if (name.startsWith("$")) {
+            targets.globals[name.slice(1)] = value;
+        }
+        else {
+            targets.locals[name] = value;
+        }
+    }
+}
+/**
+ * Story runtime containing core playback logic.
+ * Construct via `fromSource(source)`, `fromPath(path)`,
+ * `fromParsed(parsedStory)`, or manually with a parsed StoryInit.
+ */
+export class Story {
+    constructor(init) {
+        /** @internal */ this._storyTitleShown = false;
+        this.title = (init.title || init.metadata?.title) ?? "";
+        this.template = init.template ?? "";
+        this.chapters = init.chapters;
+        this.metadata = init.metadata ?? {};
+        this.globals = this.metadata.globals ?? {};
+        this.assets = this.metadata.assets ?? {};
+        this.hooks = init.hooks ?? {};
+        this.stylesheet = init.stylesheet ?? "";
+        this.debug = init.debug ?? false;
+    }
+    /** Get chapter by chapter id */
+    getChapter(id) {
+        return this.chapters.find((chapter) => chapter.id === id) ?? null;
+    }
+    resolveTarget(target, currentChapter) {
+        const dot = target.indexOf(".");
+        if (dot !== -1) {
+            // Cross-chapter scene: "chapterId.sceneId"
+            const chapterId = target.slice(0, dot);
+            const sceneId = target.slice(dot + 1);
+            const chapter = this.getChapter(chapterId);
+            if (chapter) {
+                const scene = chapter.getScene(sceneId);
+                if (scene) {
+                    return { chapter, scene };
+                }
+            }
+            return null;
+        }
+        // Local scene in current chapter
+        {
+            const chapter = currentChapter.getScene(target);
+            if (chapter) {
+                return { chapter: currentChapter, scene: chapter };
+            }
+        }
+        // Global scene lookup across all chapters
+        for (const chapter of this.chapters) {
+            const scene = chapter.getScene(target);
+            if (scene) {
+                return { chapter: chapter, scene: scene };
+            }
+        }
+        // Chapter id → entry scene
+        {
+            const chapter = this.getChapter(target);
+            if (chapter && chapter.scenes.length > 0) {
+                return { chapter, scene: chapter.scenes[0] };
+            }
+        }
+        return null;
+    }
+    /** Renders the story template with the given scope and render options. */
+    render(scope, assets, options) {
+        return renderTemplate(this.template, scope, assets, options);
+    }
+    async enterChapter(chapter) {
+        chapter.locals = {};
+        if (chapter.hooks.locals) {
+            const result = await chapter.hooks.locals({ globals: this.globals });
+            if (result) {
+                Object.assign(chapter.locals, result);
+            }
+        }
+        if (chapter.hooks.onEnter) {
+            await chapter.hooks.onEnter({ globals: this.globals, locals: chapter.locals });
+        }
+    }
+    async leaveChapter(chapter, target) {
+        if (chapter.hooks.onLeave) {
+            await chapter.hooks.onLeave({
+                globals: this.globals,
+                locals: chapter.locals,
+                target,
+            });
+        }
+    }
+    /** Starts playing the story, looping through chapters and scenes until navigation ends. */
+    async play(prompt, options) {
+        const debug = options.debug ?? this.debug;
+        if (this.hooks.globals) {
+            const result = await this.hooks.globals();
+            if (result) {
+                Object.assign(this.globals, result);
+            }
+        }
+        if (this.hooks.onStart) {
+            await this.hooks.onStart({ globals: this.globals });
+        }
+        const assetUrlMap = Object.fromEntries(Object.entries(this.assets).map(([name, { url }]) => [name, url]));
+        const entryChapter = this.chapters[0];
+        const entryScene = entryChapter?.scenes[0];
+        if (!entryChapter || !entryScene) {
+            return;
+        }
+        let chapter = entryChapter;
+        let scene = entryScene;
+        let currentChapterId = null;
+        await this.enterChapter(chapter);
+        while (true) {
+            // Scene onEnter + render-only view data
+            if (scene.hooks.onEnter) {
+                await scene.hooks.onEnter({ globals: this.globals, locals: chapter.locals });
+            }
+            let sceneOverrides = {};
+            if (scene.hooks.view) {
+                const result = await scene.hooks.view({
+                    globals: this.globals,
+                    locals: chapter.locals,
+                });
+                if (result) {
+                    Object.assign(sceneOverrides, result);
+                }
+            }
+            if (debug) {
+                console.log("--- [debug] scene:", scene.id);
+                console.log("--- [debug] globals:", JSON.stringify(this.globals, null, 2));
+                console.log("--- [debug] locals:", JSON.stringify(chapter.locals, null, 2));
+            }
+            const renderContext = { ...this.globals, ...assetUrlMap, ...chapter.locals, ...sceneOverrides };
+            const renderResult = scene.render(renderContext, this.assets, options);
+            // Prepend chapter and story templates to rendered text
+            let { text } = renderResult;
+            let prefix = "";
+            if (!this._storyTitleShown) {
+                const rendered = this.render(renderContext, this.assets, options);
+                if (rendered.text) {
+                    prefix += rendered.text;
+                }
+                this._storyTitleShown = true;
+            }
+            if (chapter.id !== currentChapterId) {
+                const rendered = chapter.render(renderContext, this.assets, options);
+                if (rendered.text) {
+                    prefix += rendered.text;
+                }
+                currentChapterId = chapter.id;
+            }
+            text = prefix + text;
+            const promptResult = await prompt({ scene, ...renderResult, text });
+            const normalizedPromptResult = promptResult instanceof FormData ? parseFormData(promptResult, renderResult) : promptResult;
+            applyInputScopes({
+                globals: this.globals,
+                locals: chapter.locals,
+            }, normalizedPromptResult.inputs);
+            // Scene onLeave (side effect only)
+            if (scene.hooks.onLeave) {
+                await scene.hooks.onLeave({
+                    globals: this.globals,
+                    locals: chapter.locals,
+                    target: normalizedPromptResult.target,
+                });
+            }
+            const finalTarget = normalizedPromptResult.target;
+            if (finalTarget === null) {
+                await this.leaveChapter(chapter, finalTarget);
+                break;
+            }
+            // Resolve target
+            const resolved = this.resolveTarget(finalTarget, chapter);
+            if (!resolved) {
+                throw new Error(`Target not found: ${finalTarget}`);
+            }
+            // Chapter transition
+            if (resolved.chapter !== chapter) {
+                await this.leaveChapter(chapter, finalTarget);
+                await this.enterChapter(resolved.chapter);
+            }
+            chapter = resolved.chapter;
+            scene = resolved.scene;
+        }
+    }
+}
+/** Creates a Story instance from a parsed story object. */
+export async function fromParsed(story) {
+    return new Story({
+        metadata: story.metadata,
+        title: story.title,
+        template: story.template,
+        chapters: await Promise.all(story.chapters.map((chapter) => Chapter.fromParsed(chapter))),
+        stylesheet: story.stylesheet,
+        hooks: await importScriptModule(story.script, getScriptModuleId()),
+        debug: story.debug,
+    });
+}
+/** Parses a story source string and creates a Story instance. */
+export async function fromSource(source, options) {
+    const parseOptions = await resolveParseOptions(options);
+    const parsedStory = await parseStorySource(source, parseOptions);
+    return fromParsed(parsedStory);
+}
+/** Loads a story from a path or URL and resolves includes relative to each containing resource. */
+export async function fromPath(path, options) {
+    const normalizedPath = await normalizePath(path, options?.base);
+    const parseOptions = await resolveParseOptions({ ...options, base: normalizedPath });
+    const source = await parseOptions.resolveInclude(normalizedPath);
+    const parsedStory = await parseStorySource(source, parseOptions);
+    return fromParsed(parsedStory);
+}

package/dist/core/utils.js

@@ -0,0 +1,66 @@
+import { DEFAULT_CHAPTER } from "./definitions.js";
+function dynamicImport(specifier) {
+    return import(/* @vite-ignore */ specifier);
+}
+function isBrowser() {
+    return typeof window !== "undefined" && typeof window.location?.href === "string";
+}
+async function nodePath() {
+    return isBrowser() ? null : dynamicImport("node:path");
+}
+async function nodeFs() {
+    return isBrowser() ? null : dynamicImport("node:fs/promises");
+}
+function isUrl(path) {
+    return /^https?:\/\//.test(path);
+}
+export function getScriptModuleId(chapterId, sceneId) {
+    let moduleId = "story";
+    if (chapterId) {
+        const chapterIdStr = chapterId === DEFAULT_CHAPTER ? "" : chapterId;
+        moduleId += `.chapter.${chapterIdStr}`;
+    }
+    if (sceneId) {
+        moduleId += `.scene.${sceneId}`;
+    }
+    return moduleId;
+}
+export async function importScriptModule(script, id) {
+    if (!script.trim()) {
+        return {};
+    }
+    const uint8 = new TextEncoder().encode(script);
+    const binary = String.fromCharCode(...uint8);
+    const url = "data:text/javascript;charset=utf-8;base64," + btoa(binary) + (id ? `#id_${id}` : "");
+    const module = await import(/* @vite-ignore */ url);
+    return module.default ?? {};
+}
+export async function parseScript(script, schema, id) {
+    return schema.parse(await importScriptModule(script, id));
+}
+export async function normalizePath(path, base) {
+    if (isUrl(path)) {
+        return new URL(path).toString();
+    }
+    if (base && isUrl(base)) {
+        return new URL(path, base).toString();
+    }
+    if (isBrowser()) {
+        return new URL(path, base ?? globalThis.location.href).toString();
+    }
+    const pathModule = (await nodePath());
+    if (base) {
+        const baseDir = /[/\\]$/.test(base) ? base : pathModule.dirname(base);
+        return pathModule.resolve(baseDir, path);
+    }
+    return pathModule.resolve(path);
+}
+export async function loadSource(normalizedPath) {
+    if (isUrl(normalizedPath)) {
+        return await (await fetch(normalizedPath)).text();
+    }
+    return (await (await nodeFs()).readFile(normalizedPath, { encoding: "utf-8" }));
+}
+export function escapeHtml(text) {
+    return text.replace(/[<>&'"]/g, (ch) => `&#${ch.charCodeAt(0)};`);
+}

package/dist/index.js

@@ -1,7 +1 @@
-export * from "./base/index.js";
-import { StoryBase, parseStorySource } from "./base/index.js";
-export class Story extends StoryBase {
-    constructor(source) {
-        super(parseStorySource(source));
-    }
-}
+export * from "./core/index.js";

package/dist/tools/count-words.js

@@ -0,0 +1,22 @@
+import { createRequire } from "module";
+import { fromPath } from "../index.js";
+const require = createRequire(import.meta.url);
+const { wordsCount } = require("words-count");
+function countWords(text) {
+    const cleanText = text.replace(/\{\{\{.*?\}\}\}/g, "").replace(/\{\{.*?\}\}/g, "");
+    return wordsCount(cleanText);
+}
+async function main() {
+    const entryPath = process.argv[2];
+    const story = await fromPath(entryPath);
+    let count = 0;
+    count += countWords(story.title);
+    for (const chapter of Object.values(story.chapters)) {
+        count += countWords(chapter.title);
+        for (const scene of Object.values(chapter.scenes)) {
+            count += countWords(scene.template);
+        }
+    }
+    console.log("Total words:", count);
+}
+main();