@elvishscout/mdstory 0.1.1 → 0.1.2

package/dist/base/chapter.js

@@ -58,51 +58,57 @@ const createSubmitButtonHtml = ({ tagMap = {}, target, children, }) => {
     };
     return createElementHtml(tag, buttonAttrs, children);
 };
-const createInputMarkdown = ({ name, type }) => {
-    if (type === "boolean") {
-        return `[ ${name}? ]`;
-    }
-    return `[> ${name} <]`;
-};
-const useHelper = ({ inputs, sets, navs }, options) => {
+const useHelper = ({ inputs, sets, navs }, assets, options) => {
     return {
         input(type, opt) {
-            let result = "";
             for (const name in opt.hash) {
+                let result;
                 const value = opt.hash[name];
                 inputs.push({ name, type, value });
                 if (options.format === "html") {
                     result = createInputHtml({ name, type, value, ...options });
                 }
                 else {
-                    result = createInputMarkdown({ name, type });
+                    if (type === "boolean") {
+                        result = `[? _${name}_]`;
+                    }
+                    else {
+                        result = `[> _${name}_]`;
+                    }
                 }
-                break;
+                return new Handlebars.SafeString(result);
             }
-            return new Handlebars.SafeString(result);
+            return "";
         },
         set(opt) {
-            const result = Object.entries(opt.hash)
-                .map(([name, value]) => {
+            for (const name in opt.hash) {
+                const value = opt.hash[name];
                 const type = valueType(value);
                 sets.push({ name, type, value });
-                if (options.format === "html") {
-                    return createInputHtml({ name, type, value, readonly: true, ...options });
-                }
-                return "";
-            })
-                .join("");
-            return new Handlebars.SafeString(result);
+            }
+            return "";
         },
         nav(target, opt) {
-            let result = "";
+            let result;
             const text = opt.fn(this).trim();
             navs.push({ text, target });
             if (options.format === "html") {
                 result = createSubmitButtonHtml({ target: target ?? "", children: text, ...options });
             }
+            else {
+                result = `[@ __${text}__]`;
+            }
             return new Handlebars.SafeString(result);
         },
+        asset(name) {
+            return new Handlebars.SafeString(assets[name]?.url ?? "");
+        },
+        mime(name) {
+            return new Handlebars.SafeString(assets[name]?.mime ?? "");
+        },
+        linebreak(n) {
+            return new Handlebars.SafeString("\n".repeat(n ?? 1));
+        },
     };
 };
 export class Chapter {
@@ -112,20 +118,23 @@ export class Chapter {
         this.template = template;
         this.hooks = hooks;
     }
-    render(scope, options) {
+    render(scope, assets = {}, options) {
         const md = new MarkdownIt({ html: true }).use(pluginAttrs);
         const fields = {
             inputs: [],
             sets: [],
             navs: [],
         };
-        const handle = Handlebars.create();
-        handle.registerHelper(useHelper(fields, options));
-        let text = handle.compile(this.template)(scope);
+        const helpers = useHelper(fields, assets, options);
+        let text;
         if (options.format === "html") {
+            text = Handlebars.compile(this.template)(scope, { helpers });
             text = md.render(text);
             text = createElementHtml("input", { type: "submit", disabled: true, hidden: true }) + text;
         }
+        else {
+            text = Handlebars.compile(this.template, { noEscape: true })(scope, { helpers });
+        }
         return { text, ...fields };
     }
 }

package/dist/base/definitions.js

@@ -1,9 +1,17 @@
 import { z } from "zod";
 export const ValueSchema = z.any().transform((v) => v);
 export const ScopeSchema = z.record(ValueSchema);
+export const AssetSchema = z.union([
+    z.string().transform((url) => ({ url, mime: undefined })),
+    z.object({ url: z.string(), mime: z.string().optional() }),
+]);
+export const AssetsSchema = z.record(AssetSchema);
 export const MetadataSchema = z.object({
-    title: z.string().default(""),
-    globals: ScopeSchema.default({}),
+    title: z.string().optional(),
+    author: z.string().optional(),
+    email: z.string().optional(),
+    globals: ScopeSchema.optional(),
+    assets: AssetsSchema.optional(),
 });
 const TargetSchema = z.string().or(z.null());
 export const StoryHooksSchema = z

package/dist/base/index.js

@@ -1,4 +1,5 @@
 export * from "./definitions.js";
 export * from "./story.js";
+export * from "./parser.js";
 export * from "./chapter.js";
 export * from "./error.js";

package/dist/base/parser.js

@@ -0,0 +1,86 @@
+import yaml from "js-yaml";
+import MarkdownIt from "markdown-it";
+import pluginFrontMatter from "markdown-it-front-matter";
+import pluginAttrs from "markdown-it-attrs";
+import { MetadataSchema } from "./definitions.js";
+import { DuplicateIdError, EmptyChapterIdError, InvalidMetadataError } from "./error.js";
+export const parseStoryContent = (content) => {
+    const md = new MarkdownIt({ html: true }).use(pluginAttrs).use(pluginFrontMatter, () => { });
+    const tokens = md.parse(content, {});
+    let metadata = MetadataSchema.parse({});
+    let storyScript = "";
+    let stylesheet = "";
+    const ignoredRanges = [];
+    const divisions = [];
+    tokens.forEach((token, i) => {
+        if (token.type === "front_matter" && token.meta) {
+            try {
+                const frontMatter = MetadataSchema.parse(yaml.load(token.meta));
+                metadata = Object.assign(metadata, frontMatter);
+            }
+            catch {
+                throw new InvalidMetadataError(token.meta);
+            }
+        }
+        else if (token.type === "heading_open" && token.tag === "h1" && token.level === 0 && token.map) {
+            const lineno = token.map[0];
+            let id = token.attrs?.find(([key]) => key === "id")?.[1] ?? "";
+            let title = "";
+            const nextToken = tokens[i + 1];
+            if (nextToken && nextToken.type === "inline") {
+                const content = nextToken.content.trim();
+                id || (id = content);
+                title = content;
+            }
+            if (!id) {
+                throw new EmptyChapterIdError();
+            }
+            if (divisions.find(({ id: _id }) => id === _id)) {
+                throw new DuplicateIdError(id);
+            }
+            divisions.push({ id, title, lineno, script: "" });
+        }
+        else if (token.type === "html_block" && token.map) {
+            let regres;
+            if ((regres = /^[\s]*<script>(.*)<\/script>[\s]*$/s.exec(token.content))) {
+                const script = regres[1].trim();
+                if (script) {
+                    if (divisions.length === 0) {
+                        storyScript = script;
+                    }
+                    else {
+                        divisions[divisions.length - 1].script = script;
+                    }
+                    ignoredRanges.push(token.map);
+                }
+            }
+            else if ((regres = /^[\s]*<style>(.*)<\/style>[\s]*$/s.exec(token.content))) {
+                const style = regres[1].trim();
+                stylesheet += style;
+                ignoredRanges.push(token.map);
+            }
+        }
+    });
+    const lines = content.split("\n").map((line, i) => {
+        if (ignoredRanges.find(([from, to]) => i >= from && i < to)) {
+            return null;
+        }
+        return line;
+    });
+    const chapterEntries = divisions.map(({ id, title, lineno, script }, i) => {
+        const template = lines
+            .slice(lineno, divisions[i + 1]?.lineno)
+            .filter((line) => line !== null)
+            .join("\n");
+        return [id, { title, template, script }];
+    });
+    const chapters = Object.fromEntries(chapterEntries);
+    const entry = chapterEntries[0]?.[0] || null;
+    return {
+        metadata,
+        chapters,
+        entry,
+        script: storyScript,
+        stylesheet,
+    };
+};

package/dist/base/story.js

@@ -1,10 +1,6 @@
-import yaml from "js-yaml";
-import MarkdownIt from "markdown-it";
-import pluginFrontMatter from "markdown-it-front-matter";
-import pluginAttrs from "markdown-it-attrs";
-import { MetadataSchema, StoryHooksSchema, ChapterHooksSchema, } from "./definitions.js";
+import { ChapterHooksSchema, StoryHooksSchema, } from "./definitions.js";
 import { Chapter } from "./chapter.js";
-import { ChapterNotFoundError, DuplicateIdError, EmptyChapterIdError, InvalidInputError, InvalidMetadataError, } from "./error.js";
+import { ChapterNotFoundError, InvalidInputError } from "./error.js";
 const parstInput = (type, text) => {
     if (type === "boolean") {
         return text === "on";
@@ -30,114 +26,36 @@ const parseFormData = (formData, { inputs, sets }) => {
     }));
     return { target, updates };
 };
-export const parseStoryContent = (content) => {
-    const md = new MarkdownIt({ html: true }).use(pluginAttrs).use(pluginFrontMatter, () => { });
-    const tokens = md.parse(content, {});
-    let metadata = MetadataSchema.parse({});
-    let storyScript = "";
-    let stylesheet = "";
-    const ignoredRanges = [];
-    const divisions = [];
-    tokens.forEach((token, i) => {
-        if (token.type === "front_matter" && token.meta) {
-            try {
-                const frontMatter = MetadataSchema.parse(yaml.load(token.meta));
-                metadata = { ...metadata, ...frontMatter };
-            }
-            catch {
-                throw new InvalidMetadataError(token.meta);
-            }
-        }
-        else if (token.type === "heading_open" && token.tag === "h1" && token.level === 0 && token.map) {
-            const lineno = token.map[0];
-            let id = token.attrs?.find(([key]) => key === "id")?.[1] ?? "";
-            let title = "";
-            const nextToken = tokens[i + 1];
-            if (nextToken && nextToken.type === "inline") {
-                const content = nextToken.content.trim();
-                id || (id = content);
-                title = content;
-            }
-            if (!id) {
-                throw new EmptyChapterIdError();
-            }
-            if (divisions.find(({ id: _id }) => id === _id)) {
-                throw new DuplicateIdError(id);
-            }
-            divisions.push({ id, title, lineno, script: "" });
-        }
-        else if (token.type === "html_block" && token.map) {
-            let regres;
-            if ((regres = /^[\s]*<script>(.*)<\/script>[\s]*$/s.exec(token.content))) {
-                const script = regres[1].trim();
-                if (script) {
-                    if (divisions.length === 0) {
-                        storyScript = script;
-                    }
-                    else {
-                        divisions[divisions.length - 1].script = script;
-                    }
-                    ignoredRanges.push(token.map);
-                }
-            }
-            else if ((regres = /^[\s]*<style>(.*)<\/style>[\s]*$/s.exec(token.content))) {
-                const style = regres[1].trim();
-                stylesheet += style;
-                ignoredRanges.push(token.map);
-            }
-        }
-    });
-    const lines = content.split("\n").map((line, i) => {
-        if (ignoredRanges.find(([from, to]) => i >= from && i < to)) {
-            return null;
-        }
-        return line;
-    });
-    const chapterEntries = divisions.map(({ id, title, lineno, script }, i) => {
-        const template = lines
-            .slice(lineno, divisions[i + 1]?.lineno)
-            .filter((line) => line !== null)
-            .join("\n");
-        const hooks = script ? ChapterHooksSchema.parse(new Function(script)()) : {};
-        return [id, { title, template, hooks }];
-    });
-    const chapters = Object.fromEntries(chapterEntries);
-    const entry = chapterEntries[0]?.[0] || null;
-    const hooks = storyScript ? StoryHooksSchema.parse(new Function(storyScript)()) : {};
-    return {
-        metadata,
-        chapters,
-        entry,
-        hooks,
-        stylesheet,
-    };
-};
 export class StoryBase {
-    constructor({ metadata, chapters, entry, hooks, stylesheet }) {
-        const realChapters = Object.fromEntries(Object.entries(chapters).map(([id, options]) => {
-            return [id, new Chapter({ id, ...options })];
+    constructor({ metadata, chapters, entry, script, stylesheet }) {
+        const realChapters = Object.fromEntries(Object.entries(chapters).map(([id, { title, template, script }]) => {
+            const hooks = (script && ChapterHooksSchema.parse(new Function(script)())) || {};
+            return [id, new Chapter({ id, title, template, hooks })];
         }));
         this.metadata = metadata;
-        this.globals = metadata.globals;
+        this.globals = metadata.globals ?? {};
         this.chapters = realChapters;
         this.entry = (entry && realChapters[entry]) || null;
-        this.hooks = hooks;
+        this.hooks = (script && StoryHooksSchema.parse(new Function(script)())) || {};
         this.stylesheet = stylesheet;
+        this.assets = metadata.assets ?? {};
     }
     async play(prompt, options) {
         if (this.hooks.onStart) {
             this.hooks.onStart(this.globals);
         }
+        const assetsUrl = Object.fromEntries(Object.entries(this.assets).map(([name, { url }]) => [name, url]));
         let chapter = this.entry;
         while (chapter) {
-            let modifiedGlobals = this.globals;
+            let scope = this.globals;
+            scope = Object.assign(scope, assetsUrl);
             if (chapter.hooks.onEnter) {
                 const modified = chapter.hooks.onEnter(this.globals);
                 if (modified !== undefined) {
-                    modifiedGlobals = Object.assign(modifiedGlobals, modified);
+                    scope = Object.assign(scope, modified);
                 }
             }
-            const renderResult = chapter.render(modifiedGlobals, options);
+            const renderResult = chapter.render(scope, this.assets, options);
             const promptResult = await prompt({ chapter, ...renderResult });
             const { target, updates } = promptResult instanceof FormData ? parseFormData(promptResult, renderResult) : promptResult;
             let modifiedTarget = target;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elvishscout/mdstory",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "An interactive story format based on Markdown and Handlebars with JavaScript support.",
   "main": "./dist/index.js",
   "type": "module",

package/types/base/chapter.d.ts

@@ -1,4 +1,4 @@
-import { ValueType, Value, ChapterHooks, Scope } from "./definitions.js";
+import { ValueType, Value, ChapterHooks, Scope, Asset } from "./definitions.js";
 type MarkdownOptions = {};
 type HtmlOptions = {
     tagMap?: Record<string, string>;
@@ -39,6 +39,6 @@ export declare class Chapter {
     template: string;
     hooks: ChapterHooks;
     constructor({ id, title, template, hooks }: ChapterOptions);
-    render(scope: Scope, options: RenderOptions): RenderResult;
+    render(scope: Scope, assets: Record<string, Asset> | undefined, options: RenderOptions): RenderResult;
 }
 export {};

package/types/base/definitions.d.ts

@@ -7,15 +7,71 @@ type JsonObject = {
 type JsonValue = JsonPrimitive | JsonArray | JsonObject;
 export declare const ValueSchema: z.ZodEffects<z.ZodAny, string | number | boolean | JsonArray | JsonObject | null, any>;
 export declare const ScopeSchema: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodAny, string | number | boolean | JsonArray | JsonObject | null, any>>;
+export declare const AssetSchema: z.ZodUnion<[z.ZodEffects<z.ZodString, {
+    url: string;
+    mime: undefined;
+}, string>, z.ZodObject<{
+    url: z.ZodString;
+    mime: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    mime?: string | undefined;
+}, {
+    url: string;
+    mime?: string | undefined;
+}>]>;
+export declare const AssetsSchema: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodEffects<z.ZodString, {
+    url: string;
+    mime: undefined;
+}, string>, z.ZodObject<{
+    url: z.ZodString;
+    mime: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    mime?: string | undefined;
+}, {
+    url: string;
+    mime?: string | undefined;
+}>]>>;
 export declare const MetadataSchema: z.ZodObject<{
-    title: z.ZodDefault<z.ZodString>;
-    globals: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodAny, string | number | boolean | JsonArray | JsonObject | null, any>>>;
+    title: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    globals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodAny, string | number | boolean | JsonArray | JsonObject | null, any>>>;
+    assets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodEffects<z.ZodString, {
+        url: string;
+        mime: undefined;
+    }, string>, z.ZodObject<{
+        url: z.ZodString;
+        mime: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        mime?: string | undefined;
+    }, {
+        url: string;
+        mime?: string | undefined;
+    }>]>>>;
 }, "strip", z.ZodTypeAny, {
-    title: string;
-    globals: Record<string, string | number | boolean | JsonArray | JsonObject | null>;
+    title?: string | undefined;
+    author?: string | undefined;
+    email?: string | undefined;
+    globals?: Record<string, string | number | boolean | JsonArray | JsonObject | null> | undefined;
+    assets?: Record<string, {
+        url: string;
+        mime: undefined;
+    } | {
+        url: string;
+        mime?: string | undefined;
+    }> | undefined;
 }, {
     title?: string | undefined;
+    author?: string | undefined;
+    email?: string | undefined;
     globals?: Record<string, any> | undefined;
+    assets?: Record<string, string | {
+        url: string;
+        mime?: string | undefined;
+    }> | undefined;
 }>;
 export declare const StoryHooksSchema: z.ZodObject<{
     onStart: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodAny, string | number | boolean | JsonArray | JsonObject | null, any>>], z.ZodUnknown>, z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodAny, string | number | boolean | JsonArray | JsonObject | null, any>>, z.ZodVoid]>>>;
@@ -39,8 +95,22 @@ export declare const ChapterHooksSchema: z.ZodObject<{
 }>;
 export type Value = z.infer<typeof ValueSchema>;
 export type Scope = z.infer<typeof ScopeSchema>;
+export type Asset = z.infer<typeof AssetSchema>;
 export type Metadata = z.infer<typeof MetadataSchema>;
 export type StoryHooks = z.infer<typeof StoryHooksSchema>;
 export type ChapterHooks = z.infer<typeof ChapterHooksSchema>;
 export type ValueType = "string" | "number" | "boolean" | "object";
+export type ChapterBody = {
+    title: string;
+    template: string;
+    script: string;
+};
+export type StoryBody = {
+    metadata: Metadata;
+    chapters: Record<string, ChapterBody>;
+    entry: string | null;
+    script: string;
+    stylesheet: string;
+};
+export type StoryAssets = Record<string, string>;
 export {};

package/types/base/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./definitions.js";
 export * from "./story.js";
+export * from "./parser.js";
 export * from "./chapter.js";
 export * from "./error.js";

package/types/base/parser.d.ts

@@ -0,0 +1,2 @@
+import { StoryBody } from "./definitions.js";
+export declare const parseStoryContent: (content: string) => StoryBody;

package/types/base/story.d.ts

@@ -1,4 +1,4 @@
-import { StoryHooks, Scope, Metadata, ChapterHooks } from "./definitions.js";
+import { StoryBody, StoryHooks, Scope, Metadata, Asset } from "./definitions.js";
 import { Chapter, RenderOptions, RenderResult } from "./chapter.js";
 export type StoryPrompt = (props: {
     chapter: Chapter;
@@ -6,19 +6,6 @@ export type StoryPrompt = (props: {
     target: string | null;
     updates: Scope;
 } | FormData>;
-type ChapterBody = {
-    title: string;
-    template: string;
-    hooks: ChapterHooks;
-};
-type StoryBody = {
-    metadata: Metadata;
-    chapters: Record<string, ChapterBody>;
-    entry: string | null;
-    hooks: StoryHooks;
-    stylesheet: string;
-};
-export declare const parseStoryContent: (content: string) => StoryBody;
 export declare class StoryBase {
     metadata: Metadata;
     globals: Scope;
@@ -26,7 +13,7 @@ export declare class StoryBase {
     entry: Chapter | null;
     hooks: StoryHooks;
     stylesheet: string;
-    constructor({ metadata, chapters, entry, hooks, stylesheet }: StoryBody);
+    assets: Record<string, Asset>;
+    constructor({ metadata, chapters, entry, script, stylesheet }: StoryBody);
     play(prompt: StoryPrompt, options: RenderOptions): Promise<void>;
 }
-export {};