@mdsnai/sdk 0.1.0

package/dist/server/config.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = defineConfig;
+exports.resolveConfig = resolveConfig;
+function defineConfig(config) {
+    return config;
+}
+function resolveConfig(config) {
+    const locales = (config.i18n?.locales ?? ["en"]).filter((item) => item.trim().length > 0);
+    const defaultLocale = config.i18n?.defaultLocale ?? locales[0] ?? "en";
+    const normalizedLocales = locales.length > 0 ? locales : [defaultLocale];
+    if (!normalizedLocales.includes(defaultLocale)) {
+        normalizedLocales.unshift(defaultLocale);
+    }
+    return {
+        site: {
+            title: config.site?.title,
+            description: config.site?.description,
+            baseUrl: config.site?.baseUrl,
+        },
+        server: {
+            port: config.server?.port ?? 3000,
+        },
+        dirs: {
+            pages: config.dirs?.pages ?? "pages",
+            server: config.dirs?.server ?? "server",
+            public: config.dirs?.public ?? "public",
+            layouts: config.dirs?.layouts ?? "layouts",
+        },
+        markdown: {
+            linkify: config.markdown?.linkify ?? true,
+            typographer: config.markdown?.typographer ?? false,
+        },
+        dev: {
+            openBrowser: config.dev?.openBrowser ?? true,
+        },
+        i18n: {
+            defaultLocale,
+            locales: normalizedLocales,
+        },
+    };
+}

package/dist/server/dev.d.ts

@@ -0,0 +1,48 @@
+export type DevChange = {
+    version: number;
+    path: string;
+    changedAt: number;
+};
+export type DevParseError = {
+    path: string;
+    message: string;
+    timestamp: number;
+};
+export type DevActionError = {
+    actionId: string;
+    message: string;
+    timestamp: number;
+};
+export type DevActionRun = {
+    actionId: string;
+    pathname: string;
+    inputSummary: string;
+    status: "ok" | "failure" | "error";
+    timestamp: number;
+};
+export type DevEvent = {
+    type: "file-change";
+    version: number;
+    path: string;
+    timestamp: number;
+} | ({
+    type: "parse-error";
+} & DevParseError) | ({
+    type: "action-error";
+} & DevActionError) | ({
+    type: "action-run";
+} & DevActionRun);
+export type DevState = {
+    getVersion: () => number;
+    getLastChangedAt: () => number | null;
+    getRecentChanges: () => DevChange[];
+    getRecentActionRuns: () => DevActionRun[];
+    getRecentEvents: () => DevEvent[];
+    getLatestParseError: () => DevParseError | null;
+    getLatestActionError: () => DevActionError | null;
+    recordActionRun: (run: DevActionRun) => void;
+    setLatestParseError: (error: DevParseError | null) => void;
+    setLatestActionError: (error: DevActionError | null) => void;
+    bumpVersion: (changedPath?: string) => number;
+};
+export declare function createDevState(): DevState;

package/dist/server/dev.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDevState = createDevState;
+function createDevState() {
+    let version = 0;
+    let lastChangedAt = null;
+    const recentChanges = [];
+    const recentActionRuns = [];
+    const recentEvents = [];
+    let latestParseError = null;
+    let latestActionError = null;
+    function recordEvent(event) {
+        recentEvents.unshift(event);
+        if (recentEvents.length > 20) {
+            recentEvents.length = 20;
+        }
+    }
+    return {
+        getVersion() {
+            return version;
+        },
+        getLastChangedAt() {
+            return lastChangedAt;
+        },
+        getRecentChanges() {
+            return [...recentChanges];
+        },
+        getRecentActionRuns() {
+            return [...recentActionRuns];
+        },
+        getRecentEvents() {
+            return [...recentEvents];
+        },
+        getLatestParseError() {
+            return latestParseError;
+        },
+        getLatestActionError() {
+            return latestActionError;
+        },
+        recordActionRun(run) {
+            recentActionRuns.unshift(run);
+            if (recentActionRuns.length > 10) {
+                recentActionRuns.length = 10;
+            }
+            recordEvent({
+                type: "action-run",
+                ...run,
+            });
+        },
+        setLatestParseError(error) {
+            latestParseError = error;
+            if (error) {
+                recordEvent({
+                    type: "parse-error",
+                    ...error,
+                });
+            }
+        },
+        setLatestActionError(error) {
+            latestActionError = error;
+            if (error) {
+                recordEvent({
+                    type: "action-error",
+                    ...error,
+                });
+            }
+        },
+        bumpVersion(changedPath) {
+            version += 1;
+            lastChangedAt = Date.now();
+            if (changedPath) {
+                recentChanges.unshift({
+                    version,
+                    path: changedPath,
+                    changedAt: lastChangedAt,
+                });
+                if (recentChanges.length > 10) {
+                    recentChanges.length = 10;
+                }
+                recordEvent({
+                    type: "file-change",
+                    version,
+                    path: changedPath,
+                    timestamp: lastChangedAt,
+                });
+            }
+            return version;
+        },
+    };
+}

