@mdsnai/sdk 0.1.0

package/dist/server/targets.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFrameworkTarget = parseFrameworkTarget;
+exports.isActionTarget = isActionTarget;
+function parseFrameworkTarget(target) {
+    if (!target || /\.md$/i.test(target) || /^https?:\/\//i.test(target)) {
+        return null;
+    }
+    const actionPath = target.replace(/^\/+/, "");
+    if (!actionPath) {
+        return null;
+    }
+    return {
+        kind: "action",
+        target,
+        actionPath,
+    };
+}
+function isActionTarget(target) {
+    return parseFrameworkTarget(target) !== null;
+}

package/dist/web/block-runtime.d.ts

@@ -0,0 +1,2 @@
+export declare function createBlockRegionMarkup(blockName: string, innerHtml: string): string;
+export declare function replaceBlockRegionMarkup(html: string, blockName: string, replacementInnerHtml: string): string;

package/dist/web/block-runtime.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBlockRegionMarkup = createBlockRegionMarkup;
+exports.replaceBlockRegionMarkup = replaceBlockRegionMarkup;
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+function createRegionMarker(kind, blockName) {
+    return `<!--mdsn:block-region:${kind}:${escapeHtml(blockName)}-->`;
+}
+function createBlockRegionMarkup(blockName, innerHtml) {
+    return `${createRegionMarker("start", blockName)}<section class="mdsn-block-region" data-mdsn-block-region="${escapeHtml(blockName)}">${innerHtml}</section>${createRegionMarker("end", blockName)}`;
+}
+function replaceBlockRegionMarkup(html, blockName, replacementInnerHtml) {
+    const escapedName = escapeHtml(blockName).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`<!--mdsn:block-region:start:${escapedName}-->[\\s\\S]*?<!--mdsn:block-region:end:${escapedName}-->`, "g");
+    if (pattern.test(html)) {
+        return html.replace(pattern, createBlockRegionMarkup(blockName, replacementInnerHtml));
+    }
+    const legacyPattern = new RegExp(`<section class="mdsn-block-region" data-mdsn-block-region="${escapedName}">[\\s\\S]*?<\\/section>`, "g");
+    return html.replace(legacyPattern, createBlockRegionMarkup(blockName, replacementInnerHtml));
+}

package/dist/web/fragment-render.d.ts

@@ -0,0 +1,10 @@
+import type { BlockDefinition } from "../core/model/block";
+import type { SchemaDefinition } from "../core/model/schema";
+import { type CreatePageRenderOptions } from "./page-render";
+export interface ParsedBlockFragment {
+    markdown: string;
+    schemas: SchemaDefinition[];
+    blocks: BlockDefinition[];
+}
+export declare function parseBlockFragment(raw: string): ParsedBlockFragment;
+export declare function renderBlockFragmentHtml(raw: string, blockName?: string, options?: CreatePageRenderOptions): string;

