@mp-lb/mdkit 0.0.1-main.2.1

package/dist/markdown/normalizeMarkdownSerialization.js

@@ -0,0 +1,34 @@
+const placeholderLinePattern = /^[ \t]*(?: |\u00a0)[ \t]*$/;
+const normalizePlaceholderParagraphs = (markdown) => {
+    const lines = markdown.split("\n");
+    const normalizedLines = [];
+    let index = 0;
+    while (index < lines.length) {
+        const line = lines[index] ?? "";
+        if (line !== "" && !placeholderLinePattern.test(line)) {
+            normalizedLines.push(line);
+            index += 1;
+            continue;
+        }
+        const start = index;
+        let placeholderCount = 0;
+        while (index < lines.length &&
+            ((lines[index] ?? "") === "" ||
+                placeholderLinePattern.test(lines[index] ?? ""))) {
+            if (placeholderLinePattern.test(lines[index] ?? "")) {
+                placeholderCount += 1;
+            }
+            index += 1;
+        }
+        if (placeholderCount === 0) {
+            normalizedLines.push(...lines.slice(start, index));
+            continue;
+        }
+        normalizedLines.push(...Array.from({ length: placeholderCount + 1 }, () => ""));
+    }
+    const normalizedMarkdown = normalizedLines.join("\n");
+    return placeholderLinePattern.test(normalizedMarkdown.trim())
+        ? ""
+        : normalizedMarkdown;
+};
+export const normalizeMarkdownSerialization = (markdown) => normalizePlaceholderParagraphs(markdown.replace(/^([ \t]*(?:[-*+]|\d+[.)])[ \t]+)(?:&nbsp;|\u00a0)[ \t]*$/gm, "$1"));

package/dist/markdown/normalizeMarkdownSerialization.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/markdown/normalizeMarkdownSerialization.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { normalizeMarkdownSerialization } from "./normalizeMarkdownSerialization";
+describe("normalizeMarkdownSerialization", () => {
+    it("removes TipTap non-breaking-space placeholders from empty list items", () => {
+        expect(normalizeMarkdownSerialization("- first\n-  \n- third\n\n1. first\n2. \u00a0")).toBe("- first\n- \n- third\n\n1. first\n2. ");
+    });
+    it("does not remove non-breaking-space text outside empty list items", () => {
+        expect(normalizeMarkdownSerialization("Paragraph  \n\n- real")).toBe("Paragraph  \n\n- real");
+    });
+    it("removes standalone TipTap non-breaking-space placeholder lines", () => {
+        expect(normalizeMarkdownSerialization("- first\n\n \n\n\u00a0")).toBe("- first\n\n\n");
+    });
+    it("normalizes hydrated empty paragraphs back to the original newline run", () => {
+        expect(normalizeMarkdownSerialization("Before\n\n \n\n \n\n \n\nAfter")).toBe("Before\n\n\n\n\nAfter");
+    });
+});

package/dist/markdown/prepareMarkdownForEditorHydration.d.ts

@@ -0,0 +1 @@
+export declare const prepareMarkdownForEditorHydration: (markdown: string) => string;

package/dist/markdown/prepareMarkdownForEditorHydration.js

@@ -0,0 +1,12 @@
+import { getMarkdownFenceRanges, isInsideMarkdownFence, } from "./markdownFenceRanges";
+const expandedBlankLineRunPattern = /\n{3,}/g;
+export const prepareMarkdownForEditorHydration = (markdown) => {
+    const fenceRanges = getMarkdownFenceRanges(markdown);
+    return markdown.replace(expandedBlankLineRunPattern, (newlineRun, offset) => {
+        if (isInsideMarkdownFence(offset, fenceRanges)) {
+            return newlineRun;
+        }
+        const emptyParagraphs = Array.from({ length: newlineRun.length - 2 }, () => " ").join("\n\n");
+        return `\n\n${emptyParagraphs}\n\n`;
+    });
+};

