@mp-lb/mdkit 0.0.1-main.2.1

package/dist/transport/trpcClient.js

@@ -0,0 +1,21 @@
+import { createTRPCProxyClient, httpBatchLink } from "@trpc/client";
+export const createMdKitTrpcAdapter = ({ client, }) => ({
+    listDocumentVersions: async (documentId) => {
+        const body = await client.listDocumentVersions.query({ documentId });
+        return body.versions;
+    },
+    readDocument: (documentId) => client.readDocument.query({ documentId }),
+    readDocumentVersion: (input) => client.readDocumentVersion.query(input),
+    resyncDocument: (documentId) => client.resyncDocument.mutate({ documentId }),
+    writeDocument: (input) => client.writeDocument.mutate(input),
+});
+export const createMdKitTrpcClient = ({ url, }) => createTRPCProxyClient({
+    links: [
+        httpBatchLink({
+            url,
+        }),
+    ],
+});
+export const createMdKitTrpcClientAdapter = ({ url, }) => createMdKitTrpcAdapter({
+    client: createMdKitTrpcClient({ url }),
+});

package/dist/transport/trpcServer.d.ts

@@ -0,0 +1,72 @@
+import type { MdKitTransportStore } from "./store";
+export declare const createMdKitTrpcRouter: (store: MdKitTransportStore) => 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 type MdKitTrpcRouter = ReturnType<typeof createMdKitTrpcRouter>;

package/dist/transport/trpcServer.js

@@ -0,0 +1,45 @@
+import { initTRPC } from "@trpc/server";
+import { z } from "zod";
+const t = initTRPC.create();
+const documentInput = z.object({
+    documentId: z.string(),
+});
+const versionInput = z.object({
+    documentId: z.string(),
+    versionId: z.string(),
+});
+const versionToken = z.union([z.string(), z.number()]).nullable();
+const writeInput = z.object({
+    baseVersion: versionToken,
+    content: z.string(),
+    documentId: z.string(),
+    force: z.boolean().optional(),
+});
+export const createMdKitTrpcRouter = (store) => t.router({
+    listDocumentVersions: t.procedure
+        .input(documentInput)
+        .query(async ({ input }) => ({
+        versions: await (store.listDocumentVersions?.(input.documentId) ?? []),
+    })),
+    readDocument: t.procedure
+        .input(documentInput)
+        .query(({ input }) => store.readDocument(input.documentId)),
+    readDocumentVersion: t.procedure.input(versionInput).query(({ input }) => store.readDocumentVersion?.({
+        documentId: input.documentId,
+        versionId: input.versionId,
+    }) ?? null),
+    resyncDocument: t.procedure
+        .input(documentInput)
+        .mutation(({ input }) => (store.resyncDocument ?? store.readDocument)(input.documentId)),
+    restoreDocumentVersion: t.procedure
+        .input(versionInput)
+        .mutation(({ input }) => {
+        if (!store.restoreDocumentVersion) {
+            throw new Error("Version restore is not supported");
+        }
+        return store.restoreDocumentVersion(input);
+    }),
+    writeDocument: t.procedure
+        .input(writeInput)
+        .mutation(({ input }) => store.writeDocument(input)),
+});

package/dist/trpc/client.d.ts

@@ -0,0 +1,3 @@
+export { createMdKitTrpcAdapter, createMdKitTrpcClient, createMdKitTrpcClientAdapter, } from "../transport/trpcClient";
+export type { CreateMdKitTrpcAdapterOptions, CreateMdKitTrpcClientAdapterOptions, } from "../transport/trpcClient";
+export type { MdKitTrpcRouter } from "../transport/trpcServer";

package/dist/trpc/client.js

@@ -0,0 +1 @@
+export { createMdKitTrpcAdapter, createMdKitTrpcClient, createMdKitTrpcClientAdapter, } from "../transport/trpcClient";

package/dist/trpc/server.d.ts

@@ -0,0 +1,3 @@
+export { createMdKitTrpcRouter } from "../transport/trpcServer";
+export type { MdKitTrpcRouter } from "../transport/trpcServer";
+export type { MdKitRestoreDocumentVersionInput, MdKitTransportStore, } from "../transport/store";

package/dist/trpc/server.js

@@ -0,0 +1 @@
+export { createMdKitTrpcRouter } from "../transport/trpcServer";

package/dist/trpc.d.ts