package/dist/web/fragment-render.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBlockFragment = parseBlockFragment;
+exports.renderBlockFragmentHtml = renderBlockFragmentHtml;
+const markdown_it_1 = __importDefault(require("markdown-it"));
+const headless_1 = require("./headless");
+const page_render_1 = require("./page-render");
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+function unwrapBlockRegionMarkup(renderedHtml, blockName) {
+    const escapedName = escapeHtml(blockName).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`<!--mdsn:block-region:start:${escapedName}--><section class="mdsn-block-region" data-mdsn-block-region="${escapedName}">([\\s\\S]*?)<\\/section><!--mdsn:block-region:end:${escapedName}-->`, "gu");
+    return renderedHtml.replace(pattern, "$1");
+}
+function parseBlockFragment(raw) {
+    const parsed = (0, headless_1.parseFragment)(raw);
+    return {
+        markdown: parsed.containers.map((container) => container.markdown).join("\n\n").trim(),
+        schemas: [],
+        blocks: parsed.block ? [parsed.block] : [],
+    };
+}
+function createMarkdownRenderer(options) {
+    return new markdown_it_1.default({
+        html: true,
+        linkify: options?.linkify ?? true,
+        typographer: options?.typographer ?? false,
+    });
+}
+function renderBlockFragmentHtml(raw, blockName, options) {
+    const fragment = (0, headless_1.parseFragment)(raw);
+    const effectiveBlockName = blockName ?? fragment.block?.name;
+    const renderer = createMarkdownRenderer(options?.markdown);
+    const renderedHtml = fragment.segments.map((segment) => {
+        if (segment.type === "container") {
+            return renderer.render(segment.container.markdown).trimEnd();
+        }
+        if (!effectiveBlockName) {
+            throw new Error("Interactive block fragments require a block name");
+        }
+        const block = segment.block.name === effectiveBlockName
+            ? segment.block
+            : { ...segment.block, name: effectiveBlockName };
+        return (0, page_render_1.renderBlockPanelHtml)(block, options, "plain");
+    }).join("");
+    if (!fragment.block || !effectiveBlockName) {
+        return renderedHtml.trimEnd();
+    }
+    return unwrapBlockRegionMarkup(renderedHtml, effectiveBlockName).trimEnd();
+}

package/dist/web/headless.d.ts

@@ -0,0 +1,95 @@
+import type { BlockAnchorDefinition, BlockDefinition, DocumentDefinition, FrontmatterData } from "../core";
+export type MarkdownInlineNode = {
+    type: "text";
+    value: string;
+} | {
+    type: "strong";
+    children: MarkdownInlineNode[];
+} | {
+    type: "em";
+    children: MarkdownInlineNode[];
+} | {
+    type: "inline_code";
+    value: string;
+} | {
+    type: "link";
+    href: string;
+    title?: string;
+    children: MarkdownInlineNode[];
+} | {
+    type: "image";
+    src: string;
+    alt: string;
+    title?: string;
+} | {
+    type: "softbreak";
+} | {
+    type: "hardbreak";
+} | {
+    type: "html_inline";
+    value: string;
+};
+export type MarkdownBlockNode = {
+    type: "heading";
+    depth: number;
+    children: MarkdownInlineNode[];
+} | {
+    type: "paragraph";
+    children: MarkdownInlineNode[];
+} | {
+    type: "list";
+    ordered: boolean;
+    start?: number;
+    items: MarkdownBlockNode[][];
+} | {
+    type: "blockquote";
+    children: MarkdownBlockNode[];
+} | {
+    type: "code";
+    language?: string;
+    value: string;
+} | {
+    type: "html";
+    value: string;
+} | {
+    type: "thematic_break";
+} | {
+    type: "table";
+    header: MarkdownInlineNode[][];
+    rows: MarkdownInlineNode[][][];
+};
+export interface MarkdownContainer {
+    id: string;
+    markdown: string;
+    nodes: MarkdownBlockNode[];
+}
+export type PageStructureSegment = {
+    type: "container";
+    container: MarkdownContainer;
+} | {
+    type: "anchor";
+    anchor: BlockAnchorDefinition;
+};
+export type FragmentStructureSegment = {
+    type: "container";
+    container: MarkdownContainer;
+} | {
+    type: "block";
+    block: BlockDefinition;
+};
+export interface ParsedPage {
+    frontmatter: FrontmatterData;
+    containers: MarkdownContainer[];
+    anchors: BlockAnchorDefinition[];
+    blocks: BlockDefinition[];
+    segments: PageStructureSegment[];
+}
+export interface ParsedFragment {
+    containers: MarkdownContainer[];
+    block?: BlockDefinition;
+    segments: FragmentStructureSegment[];
+}
+export declare function parseMarkdown(source: string): MarkdownBlockNode[];
+export declare function parsePage(source: string): ParsedPage;
+export declare function createParsedPage(document: DocumentDefinition): ParsedPage;
+export declare function parseFragment(source: string): ParsedFragment;

package/dist/web/headless.js