package/dist/server/index.d.ts

@@ -0,0 +1,8 @@
+export { defineAction, defineActions } from "./action";
+export { renderMarkdownFragment, renderMarkdownValue, serializeBlock, } from "./markdown";
+export { wantsHtml } from "./negotiate";
+export { executeActionHandler } from "./action-host";
+export { renderHostedPage } from "./page-host";
+export type { ActionContext, ActionDefinition, ActionDefinitionMap, ActionResult, } from "./action";
+export type { MarkdownImageValue, MarkdownTableValue, MarkdownValueType, RenderMarkdownFragmentOptions, SerializableBlock, SerializableInput, SerializableRead, SerializableRedirect, SerializableWrite, } from "./markdown";
+export type { HostedPageResponse } from "./page-host";

package/dist/server/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderHostedPage = exports.executeActionHandler = exports.wantsHtml = exports.serializeBlock = exports.renderMarkdownValue = exports.renderMarkdownFragment = exports.defineActions = exports.defineAction = void 0;
+var action_1 = require("./action");
+Object.defineProperty(exports, "defineAction", { enumerable: true, get: function () { return action_1.defineAction; } });
+Object.defineProperty(exports, "defineActions", { enumerable: true, get: function () { return action_1.defineActions; } });
+var markdown_1 = require("./markdown");
+Object.defineProperty(exports, "renderMarkdownFragment", { enumerable: true, get: function () { return markdown_1.renderMarkdownFragment; } });
+Object.defineProperty(exports, "renderMarkdownValue", { enumerable: true, get: function () { return markdown_1.renderMarkdownValue; } });
+Object.defineProperty(exports, "serializeBlock", { enumerable: true, get: function () { return markdown_1.serializeBlock; } });
+var negotiate_1 = require("./negotiate");
+Object.defineProperty(exports, "wantsHtml", { enumerable: true, get: function () { return negotiate_1.wantsHtml; } });
+var action_host_1 = require("./action-host");
+Object.defineProperty(exports, "executeActionHandler", { enumerable: true, get: function () { return action_host_1.executeActionHandler; } });
+var page_host_1 = require("./page-host");
+Object.defineProperty(exports, "renderHostedPage", { enumerable: true, get: function () { return page_host_1.renderHostedPage; } });

package/dist/server/init.d.ts

@@ -0,0 +1 @@
+export declare function createStarterSite(targetDir: string): void;