@@ -0,0 +1,3 @@
+export { createMdKitTrpcAdapter, createMdKitTrpcClient, createMdKitTrpcClientAdapter, } from "./transport/trpcClient";
+export type { CreateMdKitTrpcAdapterOptions, CreateMdKitTrpcClientAdapterOptions, } from "./transport/trpcClient";
+export type { MdKitTrpcRouter } from "./transport/trpcServer";

package/dist/trpc.js

@@ -0,0 +1 @@
+export { createMdKitTrpcAdapter, createMdKitTrpcClient, createMdKitTrpcClientAdapter, } from "./transport/trpcClient";

package/dist/ui/joinClassNames.d.ts

@@ -0,0 +1 @@
+export declare const joinClassNames: (...values: Array<string | false | null | undefined>) => string;

package/dist/ui/joinClassNames.js

@@ -0,0 +1 @@
+export const joinClassNames = (...values) => values.filter(Boolean).join(" ");

package/dist/versioning/VersionHistoryPanel.d.ts

@@ -0,0 +1,9 @@
+import type { MdKitDocumentVersionDetail } from "../document/documentTypes";
+import type { MdKitDocumentVersionsController } from "./useMdKitDocumentVersions";
+export type VersionHistoryPanelProps = {
+    className?: string;
+    controller: MdKitDocumentVersionsController;
+    onRestoreVersion?: (version: MdKitDocumentVersionDetail) => Promise<void> | void;
+    title?: string;
+};
+export declare const VersionHistoryPanel: ({ className, controller, onRestoreVersion, title, }: VersionHistoryPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/versioning/VersionHistoryPanel.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from "react";
+import { joinClassNames } from "../ui/joinClassNames";
+const getVersionLabel = (version) => {
+    if (version.label) {
+        return version.label;
+    }
+    if (version.version != null) {
+        return `Version ${String(version.version)}`;
+    }
+    return version.id.slice(0, 8);
+};
+export const VersionHistoryPanel = ({ className, controller, onRestoreVersion, title = "Version history", }) => {
+    const [isRestoring, setIsRestoring] = useState(false);
+    const restoreSelectedVersion = async () => {
+        if (!controller.selectedVersion || !onRestoreVersion) {
+            return;
+        }
+        setIsRestoring(true);
+        try {
+            await onRestoreVersion(controller.selectedVersion);
+        }
+        finally {
+            setIsRestoring(false);
+        }
+    };
+    return (_jsxs("aside", { className: joinClassNames("mdkit-version-history-panel", className), children: [_jsx("div", { className: "mdkit-version-history-header", children: _jsxs("div", { children: [_jsx("h2", { className: "mdkit-version-history-title", children: title }), _jsx("p", { className: "mdkit-version-history-subtitle", children: "Browse saved revisions and restore one when you need it." })] }) }), !controller.hasVersioning ? (_jsx("div", { className: "mdkit-version-history-empty", children: "This adapter does not expose version history." })) : null, controller.error ? (_jsx("div", { className: "mdkit-version-history-error", children: controller.error })) : null, controller.hasVersioning ? (_jsxs("div", { className: "mdkit-version-history-layout", children: [_jsx("div", { className: "mdkit-version-history-list", role: "list", children: controller.versions.length === 0 ? (_jsx("div", { className: "mdkit-version-history-empty", children: "No revisions have been recorded for this document yet." })) : (controller.versions.map((version) => (_jsxs("button", { type: "button", className: joinClassNames("mdkit-version-history-item", controller.selectedVersionId === version.id &&
+                                "mdkit-version-history-item-active"), onClick: () => void controller.openVersion(version.id), children: [_jsx("span", { className: "mdkit-version-history-item-title", children: getVersionLabel(version) }), _jsx("span", { className: "mdkit-version-history-item-meta", children: new Date(version.createdAt).toLocaleString() })] }, version.id)))) }), _jsx("div", { className: "mdkit-version-history-preview", children: controller.selectedVersion ? (_jsxs(_Fragment, { children: [_jsxs("div", { className: "mdkit-version-history-preview-header", children: [_jsxs("div", { children: [_jsx("h3", { className: "mdkit-version-history-preview-title", children: getVersionLabel(controller.selectedVersion) }), _jsx("p", { className: "mdkit-version-history-item-meta", children: new Date(controller.selectedVersion.createdAt).toLocaleString() })] }), onRestoreVersion ? (_jsx("button", { type: "button", className: "mdkit-panel-primary-action", disabled: isRestoring, onClick: () => void restoreSelectedVersion(), children: isRestoring ? "Restoring..." : "Restore" })) : null] }), _jsx("pre", { className: "mdkit-version-history-code", children: controller.selectedVersion.content })] })) : (_jsx("div", { className: "mdkit-version-history-empty", children: "Select a saved revision to preview it here." })) })] })) : null, controller.isLoading ? (_jsx("div", { className: "mdkit-version-history-meta", children: "Loading version data..." })) : null] }));
+};

package/dist/versioning/useMdKitDocumentVersions.d.ts

@@ -0,0 +1,16 @@
+import type { MdKitDocumentAdapter, MdKitDocumentVersionDetail, MdKitDocumentVersionSummary } from "../document/documentTypes";
+export type UseMdKitDocumentVersionsOptions = {
+    adapter: Pick<MdKitDocumentAdapter, "listDocumentVersions" | "readDocumentVersion">;
+    documentId: string | null;
+};
+export type MdKitDocumentVersionsController = {
+    error: string | null;
+    hasVersioning: boolean;
+    isLoading: boolean;
+    openVersion: (versionId: string) => Promise<void>;
+    refresh: () => Promise<void>;
+    selectedVersion: MdKitDocumentVersionDetail | null;
+    selectedVersionId: string | null;
+    versions: MdKitDocumentVersionSummary[];
+};
+export declare const useMdKitDocumentVersions: (options: UseMdKitDocumentVersionsOptions) => MdKitDocumentVersionsController;

package/dist/versioning/useMdKitDocumentVersions.js

@@ -0,0 +1,88 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+export const useMdKitDocumentVersions = (options) => {
+    const { adapter, documentId } = options;
+    const [versions, setVersions] = useState([]);
+    const [selectedVersionId, setSelectedVersionId] = useState(null);
+    const [selectedVersion, setSelectedVersion] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const hasVersioning = !!adapter.listDocumentVersions && !!adapter.readDocumentVersion;
+    const refresh = useCallback(async () => {
+        if (!documentId || !adapter.listDocumentVersions) {
+            setVersions([]);
+            setSelectedVersionId(null);
+            setSelectedVersion(null);
+            setError(null);
+            return;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const nextVersions = await adapter.listDocumentVersions(documentId);
+            setVersions(nextVersions);
+            setSelectedVersionId((currentSelectedVersionId) => {
+                if (!nextVersions.some((version) => version.id === currentSelectedVersionId)) {
+                    setSelectedVersion(null);
+                    return null;
+                }
+                return currentSelectedVersionId;
+            });
+        }
+        catch (err) {
+            setError(`Failed to load versions: ${String(err)}`);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [adapter, documentId]);
+    const openVersion = useCallback(async (versionId) => {
+        if (!documentId || !adapter.readDocumentVersion) {
+            return;
+        }
+        setSelectedVersionId(versionId);
+        setIsLoading(true);
+        setError(null);
+        try {
+            const nextVersion = await adapter.readDocumentVersion({
+                documentId,
+                versionId,
+            });
+            if (!nextVersion) {
+                setSelectedVersion(null);
+                setError("That version is no longer available.");
+                return;
+            }
+            setSelectedVersion(nextVersion);
+        }
+        catch (err) {
+            setError(`Failed to load version: ${String(err)}`);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [adapter, documentId]);
+    useEffect(() => {
+        setSelectedVersionId(null);
+        setSelectedVersion(null);
+        void refresh();
+    }, [documentId, refresh]);
+    return useMemo(() => ({
+        error,
+        hasVersioning,
+        isLoading,
+        openVersion,
+        refresh,
+        selectedVersion,
+        selectedVersionId,
+        versions,
+    }), [
+        error,
+        hasVersioning,
+        isLoading,
+        openVersion,
+        refresh,
+        selectedVersion,
+        selectedVersionId,
+        versions,
+    ]);
+};

package/dist/versioning/useMdKitDocumentVersions.test.d.ts

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

package/dist/versioning/useMdKitDocumentVersions.test.js

@@ -0,0 +1,41 @@
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { useMdKitDocumentVersions } from "./useMdKitDocumentVersions";
+describe("useMdKitDocumentVersions", () => {
+    it("keeps the selected version preview open after loading it", async () => {
+        const adapter = {
+            listDocumentVersions: vi.fn(async () => [
+                {
+                    createdAt: "2026-01-01T00:00:00.000Z",
+                    id: "1",
+                    label: "Version 1",
+                    version: 1,
+                },
+            ]),
+            readDocumentVersion: vi.fn(async () => ({
+                content: "Version one content",
+                createdAt: "2026-01-01T00:00:00.000Z",
+                id: "1",
+                label: "Version 1",
+                updatedAt: "2026-01-01T00:00:00.000Z",
+                version: 1,
+            })),
+        };
+        const { result } = renderHook(() => useMdKitDocumentVersions({
+            adapter,
+            documentId: "docs/example.md",
+        }));
+        await waitFor(() => {
+            expect(result.current.versions).toHaveLength(1);
+        });
+        await act(async () => {
+            await result.current.openVersion("1");
+        });
+        await waitFor(() => {
+            expect(result.current.selectedVersionId).toBe("1");
+            expect(result.current.selectedVersion?.content).toBe("Version one content");
+            expect(result.current.isLoading).toBe(false);
+        });
+        expect(adapter.listDocumentVersions).toHaveBeenCalledTimes(1);
+    });
+});

package/docs/.vitepress/config.ts

@@ -0,0 +1,34 @@
+import { defineConfig } from "vitepress";
+
+export default defineConfig({
+  title: "Markdown Editor Kit",
+  description: "Docs for the mdkit markdown editor package",
+  cleanUrls: true,
+  themeConfig: {
+    nav: [
+      { text: "Quick Start", link: "/" },
+      { text: "Styling", link: "/styling" },
+      { text: "Shadcn", link: "/shadcn" },
+      { text: "API", link: "/api" },
+      { text: "Architecture", link: "/architecture" },
+    ],
+    sidebar: [
+      {
+        text: "Guide",
+        items: [
+          { text: "Quick Start", link: "/" },
+          { text: "Styling", link: "/styling" },
+          { text: "Shadcn Plugin", link: "/shadcn" },
+          { text: "API Reference", link: "/api" },
+          { text: "Architecture", link: "/architecture" },
+        ],
+      },
+    ],
+    socialLinks: [
+      {
+        icon: "github",
+        link: "https://github.com/mp-lb/mdkit",
+      },
+    ],
+  },
+});

package/docs/.vitepress/dist/404.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en-US" dir="ltr">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <title>404 | Markdown Editor Kit</title>
+    <meta name="description" content="Not Found">
+    <meta name="generator" content="VitePress v1.6.4">
+    <link rel="preload stylesheet" href="/assets/style.BtrGaL3i.css" as="style">
+    <link rel="preload stylesheet" href="/vp-icons.css" as="style">
+    
+    <script type="module" src="/assets/app.BQvrHyG0.js"></script>
+    <link rel="preload" href="/assets/inter-roman-latin.Di8DUHzh.woff2" as="font" type="font/woff2" crossorigin="">
+    <script id="check-dark-mode">(()=>{const e=localStorage.getItem("vitepress-theme-appearance")||"auto",a=window.matchMedia("(prefers-color-scheme: dark)").matches;(!e||e==="auto"?a:e==="dark")&&document.documentElement.classList.add("dark")})();</script>
+    <script id="check-mac-os">document.documentElement.classList.toggle("mac",/Mac|iPhone|iPod|iPad/i.test(navigator.platform));</script>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script>window.__VP_HASH_MAP__=JSON.parse("{\"api.md\":\"asncK3PQ\",\"architecture.md\":\"BHQLarmZ\",\"index.md\":\"CITl-897\",\"shadcn.md\":\"C3idOo2N\",\"styling.md\":\"B2C6kVFa\"}");window.__VP_SITE_DATA__=JSON.parse("{\"lang\":\"en-US\",\"dir\":\"ltr\",\"title\":\"Markdown Editor Kit\",\"description\":\"Docs for the mdkit markdown editor package\",\"base\":\"/\",\"head\":[],\"router\":{\"prefetchLinks\":true},\"appearance\":true,\"themeConfig\":{\"nav\":[{\"text\":\"Quick Start\",\"link\":\"/\"},{\"text\":\"Styling\",\"link\":\"/styling\"},{\"text\":\"Shadcn\",\"link\":\"/shadcn\"},{\"text\":\"API\",\"link\":\"/api\"},{\"text\":\"Architecture\",\"link\":\"/architecture\"}],\"sidebar\":[{\"text\":\"Guide\",\"items\":[{\"text\":\"Quick Start\",\"link\":\"/\"},{\"text\":\"Styling\",\"link\":\"/styling\"},{\"text\":\"Shadcn Plugin\",\"link\":\"/shadcn\"},{\"text\":\"API Reference\",\"link\":\"/api\"},{\"text\":\"Architecture\",\"link\":\"/architecture\"}]}],\"socialLinks\":[{\"icon\":\"github\",\"link\":\"https://github.com/mp-lb/mdkit\"}]},\"locales\":{},\"scrollOffset\":134,\"cleanUrls\":true}");</script>
+    
+  </body>
+</html>