@@ -0,0 +1,370 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMarkdown = parseMarkdown;
+exports.parsePage = parsePage;
+exports.createParsedPage = createParsedPage;
+exports.parseFragment = parseFragment;
+const markdown_it_1 = __importDefault(require("markdown-it"));
+const core_1 = require("../core");
+const frontmatter_1 = require("../core/document/frontmatter");
+const mdsn_1 = require("../core/protocol/mdsn");
+function createMarkdownParser() {
+    return new markdown_it_1.default({
+        html: true,
+        linkify: true,
+        typographer: false,
+    });
+}
+function parseInlineNodes(tokens, startIndex = 0, stopType) {
+    const nodes = [];
+    let index = startIndex;
+    while (index < tokens.length) {
+        const token = tokens[index];
+        if (stopType && token.type === stopType) {
+            return [nodes, index];
+        }
+        switch (token.type) {
+            case "text":
+                nodes.push({ type: "text", value: token.content });
+                index += 1;
+                continue;
+            case "strong_open": {
+                const [children, nextIndex] = parseInlineNodes(tokens, index + 1, "strong_close");
+                nodes.push({ type: "strong", children });
+                index = nextIndex + 1;
+                continue;
+            }
+            case "em_open": {
+                const [children, nextIndex] = parseInlineNodes(tokens, index + 1, "em_close");
+                nodes.push({ type: "em", children });
+                index = nextIndex + 1;
+                continue;
+            }
+            case "code_inline":
+                nodes.push({ type: "inline_code", value: token.content });
+                index += 1;
+                continue;
+            case "link_open": {
+                const [children, nextIndex] = parseInlineNodes(tokens, index + 1, "link_close");
+                nodes.push({
+                    type: "link",
+                    href: token.attrGet("href") ?? "",
+                    title: token.attrGet("title") ?? undefined,
+                    children,
+                });
+                index = nextIndex + 1;
+                continue;
+            }
+            case "image":
+                nodes.push({
+                    type: "image",
+                    src: token.attrGet("src") ?? "",
+                    alt: token.content,
+                    title: token.attrGet("title") ?? undefined,
+                });
+                index += 1;
+                continue;
+            case "softbreak":
+                nodes.push({ type: "softbreak" });
+                index += 1;
+                continue;
+            case "hardbreak":
+                nodes.push({ type: "hardbreak" });
+                index += 1;
+                continue;
+            case "html_inline":
+                nodes.push({ type: "html_inline", value: token.content });
+                index += 1;
+                continue;
+            default:
+                index += 1;
+                continue;
+        }
+    }
+    return [nodes, index];
+}
+function parseTable(tokens, startIndex) {
+    const header = [];
+    const rows = [];
+    let index = startIndex + 1;
+    let currentRow = null;
+    while (index < tokens.length) {
+        const token = tokens[index];
+        if (token.type === "table_close") {
+            return [{ type: "table", header, rows }, index + 1];
+        }
+        if (token.type === "tr_open") {
+            currentRow = [];
+            index += 1;
+            continue;
+        }
+        if (token.type === "tr_close") {
+            if (currentRow) {
+                if (header.length === 0) {
+                    header.push(...currentRow);
+                }
+                else {
+                    rows.push(currentRow);
+                }
+            }
+            currentRow = null;
+            index += 1;
+            continue;
+        }
+        if (token.type === "th_open" || token.type === "td_open") {
+            const inlineToken = tokens[index + 1];
+            const children = inlineToken?.type === "inline"
+                ? parseInlineNodes(inlineToken.children ?? [])[0]
+                : [];
+            currentRow?.push(children);
+            index += 3;
+            continue;
+        }
+        index += 1;
+    }
+    throw new Error("Unterminated markdown table");
+}
+function parseBlockNodes(tokens, startIndex = 0, stopType) {
+    const nodes = [];
+    let index = startIndex;
+    while (index < tokens.length) {
+        const token = tokens[index];
+        if (stopType && token.type === stopType) {
+            return [nodes, index];
+        }
+        switch (token.type) {
+            case "heading_open": {
+                const inlineToken = tokens[index + 1];
+                const children = inlineToken?.type === "inline"
+                    ? parseInlineNodes(inlineToken.children ?? [])[0]
+                    : [];
+                nodes.push({
+                    type: "heading",
+                    depth: Number(token.tag.slice(1)),
+                    children,
+                });
+                index += 3;
+                continue;
+            }
+            case "paragraph_open": {
+                const inlineToken = tokens[index + 1];
+                const children = inlineToken?.type === "inline"
+                    ? parseInlineNodes(inlineToken.children ?? [])[0]
+                    : [];
+                nodes.push({ type: "paragraph", children });
+                index += 3;
+                continue;
+            }
+            case "bullet_list_open":
+            case "ordered_list_open": {
+                const ordered = token.type === "ordered_list_open";
+                const closeType = ordered ? "ordered_list_close" : "bullet_list_close";
+                const items = [];
+                const startValue = token.attrGet("start");
+                index += 1;
+                while (index < tokens.length && tokens[index]?.type !== closeType) {
+                    if (tokens[index]?.type !== "list_item_open") {
+                        index += 1;
+                        continue;
+                    }
+                    const [itemNodes, nextIndex] = parseBlockNodes(tokens, index + 1, "list_item_close");
+                    items.push(itemNodes);
+                    index = nextIndex + 1;
+                }
+                nodes.push({
+                    type: "list",
+                    ordered,
+                    start: ordered && startValue ? Number(startValue) : undefined,
+                    items,
+                });
+                index += 1;
+                continue;
+            }
+            case "blockquote_open": {
+                const [children, nextIndex] = parseBlockNodes(tokens, index + 1, "blockquote_close");
+                nodes.push({ type: "blockquote", children });
+                index = nextIndex + 1;
+                continue;
+            }
+            case "fence":
+            case "code_block":
+                nodes.push({
+                    type: "code",
+                    language: token.info?.trim() || undefined,
+                    value: token.content,
+                });
+                index += 1;
+                continue;
+            case "html_block":
+                nodes.push({ type: "html", value: token.content });
+                index += 1;
+                continue;
+            case "hr":
+                nodes.push({ type: "thematic_break" });
+                index += 1;
+                continue;
+            case "table_open": {
+                const [tableNode, nextIndex] = parseTable(tokens, index);
+                nodes.push(tableNode);
+                index = nextIndex;
+                continue;
+            }
+            default:
+                index += 1;
+                continue;
+        }
+    }
+    return [nodes, index];
+}
+function parseMarkdownContainer(markdown, id) {
+    return {
+        id,
+        markdown,
+        nodes: parseMarkdown(markdown),
+    };
+}
+function splitMarkdownByAnchors(markdown) {
+    const containers = [];
+    const anchors = [];
+    const segments = [];
+    const lines = markdown.split(/\r?\n/);
+    let activeFence = false;
+    let currentLines = [];
+    const pushContainer = () => {
+        const containerMarkdown = currentLines.join("\n").trim();
+        currentLines = [];
+        if (!containerMarkdown) {
+            return;
+        }
+        const container = parseMarkdownContainer(containerMarkdown, `container-${containers.length}`);
+        containers.push(container);
+        segments.push({ type: "container", container });
+    };
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+            activeFence = !activeFence;
+            currentLines.push(line);
+            continue;
+        }
+        if (!activeFence) {
+            const anchorMatch = trimmed.match(/^<!--\s*mdsn:block\s+([a-zA-Z_][\w-]*)\s*-->$/);
+            if (anchorMatch) {
+                pushContainer();
+                const anchor = { name: anchorMatch[1] };
+                anchors.push(anchor);
+                segments.push({ type: "anchor", anchor });
+                continue;
+            }
+        }
+        currentLines.push(line);
+    }
+    pushContainer();
+    return { containers, anchors, segments };
+}
+function splitFragmentSource(markdown) {
+    const segments = [];
+    const lines = markdown.split(/\r?\n/);
+    let activeFence = null;
+    let currentMarkdownLines = [];
+    let index = 0;
+    const pushMarkdownSegment = () => {
+        const segmentMarkdown = currentMarkdownLines.join("\n").trim();
+        currentMarkdownLines = [];
+        if (!segmentMarkdown) {
+            return;
+        }
+        segments.push({ type: "markdown", markdown: segmentMarkdown });
+    };
+    while (index < lines.length) {
+        const line = lines[index] ?? "";
+        const trimmed = line.trim();
+        const fenceMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
+        if (fenceMatch) {
+            const marker = fenceMatch[1];
+            const info = fenceMatch[2].trim();
+            if (activeFence) {
+                if (trimmed === activeFence) {
+                    activeFence = null;
+                }
+                currentMarkdownLines.push(line);
+                index += 1;
+                continue;
+            }
+            if (marker === "```" && info === "mdsn") {
+                pushMarkdownSegment();
+                index += 1;
+                const blockLines = [];
+                while (index < lines.length && lines[index]?.trim() !== "```") {
+                    blockLines.push(lines[index] ?? "");
+                    index += 1;
+                }
+                if (index >= lines.length) {
+                    throw new Error("Unterminated mdsn code block");
+                }
+                segments.push({ type: "mdsn", source: blockLines.join("\n") });
+                index += 1;
+                continue;
+            }
+            activeFence = marker;
+            currentMarkdownLines.push(line);
+            index += 1;
+            continue;
+        }
+        currentMarkdownLines.push(line);
+        index += 1;
+    }
+    pushMarkdownSegment();
+    return segments;
+}
+function parseMarkdown(source) {
+    const parser = createMarkdownParser();
+    const tokens = parser.parse(source, {});
+    return parseBlockNodes(tokens)[0];
+}
+function parsePage(source) {
+    const document = (0, core_1.parsePageDefinition)(source);
+    return createParsedPage(document);
+}
+function createParsedPage(document) {
+    const structure = splitMarkdownByAnchors(document.markdown);
+    return {
+        frontmatter: document.frontmatter,
+        containers: structure.containers,
+        anchors: structure.anchors,
+        blocks: document.blocks,
+        segments: structure.segments,
+    };
+}
+function parseFragment(source) {
+    const { body } = (0, frontmatter_1.parseFrontmatter)(source);
+    const sourceSegments = splitFragmentSource(body);
+    const mdsnSegments = sourceSegments.filter((segment) => segment.type === "mdsn");
+    if (mdsnSegments.length > 1) {
+        throw new Error("A block fragment may contain at most one mdsn code block");
+    }
+    const parsedBlock = mdsnSegments.length > 0
+        ? (0, mdsn_1.parseMdsnBlocks)([mdsnSegments[0].source]).blocks[0]
+        : undefined;
+    const containers = [];
+    const segments = [];
+    for (const segment of sourceSegments) {
+        if (segment.type === "markdown") {
+            const container = parseMarkdownContainer(segment.markdown, `container-${containers.length}`);
+            containers.push(container);
+            segments.push({ type: "container", container });
+            continue;
+        }
+        if (parsedBlock) {
+            segments.push({ type: "block", block: parsedBlock });
+        }
+    }
+    return {
+        containers,
+        block: parsedBlock,
+        segments,
+    };
+}