package/dist/markdown/prepareMarkdownForEditorHydration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/markdown/prepareMarkdownForEditorHydration.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import { prepareMarkdownForEditorHydration } from "./prepareMarkdownForEditorHydration";
+describe("prepareMarkdownForEditorHydration", () => {
+    it("converts expanded blank-line runs into empty paragraphs for TipTap", () => {
+        expect(prepareMarkdownForEditorHydration("Before\n\n\n\nAfter")).toBe("Before\n\n \n\n \n\nAfter");
+    });
+    it("keeps normal block separators unchanged", () => {
+        expect(prepareMarkdownForEditorHydration("Before\n\nAfter")).toBe("Before\n\nAfter");
+    });
+    it("does not convert blank lines inside fenced code blocks", () => {
+        expect(prepareMarkdownForEditorHydration("Before\n\n```ts\nconst one = 1;\n\n\nconst two = 2;\n```\n\n\nAfter")).toBe("Before\n\n```ts\nconst one = 1;\n\n\nconst two = 2;\n```\n\n \n\nAfter");
+    });
+});

package/dist/markdown/preserveMarkdownWhitespace.d.ts

@@ -0,0 +1 @@
+export declare const preserveMarkdownWhitespace: (previousRawMarkdown: string, nextSerializedMarkdown: string) => string;

package/dist/markdown/preserveMarkdownWhitespace.js

@@ -0,0 +1,86 @@
+import { getMarkdownFenceRanges, isInsideMarkdownFence, } from "./markdownFenceRanges";
+const tokenizeMarkdownBlocks = (markdown) => {
+    const ranges = getMarkdownFenceRanges(markdown);
+    const tokens = [];
+    const separatorPattern = /\n{2,}/g;
+    let contentStart = 0;
+    let match;
+    while ((match = separatorPattern.exec(markdown))) {
+        const separatorStart = match.index;
+        const separator = match[0] ?? "";
+        if (isInsideMarkdownFence(separatorStart, ranges)) {
+            continue;
+        }
+        tokens.push({
+            content: markdown.slice(contentStart, separatorStart),
+            separatorAfter: separator,
+        });
+        contentStart = separatorStart + separator.length;
+    }
+    tokens.push({
+        content: markdown.slice(contentStart),
+        separatorAfter: "",
+    });
+    return tokens;
+};
+const blockPairKey = (left, right) => `${left.content.trim()}\u0000${right.content.trim()}`;
+const leadingNewlineRunPattern = /^\n+/;
+const trailingNewlineRunPattern = /\n+$/;
+const preserveOuterBlankLines = (previousRawMarkdown, nextSerializedMarkdown) => {
+    const previousLeading = previousRawMarkdown.match(leadingNewlineRunPattern);
+    const nextLeading = nextSerializedMarkdown.match(leadingNewlineRunPattern);
+    const previousTrailing = previousRawMarkdown.match(trailingNewlineRunPattern);
+    const nextTrailing = nextSerializedMarkdown.match(trailingNewlineRunPattern);
+    const isBodyUnchanged = previousRawMarkdown.trim() === nextSerializedMarkdown.trim();
+    let nextMarkdown = nextSerializedMarkdown;
+    if (isBodyUnchanged &&
+        previousLeading &&
+        previousLeading[0].length > (nextLeading?.[0].length ?? 0)) {
+        nextMarkdown = `${previousLeading[0]}${nextMarkdown.trimStart()}`;
+    }
+    if (isBodyUnchanged &&
+        previousTrailing &&
+        previousTrailing[0].length > (nextTrailing?.[0].length ?? 0)) {
+        nextMarkdown = `${nextMarkdown.trimEnd()}${previousTrailing[0]}`;
+    }
+    return nextMarkdown;
+};
+export const preserveMarkdownWhitespace = (previousRawMarkdown, nextSerializedMarkdown) => {
+    const outerPreservedMarkdown = preserveOuterBlankLines(previousRawMarkdown, nextSerializedMarkdown);
+    if (previousRawMarkdown === outerPreservedMarkdown ||
+        !previousRawMarkdown.includes("\n\n") ||
+        !outerPreservedMarkdown.includes("\n\n")) {
+        return outerPreservedMarkdown;
+    }
+    const previousTokens = tokenizeMarkdownBlocks(previousRawMarkdown);
+    const nextTokens = tokenizeMarkdownBlocks(outerPreservedMarkdown);
+    if (previousTokens.length < 2 || nextTokens.length < 2) {
+        return outerPreservedMarkdown;
+    }
+    const preservedSeparators = new Map();
+    for (let index = 0; index < previousTokens.length - 1; index += 1) {
+        const left = previousTokens[index];
+        const right = previousTokens[index + 1];
+        if (!left || !right || left.separatorAfter.length <= 2) {
+            continue;
+        }
+        preservedSeparators.set(blockPairKey(left, right), left.separatorAfter);
+    }
+    if (preservedSeparators.size === 0) {
+        return outerPreservedMarkdown;
+    }
+    return nextTokens
+        .map((token, index) => {
+        const nextToken = nextTokens[index + 1];
+        if (!nextToken || !token.separatorAfter) {
+            return token.content;
+        }
+        const preservedSeparator = preservedSeparators.get(blockPairKey(token, nextToken));
+        const separator = preservedSeparator &&
+            preservedSeparator.length > token.separatorAfter.length
+            ? preservedSeparator
+            : token.separatorAfter;
+        return `${token.content}${separator}`;
+    })
+        .join("");
+};