package/dist/server/init.js

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStarterSite = createStarterSite;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+function ensureEmptyDirectory(targetDir) {
+    if (!(0, node_fs_1.existsSync)(targetDir)) {
+        (0, node_fs_1.mkdirSync)(targetDir, { recursive: true });
+        return;
+    }
+    if ((0, node_fs_1.readdirSync)(targetDir).length > 0) {
+        throw new Error(`Target directory is not empty: ${targetDir}`);
+    }
+}
+function createStarterSite(targetDir) {
+    ensureEmptyDirectory(targetDir);
+    (0, node_fs_1.mkdirSync)(node_path_1.default.join(targetDir, "pages"), { recursive: true });
+    (0, node_fs_1.mkdirSync)(node_path_1.default.join(targetDir, "server"), { recursive: true });
+    const packageName = node_path_1.default.basename(targetDir).toLowerCase().replace(/[^a-z0-9-]+/g, "-") || "mdsn-site";
+    (0, node_fs_1.writeFileSync)(node_path_1.default.join(targetDir, "package.json"), JSON.stringify({
+        name: packageName,
+        private: true,
+        scripts: {
+            dev: "mdsn dev",
+            build: "mdsn build",
+            start: "mdsn start",
+        },
+        dependencies: {
+            "@mdsnai/sdk": "^0.1.0",
+        },
+    }, null, 2) + "\n", "utf8");
+    (0, node_fs_1.writeFileSync)(node_path_1.default.join(targetDir, "pages", "index.md"), `---
+id: guestbook
+title: Guestbook
+description: A runnable MDSN guestbook starter
+---
+
+# Guestbook
+
+Start with a working guestbook and reshape it into your own app.
+
+- \`read\` / \`write\` both return Markdown fragments
+- the Host only replaces the current \`guestbook\` block region
+- page content stays static while the block keeps updating
+
+<!-- mdsn:block guestbook -->
+
+\`\`\`mdsn
+block guestbook {
+  input nickname: text
+  input message!: text
+  read refresh: "/list"
+  write submit: "/post" (nickname, message)
+}
+\`\`\`
+`, "utf8");
+    (0, node_fs_1.writeFileSync)(node_path_1.default.join(targetDir, "server", "actions.cjs"), `const {
+  defineAction,
+  defineActions,
+  renderMarkdownFragment,
+  renderMarkdownValue,
+} = require("@mdsnai/sdk/server");
+
+const guestbookBlock = {
+  name: "guestbook",
+  inputs: [
+    { name: "nickname", type: "text" },
+    { name: "message", type: "text", required: true },
+  ],
+  reads: [{ name: "refresh", target: "/list" }],
+  writes: [{ name: "submit", target: "/post", inputs: ["nickname", "message"] }],
+};
+
+function getGuestbookStore() {
+  if (!globalThis.__mdsnStarterGuestbookMessages) {
+    globalThis.__mdsnStarterGuestbookMessages = [];
+  }
+
+  return globalThis.__mdsnStarterGuestbookMessages;
+}
+
+function listGuestbookMessages() {
+  return getGuestbookStore().map((entry) => ({ ...entry }));
+}
+
+function renderGuestbookFragment(messages) {
+  return renderMarkdownFragment({
+    body: [
+      "## Messages",
+      messages.length > 0
+        ? renderMarkdownValue(
+          "list",
+          messages.map((entry) => \`**\${entry.nickname}**: \${entry.message}\`),
+        )
+        : "_No messages yet._",
+    ],
+    block: guestbookBlock,
+  });
+}
+
+function addGuestbookMessage(message) {
+  const store = getGuestbookStore();
+  const entry = {
+    id: \`\${Date.now()}-\${Math.random().toString(36).slice(2, 8)}\`,
+    nickname: message.nickname,
+    message: message.message,
+    createdAt: new Date().toISOString(),
+  };
+
+  store.unshift(entry);
+  if (store.length > 20) {
+    store.length = 20;
+  }
+
+  return { ...entry };
+}
+
+module.exports = defineActions({
+  list: defineAction({
+    async run() {
+      return renderGuestbookFragment(listGuestbookMessages());
+    },
+  }),
+  post: defineAction({
+    async run(ctx) {
+      const nickname = String(ctx.inputs.nickname ?? "").trim() || "Guest";
+      const message = String(ctx.inputs.message ?? "").trim();
+
+      if (!message) {
+        return {
+          ok: false,
+          errorCode: "EMPTY_MESSAGE",
+          fieldErrors: {
+            message: "Please enter a message.",
+          },
+        };
+      }
+
+      addGuestbookMessage({ nickname, message });
+      return renderGuestbookFragment(listGuestbookMessages());
+    },
+  }),
+});
+`, "utf8");
+    (0, node_fs_1.writeFileSync)(node_path_1.default.join(targetDir, "README.md"), `# ${packageName}
+
+Starter: runnable guestbook
+
+## Commands
+
+\`\`\`bash
+npm run dev
+npm run build
+npm run start
+\`\`\`
+
+Open:
+
+\`\`\`text
+http://localhost:3000/
+\`\`\`
+
+Key files:
+
+- \`pages/index.md\`
+- \`server/actions.cjs\`
+
+Optional next steps:
+
+- Add \`mdsn.config.cjs\` when you need custom settings
+- Add \`layouts/default.html\` when you want a custom layout
+`, "utf8");
+}

package/dist/server/layout.d.ts