package/dist/web/i18n.d.ts

@@ -0,0 +1,31 @@
+export type WebRuntimeLocale = "en" | "zh";
+export type WebRuntimeMessages = {
+    chooseOption: string;
+    inputSectionTitle: string;
+    readSectionTitle: string;
+    writeSectionTitle: string;
+    sourceLabel: string;
+    viewRawMarkdownLink: string;
+    pageReadyStatus: string;
+    emptyBlock: string;
+    emptyList: string;
+    emptyImage: string;
+    imageAltFallback: string;
+    listItemFallback: string;
+    jsonInputEmpty: string;
+    jsonInputInvalid: string;
+    missingInput: string;
+    fillRequired: string;
+    operationRunning: string;
+    operationFailed: string;
+    operationSuccess: string;
+    networkError: string;
+    dependencyChainInterrupted: string;
+    blockErrorState: string;
+    dependencyNotReady: string;
+    unknownError: string;
+};
+export declare const WEB_RUNTIME_MESSAGES: Record<WebRuntimeLocale, WebRuntimeMessages>;
+export declare const DEFAULT_WEB_RUNTIME_LOCALE: WebRuntimeLocale;
+export declare function resolveWebRuntimeLocale(input?: string | null): WebRuntimeLocale;
+export declare function getWebRuntimeMessages(input?: string | null): WebRuntimeMessages;