package/dist/markdown/preserveMarkdownWhitespace.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/markdown/preserveMarkdownWhitespace.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { preserveMarkdownWhitespace } from "./preserveMarkdownWhitespace";
+describe("preserveMarkdownWhitespace", () => {
+    it("preserves expanded blank-line runs between unchanged blocks", () => {
+        expect(preserveMarkdownWhitespace("# Title\n\n\nFirst paragraph.\n\n\n\nSecond paragraph.", "# Title\n\nFirst paragraph.\n\nSecond paragraph.")).toBe("# Title\n\n\nFirst paragraph.\n\n\n\nSecond paragraph.");
+    });
+    it("preserves blank-line runs between unchanged list and paragraph blocks", () => {
+        expect(preserveMarkdownWhitespace("- first\n- second\n\n\nParagraph.", "- first\n- second\n\nParagraph.")).toBe("- first\n- second\n\n\nParagraph.");
+    });
+    it("preserves blank-line runs between unchanged blockquote and table blocks", () => {
+        expect(preserveMarkdownWhitespace("> Quoted text.\n\n\n| A | B |\n| - | - |\n| 1 | 2 |", "> Quoted text.\n\n| A | B |\n| - | - |\n| 1 | 2 |")).toBe("> Quoted text.\n\n\n| A | B |\n| - | - |\n| 1 | 2 |");
+    });
+    it("preserves leading and trailing blank-line runs when the body is unchanged", () => {
+        expect(preserveMarkdownWhitespace("\n\n# Title\n\nParagraph.\n\n\n", "# Title\n\nParagraph.")).toBe("\n\n# Title\n\nParagraph.\n\n\n");
+    });
+    it("keeps serialized markdown when adjacent block content changed", () => {
+        expect(preserveMarkdownWhitespace("# Title\n\n\nFirst paragraph.", "# Title\n\nChanged paragraph.")).toBe("# Title\n\nChanged paragraph.");
+    });
+    it("does not preserve separators from inside fenced code blocks", () => {
+        expect(preserveMarkdownWhitespace("```ts\nconst a = 1;\n\n\nconst b = 2;\n```\n\n\nAfter.", "```ts\nconst a = 1;\n\nconst b = 2;\n```\n\nAfter.")).toBe("```ts\nconst a = 1;\n\nconst b = 2;\n```\n\nAfter.");
+    });
+    it("preserves separators around unchanged fenced code blocks", () => {
+        expect(preserveMarkdownWhitespace("Before.\n\n\n```ts\nconst a = 1;\n\nconst b = 2;\n```\n\n\nAfter.", "Before.\n\n```ts\nconst a = 1;\n\nconst b = 2;\n```\n\nAfter.")).toBe("Before.\n\n\n```ts\nconst a = 1;\n\nconst b = 2;\n```\n\n\nAfter.");
+    });
+});