@@ -0,0 +1,17 @@
+export type LayoutTemplateContext = {
+    title: string;
+    description: string;
+    content: string;
+    locale: string;
+    defaultLocale: string;
+    pathname?: string;
+    canonicalUrl?: string;
+    ogImageUrl?: string;
+    siteName?: string;
+    markdownAlternateUrl?: string;
+    hreflangLinks?: string;
+    posthogProjectApiKey?: string;
+    posthogHost?: string;
+};
+export declare function applyLayoutTemplate(template: string, context: LayoutTemplateContext): string;
+export declare function resolveLocaleForRoutePath(routePath: string, locales: string[], defaultLocale: string): string;

package/dist/server/layout.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyLayoutTemplate = applyLayoutTemplate;
+exports.resolveLocaleForRoutePath = resolveLocaleForRoutePath;
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+function applyLayoutTemplate(template, context) {
+    const replacementByKey = {
+        title: escapeHtml(context.title),
+        description: escapeHtml(context.description),
+        content: context.content,
+        lang: escapeHtml(context.locale),
+        locale: escapeHtml(context.locale),
+        defaultLocale: escapeHtml(context.defaultLocale),
+        pathname: escapeHtml(context.pathname ?? ""),
+        canonical_url: escapeHtml(context.canonicalUrl ?? ""),
+        og_image_url: escapeHtml(context.ogImageUrl ?? ""),
+        site_name: escapeHtml(context.siteName ?? ""),
+        markdown_alternate_url: escapeHtml(context.markdownAlternateUrl ?? ""),
+        hreflang_links: context.hreflangLinks ?? "",
+        posthog_project_api_key: escapeHtml(context.posthogProjectApiKey ?? ""),
+        posthog_host: escapeHtml(context.posthogHost ?? ""),
+    };
+    return template.replace(/\{\{\s*([a-zA-Z_][\w-]*)\s*\}\}/g, (_match, key) => {
+        return replacementByKey[key] ?? "";
+    });
+}
+function resolveLocaleForRoutePath(routePath, locales, defaultLocale) {
+    const firstSegment = routePath.split("/").filter(Boolean)[0];
+    if (firstSegment && locales.includes(firstSegment)) {
+        return firstSegment;
+    }
+    return defaultLocale;
+}

package/dist/server/markdown.d.ts

@@ -0,0 +1,53 @@
+import type { InputType } from "../core";
+export type MarkdownValueType = "text" | "list" | "table" | "json" | "image";
+export type MarkdownTableValue = {
+    columns: string[];
+    rows: Array<Array<string | number | boolean | null | undefined>>;
+};
+export type MarkdownImageValue = string | {
+    src: string;
+    alt?: string;
+    title?: string;
+};
+export type MarkdownValue = string | string[] | Record<string, unknown> | MarkdownTableValue | MarkdownImageValue;
+export type SerializableInput = {
+    name: string;
+    type: InputType;
+    required?: boolean;
+    secret?: boolean;
+    options?: string[];
+    schema?: string;
+};
+export type SerializableRead = {
+    name: string;
+    target: string;
+    inputs?: string[];
+};
+export type SerializableWrite = {
+    name: string;
+    target: string;
+    inputs?: string[];
+};
+export type SerializableRedirect = {
+    target: string;
+};
+export type SerializableBlock = {
+    name: string;
+    inputs?: SerializableInput[];
+    reads?: SerializableRead[];
+    writes?: SerializableWrite[];
+    redirects?: SerializableRedirect[];
+};
+export type RenderMarkdownFragmentOptions = {
+    body?: string | string[];
+    block?: SerializableBlock;
+};
+export declare function renderMarkdownValue(type: "text", value: string, options?: never): string;
+export declare function renderMarkdownValue(type: "list", value: string[], options?: never): string;
+export declare function renderMarkdownValue(type: "table", value: MarkdownTableValue, options?: never): string;
+export declare function renderMarkdownValue(type: "json", value: Record<string, unknown>, options?: {
+    indent?: number;
+}): string;
+export declare function renderMarkdownValue(type: "image", value: MarkdownImageValue, options?: never): string;
+export declare function serializeBlock(block: SerializableBlock): string;
+export declare function renderMarkdownFragment(options: RenderMarkdownFragmentOptions): string;