package/dist/web/i18n.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_WEB_RUNTIME_LOCALE = exports.WEB_RUNTIME_MESSAGES = void 0;
+exports.resolveWebRuntimeLocale = resolveWebRuntimeLocale;
+exports.getWebRuntimeMessages = getWebRuntimeMessages;
+exports.WEB_RUNTIME_MESSAGES = {
+    en: {
+        chooseOption: "Please choose",
+        inputSectionTitle: "Input",
+        readSectionTitle: "Read",
+        writeSectionTitle: "Write",
+        sourceLabel: "Source",
+        viewRawMarkdownLink: "View raw Markdown",
+        pageReadyStatus: "Page loaded. Ready for action.",
+        emptyBlock: "No content yet.",
+        emptyList: "No entries yet.",
+        emptyImage: "No image yet.",
+        imageAltFallback: "image",
+        listItemFallback: "item",
+        jsonInputEmpty: "JSON input cannot be empty.",
+        jsonInputInvalid: "Invalid JSON input.",
+        missingInput: "Missing input: ",
+        fillRequired: "Please fill: ",
+        operationRunning: "Running: ",
+        operationFailed: "Failed: ",
+        operationSuccess: "Succeeded: ",
+        networkError: "Network error: ",
+        dependencyChainInterrupted: "Execution failed, dependency chain interrupted.",
+        blockErrorState: "This block is in an error state.",
+        dependencyNotReady: "Dependencies not ready: ",
+        unknownError: "UNKNOWN_ERROR",
+    },
+    zh: {
+        chooseOption: "请选择",
+        inputSectionTitle: "输入",
+        readSectionTitle: "读取",
+        writeSectionTitle: "写入",
+        sourceLabel: "源文件",
+        viewRawMarkdownLink: "查看原始 Markdown",
+        pageReadyStatus: "页面已加载，等待操作。",
+        emptyBlock: "暂无内容。",
+        emptyList: "还没有内容。",
+        emptyImage: "暂无图片。",
+        imageAltFallback: "image",
+        listItemFallback: "item",
+        jsonInputEmpty: "JSON 输入不能为空。",
+        jsonInputInvalid: "JSON 输入格式错误。",
+        missingInput: "缺少输入：",
+        fillRequired: "请先填写：",
+        operationRunning: "执行中：",
+        operationFailed: "执行失败：",
+        operationSuccess: "执行成功：",
+        networkError: "网络错误：",
+        dependencyChainInterrupted: "执行失败，依赖链已中断。",
+        blockErrorState: "当前 block 已进入错误状态。",
+        dependencyNotReady: "依赖未就绪：",
+        unknownError: "UNKNOWN_ERROR",
+    },
+};
+exports.DEFAULT_WEB_RUNTIME_LOCALE = "en";
+function resolveWebRuntimeLocale(input) {
+    if (typeof input !== "string")
+        return exports.DEFAULT_WEB_RUNTIME_LOCALE;
+    const normalized = input.trim().toLowerCase();
+    return normalized.startsWith("zh") ? "zh" : "en";
+}
+function getWebRuntimeMessages(input) {
+    return exports.WEB_RUNTIME_MESSAGES[resolveWebRuntimeLocale(input)];
+}