package/dist/test/setup.d.ts

@@ -0,0 +1 @@
+import "@testing-library/jest-dom/vitest";

package/dist/test/setup.js

@@ -0,0 +1,13 @@
+import "@testing-library/jest-dom/vitest";
+if (!window.matchMedia) {
+    window.matchMedia = () => ({
+        addEventListener: () => undefined,
+        addListener: () => undefined,
+        dispatchEvent: () => false,
+        matches: false,
+        media: "",
+        onchange: null,
+        removeEventListener: () => undefined,
+        removeListener: () => undefined,
+    });
+}

package/dist/theme/MdKitThemeEditor.d.ts

@@ -0,0 +1,8 @@
+import type { MdKitEditorTheme } from "./editorTheme";
+export type MdKitThemeEditorProps = {
+    className?: string;
+    onChange: (theme: MdKitEditorTheme) => void;
+    onReset?: () => void;
+    theme: MdKitEditorTheme;
+};
+export declare const MdKitThemeEditor: ({ className, onChange, onReset, theme, }: MdKitThemeEditorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/theme/MdKitThemeEditor.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export const MdKitThemeEditor = ({ className, onChange, onReset, theme, }) => {
+    const updateTheme = (patch) => {
+        onChange({
+            ...theme,
+            ...patch,
+        });
+    };
+    return (_jsxs("div", { className: ["hsk-theme-editor", className].filter(Boolean).join(" "), children: [_jsxs("label", { children: [_jsx("span", { children: "Background" }), _jsx("input", { type: "color", value: theme.background, onChange: (event) => updateTheme({ background: event.target.value }) })] }), _jsxs("label", { children: [_jsx("span", { children: "Text" }), _jsx("input", { type: "color", value: theme.foreground, onChange: (event) => updateTheme({ foreground: event.target.value }) })] }), _jsxs("label", { children: [_jsx("span", { children: "Link" }), _jsx("input", { type: "color", value: theme.link, onChange: (event) => updateTheme({ link: event.target.value }) })] }), _jsxs("label", { children: [_jsx("span", { children: "Code" }), _jsx("input", { type: "color", value: theme.codeBackground, onChange: (event) => updateTheme({
+                            codeBackground: event.target.value,
+                            muted: event.target.value,
+                        }) })] }), _jsxs("label", { children: [_jsx("span", { children: "Font size" }), _jsx("input", { type: "range", min: "13", max: "22", value: Number.parseInt(theme.fontSize, 10), onChange: (event) => updateTheme({ fontSize: `${event.target.value}px` }) })] }), _jsxs("label", { children: [_jsx("span", { children: "Font" }), _jsxs("select", { value: theme.fontFamily, onChange: (event) => updateTheme({ fontFamily: event.target.value }), children: [_jsx("option", { value: "inherit", children: "App default" }), _jsx("option", { value: "ui-serif, Georgia, Cambria, serif", children: "Serif" }), _jsx("option", { value: "ui-sans-serif, system-ui, sans-serif", children: "Sans" }), _jsx("option", { value: "ui-monospace, SFMono-Regular, Menlo, monospace", children: "Mono" })] })] }), _jsxs("label", { children: [_jsx("span", { children: "Line height" }), _jsx("input", { type: "range", min: "1.2", max: "2.2", step: "0.1", value: theme.lineHeight, onChange: (event) => updateTheme({ lineHeight: event.target.value }) })] }), _jsxs("label", { children: [_jsx("span", { children: "Padding" }), _jsx("input", { type: "range", min: "0", max: "32", value: Number.parseInt(theme.surfacePadding, 10), onChange: (event) => updateTheme({ surfacePadding: `${event.target.value}px` }) })] }), _jsxs("label", { children: [_jsx("span", { children: "Code radius" }), _jsx("input", { type: "range", min: "0", max: "16", value: Number.parseInt(theme.codeRadius, 10), onChange: (event) => updateTheme({ codeRadius: `${event.target.value}px` }) })] }), onReset ? (_jsx("button", { type: "button", onClick: onReset, children: "Reset style" })) : null] }));
+};

package/dist/theme/editorTheme.d.ts

@@ -0,0 +1,20 @@
+import type { CSSProperties } from "react";
+export type MdKitEditorTheme = {
+    background: string;
+    blockGap: string;
+    border: string;
+    codeBackground: string;
+    codeRadius: string;
+    fontFamily: string;
+    fontSize: string;
+    foreground: string;
+    lineHeight: string;
+    link: string;
+    muted: string;
+    mutedForeground: string;
+    surfacePadding: string;
+};
+export type MdKitEditorThemeStyle = CSSProperties & Record<`--hsk-${string}`, string>;
+export declare const defaultMdKitEditorTheme: MdKitEditorTheme;
+export declare const darkMdKitEditorTheme: MdKitEditorTheme;
+export declare const createMdKitEditorThemeStyle: (theme: MdKitEditorTheme) => MdKitEditorThemeStyle;

package/dist/theme/editorTheme.js

@@ -0,0 +1,47 @@
+export const defaultMdKitEditorTheme = {
+    background: "#ffffff",
+    blockGap: "0.75rem",
+    border: "#d8dee8",
+    codeBackground: "#eef1f4",
+    codeRadius: "0.35rem",
+    fontFamily: "inherit",
+    fontSize: "16px",
+    foreground: "#18212f",
+    lineHeight: "1.7",
+    link: "#4f46e5",
+    muted: "#eef1f4",
+    mutedForeground: "#5b6472",
+    surfacePadding: "1rem",
+};
+export const darkMdKitEditorTheme = {
+    background: "#0b1220",
+    blockGap: "0.75rem",
+    border: "#314158",
+    codeBackground: "#111827",
+    codeRadius: "0.35rem",
+    fontFamily: "inherit",
+    fontSize: "16px",
+    foreground: "#e5edf7",
+    lineHeight: "1.7",
+    link: "#38bdf8",
+    muted: "#172033",
+    mutedForeground: "#94a3b8",
+    surfacePadding: "1rem",
+};
+export const createMdKitEditorThemeStyle = (theme) => ({
+    "--hsk-background": theme.background,
+    "--hsk-block-gap": theme.blockGap,
+    "--hsk-border": theme.border,
+    "--hsk-code-background": theme.codeBackground,
+    "--hsk-code-radius": theme.codeRadius,
+    "--hsk-code-block-radius": theme.codeRadius,
+    "--hsk-font-family": theme.fontFamily,
+    "--hsk-font-size": theme.fontSize,
+    "--hsk-foreground": theme.foreground,
+    "--hsk-line-height": theme.lineHeight,
+    "--hsk-link": theme.link,
+    "--hsk-muted": theme.muted,
+    "--hsk-muted-foreground": theme.mutedForeground,
+    "--hsk-quote-border-color": theme.border,
+    "--hsk-surface-padding": theme.surfacePadding,
+});

package/dist/transport/fastify.d.ts

@@ -0,0 +1,7 @@
+import type { FastifyInstance } from "fastify";
+import type { MdKitTransportStore } from "./store";
+export type RegisterMdKitFastifyOptions = {
+    prefix?: string;
+    store: MdKitTransportStore;
+};
+export declare const registerMdKitFastify: (app: FastifyInstance, { prefix, store }: RegisterMdKitFastifyOptions) => Promise<void>;

package/dist/transport/fastify.js

@@ -0,0 +1,19 @@
+import { createMdKitHttpHandlers } from "./http";
+const send = async (reply, response) => {
+    const { body, status } = await response;
+    return reply.status(status).send(body);
+};
+const toRequest = (request) => ({
+    body: request.body,
+    params: request.params,
+    query: request.query,
+});
+export const registerMdKitFastify = async (app, { prefix = "", store }) => {
+    const handlers = createMdKitHttpHandlers(store);
+    app.get(`${prefix}/documents`, (request, reply) => send(reply, handlers.readDocument(toRequest(request))));
+    app.put(`${prefix}/documents`, (request, reply) => send(reply, handlers.writeDocument(toRequest(request))));
+    app.post(`${prefix}/documents/resync`, (request, reply) => send(reply, handlers.resyncDocument(toRequest(request))));
+    app.get(`${prefix}/versions`, (request, reply) => send(reply, handlers.listDocumentVersions(toRequest(request))));
+    app.get(`${prefix}/versions/:versionId`, (request, reply) => send(reply, handlers.readDocumentVersion(toRequest(request))));
+    app.post(`${prefix}/versions/:versionId/restore`, (request, reply) => send(reply, handlers.restoreDocumentVersion(toRequest(request))));
+};

package/dist/transport/http.d.ts

@@ -0,0 +1,43 @@
+import type { MdKitTransportStore } from "./store";
+export type MdKitHttpRequest = {
+    body?: unknown;
+    params?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+};
+export type MdKitHttpResponse<T = unknown> = {
+    body: T;
+    status: number;
+};
+export type MdKitHttpHandlers = ReturnType<typeof createMdKitHttpHandlers>;
+export declare const createMdKitHttpHandlers: (store: MdKitTransportStore) => {
+    readDocument: (request: MdKitHttpRequest) => Promise<{
+        body: import("..").MdKitDocumentSnapshot;
+        status: number;
+    }>;
+    writeDocument: (request: MdKitHttpRequest) => Promise<{
+        body: import("..").MdKitDocumentWriteResult;
+        status: number;
+    }>;
+    resyncDocument: (request: MdKitHttpRequest) => Promise<{
+        body: import("..").MdKitDocumentSnapshot;
+        status: number;
+    }>;
+    listDocumentVersions: (request: MdKitHttpRequest) => Promise<{
+        body: {
+            versions: import("..").MdKitDocumentVersionSummary[];
+        };
+        status: number;
+    }>;
+    readDocumentVersion: (request: MdKitHttpRequest) => Promise<MdKitHttpResponse<{
+        error: string;
+    }> | {
+        readonly body: import("..").MdKitDocumentVersionDetail;
+        readonly status: 200;
+    }>;
+    restoreDocumentVersion: (request: MdKitHttpRequest) => Promise<MdKitHttpResponse<{
+        error: string;
+    }> | {
+        body: import("..").MdKitDocumentWriteResult;
+        status: number;
+    }>;
+};

package/dist/transport/http.js

@@ -0,0 +1,80 @@
+const readString = (source, key) => {
+    const value = source?.[key];
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`Missing mdkit ${key}`);
+    }
+    return value;
+};
+const readVersionToken = (value) => {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number") {
+        return value;
+    }
+    throw new Error("Invalid mdkit baseVersion");
+};
+const readWriteInput = (request) => {
+    const body = request.body;
+    if (!body || typeof body !== "object") {
+        throw new Error("Missing mdkit write body");
+    }
+    const content = body.content;
+    if (typeof content !== "string") {
+        throw new Error("Invalid mdkit content");
+    }
+    return {
+        baseVersion: readVersionToken(body.baseVersion),
+        content,
+        documentId: readString(request.query, "documentId"),
+        force: body.force === true,
+    };
+};
+const notFound = (message) => ({
+    body: { error: message },
+    status: 404,
+});
+export const createMdKitHttpHandlers = (store) => ({
+    readDocument: async (request) => ({
+        body: await store.readDocument(readString(request.query, "documentId")),
+        status: 200,
+    }),
+    writeDocument: async (request) => {
+        const body = await store.writeDocument(readWriteInput(request));
+        return {
+            body,
+            status: "conflict" in body ? 409 : 200,
+        };
+    },
+    resyncDocument: async (request) => ({
+        body: await (store.resyncDocument ?? store.readDocument)(readString(request.query, "documentId")),
+        status: 200,
+    }),
+    listDocumentVersions: async (request) => ({
+        body: {
+            versions: await (store.listDocumentVersions?.(readString(request.query, "documentId")) ?? []),
+        },
+        status: 200,
+    }),
+    readDocumentVersion: async (request) => {
+        const version = await store.readDocumentVersion?.({
+            documentId: readString(request.query, "documentId"),
+            versionId: readString(request.params, "versionId"),
+        });
+        return version
+            ? { body: version, status: 200 }
+            : notFound("Version not found");
+    },
+    restoreDocumentVersion: async (request) => {
+        if (!store.restoreDocumentVersion) {
+            return notFound("Version restore is not supported");
+        }
+        const input = {
+            documentId: readString(request.query, "documentId"),
+            versionId: readString(request.params, "versionId"),
+        };
+        return {
+            body: await store.restoreDocumentVersion(input),
+            status: 200,
+        };
+    },
+});