package/dist/server/markdown.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMarkdownValue = renderMarkdownValue;
+exports.serializeBlock = serializeBlock;
+exports.renderMarkdownFragment = renderMarkdownFragment;
+function joinBody(body) {
+    if (!body) {
+        return "";
+    }
+    return Array.isArray(body)
+        ? body.filter((part) => part.trim().length > 0).join("\n\n")
+        : body.trim();
+}
+function escapeTableCell(value) {
+    return String(value ?? "").replace(/\|/g, "\\|").replace(/\n/g, "<br />");
+}
+function formatIdentifierList(inputs) {
+    return inputs && inputs.length > 0 ? ` (${inputs.join(", ")})` : "";
+}
+function renderMarkdownValue(type, value, options) {
+    switch (type) {
+        case "text":
+            return String(value);
+        case "list":
+            return value.map((item) => `- ${item}`).join("\n");
+        case "table": {
+            const table = value;
+            const header = `| ${table.columns.map(escapeTableCell).join(" | ")} |`;
+            const divider = `| ${table.columns.map(() => "---").join(" | ")} |`;
+            const rows = table.rows.map((row) => `| ${row.map(escapeTableCell).join(" | ")} |`);
+            return [header, divider, ...rows].join("\n");
+        }
+        case "json":
+            return `\`\`\`json\n${JSON.stringify(value, null, options?.indent ?? 2)}\n\`\`\``;
+        case "image": {
+            const image = value;
+            if (typeof image === "string") {
+                return `![](${image})`;
+            }
+            const title = image.title ? ` "${image.title.replace(/"/g, '\\"')}"` : "";
+            return `![${image.alt ?? ""}](${image.src}${title})`;
+        }
+    }
+}
+function serializeBlock(block) {
+    const lines = ["```mdsn", `block ${block.name} {`];
+    for (const input of block.inputs ?? []) {
+        const requiredMarker = input.required ? "!" : "";
+        const secretMarker = input.secret ? " secret" : "";
+        const optionsLiteral = input.options ? ` ${JSON.stringify(input.options)}` : "";
+        const schemaName = input.schema ? ` ${input.schema}` : "";
+        lines.push(`  input ${input.name}${requiredMarker}: ${input.type}${secretMarker}${optionsLiteral}${schemaName}`);
+    }
+    for (const read of block.reads ?? []) {
+        lines.push(`  read ${read.name}: "${read.target}"${formatIdentifierList(read.inputs)}`);
+    }
+    for (const write of block.writes ?? []) {
+        lines.push(`  write ${write.name}: "${write.target}"${formatIdentifierList(write.inputs)}`);
+    }
+    for (const redirect of block.redirects ?? []) {
+        lines.push(`  redirect "${redirect.target}"`);
+    }
+    lines.push("}", "```");
+    return lines.join("\n");
+}
+function renderMarkdownFragment(options) {
+    const parts = [];
+    const body = joinBody(options.body);
+    if (body) {
+        parts.push(body);
+    }
+    if (options.block) {
+        parts.push(serializeBlock(options.block));
+    }
+    return parts.join("\n\n").trimEnd() + "\n";
+}

package/dist/server/module-loader.d.ts

@@ -0,0 +1,4 @@
+export type ImportModuleFromFileOptions = {
+    fresh?: boolean;
+};
+export declare function importModuleFromFile(filePath: string, options?: ImportModuleFromFileOptions): Promise<Record<string, unknown>>;

package/dist/server/module-loader.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importModuleFromFile = importModuleFromFile;
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const requireFromCwd = (0, node_module_1.createRequire)(node_path_1.default.join(process.cwd(), "package.json"));
+function toImportSpecifier(filePath, options) {
+    const url = (0, node_url_1.pathToFileURL)(filePath);
+    if (options.fresh) {
+        url.searchParams.set("ts", String(Date.now()));
+    }
+    return url.href;
+}
+function requireModuleFromFile(filePath, options) {
+    if (!options.fresh) {
+        return requireFromCwd(filePath);
+    }
+    const resolvedPath = requireFromCwd.resolve(filePath);
+    delete requireFromCwd.cache[resolvedPath];
+    return requireFromCwd(filePath);
+}
+async function importModuleFromFile(filePath, options = {}) {
+    try {
+        return await Promise.resolve(`${toImportSpecifier(filePath, options)}`).then(s => __importStar(require(s)));
+    }
+    catch (importError) {
+        try {
+            return requireModuleFromFile(filePath, options);
+        }
+        catch {
+            throw importError;
+        }
+    }
+}

package/dist/server/negotiate.d.ts

@@ -0,0 +1,3 @@
+export declare function wantsHtml(acceptHeader?: string): boolean;
+export declare function wantsMarkdown(acceptHeader?: string): boolean;
+export declare function isNotAcceptableRequest(acceptHeader?: string): boolean;