package/dist/transport/index.d.ts

@@ -0,0 +1,5 @@
+export { createMdKitHttpHandlers } from "./http";
+export { createMdKitRestAdapter } from "./rest";
+export type { MdKitHttpHandlers, MdKitHttpRequest, MdKitHttpResponse, } from "./http";
+export type { CreateMdKitRestAdapterOptions } from "./rest";
+export type { MdKitRestoreDocumentVersionInput, MdKitTransportStore, } from "./store";

package/dist/transport/index.js

@@ -0,0 +1,2 @@
+export { createMdKitHttpHandlers } from "./http";
+export { createMdKitRestAdapter } from "./rest";

package/dist/transport/rest.d.ts

@@ -0,0 +1,6 @@
+import type { MdKitDocumentAdapter } from "../document/documentTypes";
+export type CreateMdKitRestAdapterOptions = {
+    baseUrl: string;
+    fetch?: typeof fetch;
+};
+export declare const createMdKitRestAdapter: ({ baseUrl, fetch: fetchImpl, }: CreateMdKitRestAdapterOptions) => MdKitDocumentAdapter;

package/dist/transport/rest.js

@@ -0,0 +1,34 @@
+const trimTrailingSlash = (value) => value.replace(/\/+$/, "");
+const documentQuery = (documentId) => `documentId=${encodeURIComponent(documentId)}`;
+const readJson = async (response) => {
+    const body = (await response.json());
+    if (!response.ok && response.status !== 409) {
+        throw new Error(`MdKit REST request failed: ${response.status}`);
+    }
+    return body;
+};
+export const createMdKitRestAdapter = ({ baseUrl, fetch: fetchImpl = fetch, }) => {
+    const url = trimTrailingSlash(baseUrl);
+    return {
+        readDocument: async (documentId) => readJson(await fetchImpl(`${url}/documents?${documentQuery(documentId)}`)),
+        writeDocument: async (input) => readJson(await fetchImpl(`${url}/documents?${documentQuery(input.documentId)}`, {
+            body: JSON.stringify(input),
+            headers: { "Content-Type": "application/json" },
+            method: "PUT",
+        })),
+        resyncDocument: async (documentId) => readJson(await fetchImpl(`${url}/documents/resync?${documentQuery(documentId)}`, {
+            method: "POST",
+        })),
+        listDocumentVersions: async (documentId) => {
+            const body = await readJson(await fetchImpl(`${url}/versions?${documentQuery(documentId)}`));
+            return body.versions;
+        },
+        readDocumentVersion: async ({ documentId, versionId }) => {
+            const response = await fetchImpl(`${url}/versions/${encodeURIComponent(versionId)}?${documentQuery(documentId)}`);
+            if (response.status === 404) {
+                return null;
+            }
+            return readJson(response);
+        },
+    };
+};

package/dist/transport/store.d.ts

@@ -0,0 +1,21 @@
+import type { MdKitDocumentSnapshot, MdKitDocumentVersionDetail, MdKitDocumentVersionSummary, MdKitDocumentWriteInput, MdKitDocumentWriteResult } from "../document/documentTypes";
+export type MdKitTransportStore = {
+    readDocument(documentId: string): Promise<MdKitDocumentSnapshot> | MdKitDocumentSnapshot;
+    writeDocument(input: MdKitDocumentWriteInput): Promise<MdKitDocumentWriteResult> | MdKitDocumentWriteResult;
+    resyncDocument?(documentId: string): Promise<MdKitDocumentSnapshot> | MdKitDocumentSnapshot;
+    listDocumentVersions?(documentId: string): Promise<MdKitDocumentVersionSummary[]> | MdKitDocumentVersionSummary[];
+    readDocumentVersion?(input: {
+        documentId: string;
+        versionId: string;
+    }): Promise<MdKitDocumentVersionDetail | null> | MdKitDocumentVersionDetail | null;
+    restoreDocumentVersion?(input: {
+        documentId: string;
+        versionId: string;
+    }): Promise<MdKitDocumentWriteResult> | MdKitDocumentWriteResult;
+    readCollaborationState?(documentName: string): Promise<Uint8Array | null> | Uint8Array | null;
+    writeCollaborationState?(documentName: string, state: Uint8Array): Promise<void> | void;
+};
+export type MdKitRestoreDocumentVersionInput = {
+    documentId: string;
+    versionId: string;
+};

package/dist/transport/store.js

@@ -0,0 +1 @@
+export {};

package/dist/transport/trpcClient.d.ts

@@ -0,0 +1,81 @@
+import { createTRPCProxyClient } from "@trpc/client";
+import type { MdKitDocumentAdapter } from "../document/documentTypes";
+import type { MdKitTrpcRouter } from "./trpcServer";
+export type CreateMdKitTrpcClientAdapterOptions = {
+    url: string;
+};
+export type CreateMdKitTrpcAdapterOptions = {
+    client: ReturnType<typeof createTRPCProxyClient<MdKitTrpcRouter>>;
+};
+export declare const createMdKitTrpcAdapter: ({ client, }: CreateMdKitTrpcAdapterOptions) => MdKitDocumentAdapter;
+export declare const createMdKitTrpcClient: ({ url, }: CreateMdKitTrpcClientAdapterOptions) => import("@trpc/client").TRPCClient<import("@trpc/server").TRPCBuiltRouter<{
+    ctx: object;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    listDocumentVersions: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            documentId: string;
+        };
+        output: {
+            versions: import("..").MdKitDocumentVersionSummary[];
+        };
+        meta: object;
+    }>;
+    readDocument: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            documentId: string;
+        };
+        output: import("..").MdKitDocumentSnapshot;
+        meta: object;
+    }>;
+    readDocumentVersion: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            documentId: string;
+            versionId: string;
+        };
+        output: import("..").MdKitDocumentVersionDetail | null;
+        meta: object;
+    }>;
+    resyncDocument: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            documentId: string;
+        };
+        output: import("..").MdKitDocumentSnapshot;
+        meta: object;
+    }>;
+    restoreDocumentVersion: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            documentId: string;
+            versionId: string;
+        };
+        output: {
+            version: import("..").MdKitDocumentVersionToken;
+            updatedAt?: string | null;
+        } | {
+            conflict: true;
+            version?: import("..").MdKitDocumentVersionToken;
+            updatedAt?: string | null;
+        };
+        meta: object;
+    }>;
+    writeDocument: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            baseVersion: string | number | null;
+            content: string;
+            documentId: string;
+            force?: boolean | undefined;
+        };
+        output: {
+            version: import("..").MdKitDocumentVersionToken;
+            updatedAt?: string | null;
+        } | {
+            conflict: true;
+            version?: import("..").MdKitDocumentVersionToken;
+            updatedAt?: string | null;
+        };
+        meta: object;
+    }>;
+}>>>;
+export declare const createMdKitTrpcClientAdapter: ({ url, }: CreateMdKitTrpcClientAdapterOptions) => MdKitDocumentAdapter;