@mp-lb/mdkit 0.0.1-main.2.1

package/dist/document/useMdKitDocument.d.ts

@@ -0,0 +1,33 @@
+import type { MdKitDocumentAdapter, MdKitDocumentVersionToken } from "./documentTypes";
+export type UseMdKitDocumentOptions = {
+    adapter: Pick<MdKitDocumentAdapter, "readDocument" | "writeDocument" | "resyncDocument">;
+    debounceMs?: number;
+    documentId: string | null;
+    pollMs?: number;
+};
+export type MdKitDocumentConflictDetails = {
+    baseContent: string;
+    localContent: string;
+    remoteContent: string | null;
+    remoteUpdatedAt: string | null;
+    remoteVersion: MdKitDocumentVersionToken;
+};
+export type MdKitDocumentController = {
+    conflict: boolean;
+    conflictDetails: MdKitDocumentConflictDetails | null;
+    error: string | null;
+    isDirty: boolean;
+    isFocused: boolean;
+    isLoading: boolean;
+    revision: number;
+    saveNow: () => Promise<boolean>;
+    saveStatus: "idle" | "pending" | "saving" | "saved";
+    forceSave: () => Promise<boolean>;
+    resync: () => Promise<void>;
+    setContent: (next: string) => void;
+    setFocused: (focused: boolean) => void;
+    updatedAt: string | null;
+    value: string;
+    version: MdKitDocumentVersionToken;
+};
+export declare const useMdKitDocument: (options: UseMdKitDocumentOptions) => MdKitDocumentController;

package/dist/document/useMdKitDocument.js

@@ -0,0 +1,396 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+const emptyDocumentState = {
+    content: "",
+    updatedAt: null,
+    version: null,
+};
+export const useMdKitDocument = (options) => {
+    const { adapter, debounceMs = 350, documentId, pollMs = 2000 } = options;
+    const [local, setLocal] = useState("");
+    const [base, setBase] = useState("");
+    const [version, setVersion] = useState(null);
+    const [updatedAt, setUpdatedAt] = useState(null);
+    const [revision, setRevision] = useState(0);
+    const [isLoading, setIsLoading] = useState(!!documentId);
+    const [error, setError] = useState(null);
+    const [conflict, setConflict] = useState(false);
+    const [conflictDetails, setConflictDetails] = useState(null);
+    const [isFocused, setIsFocused] = useState(false);
+    const [saveStatus, setSaveStatus] = useState("idle");
+    const debounceRef = useRef(null);
+    const isSavingRef = useRef(false);
+    const queuedSaveRef = useRef(false);
+    const localRef = useRef(local);
+    const baseRef = useRef(base);
+    const versionRef = useRef(version);
+    const updatedAtRef = useRef(updatedAt);
+    const conflictRef = useRef(conflict);
+    const focusedRef = useRef(isFocused);
+    useEffect(() => {
+        localRef.current = local;
+    }, [local]);
+    useEffect(() => {
+        baseRef.current = base;
+    }, [base]);
+    useEffect(() => {
+        versionRef.current = version;
+    }, [version]);
+    useEffect(() => {
+        updatedAtRef.current = updatedAt;
+    }, [updatedAt]);
+    useEffect(() => {
+        conflictRef.current = conflict;
+    }, [conflict]);
+    useEffect(() => {
+        focusedRef.current = isFocused;
+    }, [isFocused]);
+    const isDirty = local !== base;
+    const setFocused = useCallback((focused) => {
+        focusedRef.current = focused;
+        setIsFocused(focused);
+    }, []);
+    const applyRemoteSnapshot = useCallback((next, bumpRevision) => {
+        localRef.current = next.content;
+        baseRef.current = next.content;
+        versionRef.current = next.version;
+        updatedAtRef.current = next.updatedAt ?? null;
+        conflictRef.current = false;
+        setLocal(next.content);
+        setBase(next.content);
+        setVersion(next.version);
+        setUpdatedAt(next.updatedAt ?? null);
+        setConflict(false);
+        setConflictDetails(null);
+        setError(null);
+        if (bumpRevision) {
+            setRevision((current) => current + 1);
+        }
+    }, []);
+    const reset = useCallback(() => {
+        localRef.current = emptyDocumentState.content;
+        baseRef.current = emptyDocumentState.content;
+        versionRef.current = emptyDocumentState.version;
+        updatedAtRef.current = emptyDocumentState.updatedAt;
+        conflictRef.current = false;
+        focusedRef.current = false;
+        setLocal(emptyDocumentState.content);
+        setBase(emptyDocumentState.content);
+        setVersion(emptyDocumentState.version);
+        setUpdatedAt(emptyDocumentState.updatedAt);
+        setRevision(0);
+        setIsLoading(false);
+        setError(null);
+        setConflict(false);
+        setConflictDetails(null);
+        setSaveStatus("idle");
+        setFocused(false);
+        if (debounceRef.current) {
+            clearTimeout(debounceRef.current);
+            debounceRef.current = null;
+        }
+        isSavingRef.current = false;
+        queuedSaveRef.current = false;
+    }, [setFocused]);
+    useEffect(() => {
+        if (!documentId) {
+            reset();
+            return;
+        }
+        let cancelled = false;
+        setIsLoading(true);
+        setError(null);
+        setConflict(false);
+        setConflictDetails(null);
+        setSaveStatus("idle");
+        queuedSaveRef.current = false;
+        if (debounceRef.current) {
+            clearTimeout(debounceRef.current);
+            debounceRef.current = null;
+        }
+        adapter
+            .readDocument(documentId)
+            .then((result) => {
+            if (cancelled) {
+                return;
+            }
+            applyRemoteSnapshot(result, true);
+            setIsLoading(false);
+        })
+            .catch((err) => {
+            if (cancelled) {
+                return;
+            }
+            setError(String(err));
+            setIsLoading(false);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [adapter, applyRemoteSnapshot, documentId, reset]);
+    useEffect(() => {
+        if (!documentId || pollMs <= 0) {
+            return;
+        }
+        let cancelled = false;
+        const poll = async () => {
+            if (cancelled || isSavingRef.current) {
+                return;
+            }
+            try {
+                const remote = await adapter.readDocument(documentId);
+                if (cancelled) {
+                    return;
+                }
+                const remoteContent = remote.content;
+                const remoteVersion = remote.version;
+                const localNow = localRef.current;
+                const baseNow = baseRef.current;
+                const versionNow = versionRef.current;
+                const dirtyNow = localNow !== baseNow;
+                if (dirtyNow) {
+                    if (remoteContent !== baseNow || remoteVersion !== versionNow) {
+                        const nextConflictDetails = {
+                            baseContent: baseNow,
+                            localContent: localNow,
+                            remoteContent,
+                            remoteUpdatedAt: remote.updatedAt ?? null,
+                            remoteVersion,
+                        };
+                        conflictRef.current = true;
+                        versionRef.current = remoteVersion;
+                        updatedAtRef.current = remote.updatedAt ?? updatedAtRef.current;
+                        setConflict(true);
+                        setConflictDetails(nextConflictDetails);
+                        setError("Remote document changed while you have unsaved edits.");
+                        setVersion(remoteVersion);
+                        setUpdatedAt(remote.updatedAt ?? updatedAtRef.current);
+                    }
+                    return;
+                }
+                if (focusedRef.current) {
+                    return;
+                }
+                if (remoteContent !== baseNow ||
+                    remoteVersion !== versionNow ||
+                    conflictRef.current) {
+                    applyRemoteSnapshot(remote, true);
+                }
+            }
+            catch {
+                // Explicit load/save actions surface errors for callers.
+            }
+        };
+        const interval = setInterval(() => {
+            void poll();
+        }, pollMs);
+        return () => {
+            cancelled = true;
+            clearInterval(interval);
+        };
+    }, [adapter, applyRemoteSnapshot, documentId, pollMs]);
+    const commitSave = useCallback(async (input) => {
+        if (!documentId) {
+            return false;
+        }
+        const contentToSave = localRef.current;
+        const currentBase = baseRef.current;
+        if (contentToSave === currentBase) {
+            setSaveStatus("saved");
+            return true;
+        }
+        const result = await adapter.writeDocument({
+            baseVersion: input.baseVersion,
+            content: contentToSave,
+            documentId,
+            ...(input.force ? { force: true } : {}),
+        });
+        if ("conflict" in result) {
+            let remoteContent = null;
+            let remoteVersion = result.version ?? versionRef.current;
+            let remoteUpdatedAt = result.updatedAt ?? updatedAtRef.current;
+            try {
+                const remote = await adapter.readDocument(documentId);
+                remoteContent = remote.content;
+                remoteVersion = remote.version;
+                remoteUpdatedAt = remote.updatedAt ?? null;
+            }
+            catch {
+                // Conflict resolution can still proceed by keeping remote via resync
+                // or overwriting remote even if the preview fetch fails.
+            }
+            const nextConflictDetails = {
+                baseContent: currentBase,
+                localContent: contentToSave,
+                remoteContent,
+                remoteUpdatedAt,
+                remoteVersion,
+            };
+            conflictRef.current = true;
+            setConflict(true);
+            setConflictDetails(nextConflictDetails);
+            setSaveStatus("idle");
+            setError("Remote document changed while you have unsaved edits.");
+            if (remoteVersion !== undefined) {
+                versionRef.current = remoteVersion;
+                setVersion(remoteVersion);
+            }
+            if (remoteUpdatedAt !== undefined) {
+                updatedAtRef.current = remoteUpdatedAt ?? null;
+                setUpdatedAt(remoteUpdatedAt ?? null);
+            }
+            return false;
+        }
+        baseRef.current = contentToSave;
+        versionRef.current = result.version;
+        updatedAtRef.current = result.updatedAt ?? updatedAtRef.current;
+        conflictRef.current = false;
+        setBase(contentToSave);
+        setVersion(result.version);
+        setUpdatedAt(result.updatedAt ?? updatedAtRef.current);
+        setConflict(false);
+        setConflictDetails(null);
+        setSaveStatus("saved");
+        setError(null);
+        return true;
+    }, [adapter, documentId]);
+    const scheduleSave = useCallback(() => {
+        if (!documentId || conflictRef.current) {
+            return;
+        }
+        if (localRef.current === baseRef.current) {
+            setSaveStatus("saved");
+            return;
+        }
+        setSaveStatus("pending");
+        if (debounceRef.current) {
+            clearTimeout(debounceRef.current);
+        }
+        debounceRef.current = setTimeout(() => {
+            if (isSavingRef.current || conflictRef.current) {
+                queuedSaveRef.current = true;
+                debounceRef.current = null;
+                return;
+            }
+            isSavingRef.current = true;
+            queuedSaveRef.current = false;
+            setSaveStatus("saving");
+            commitSave({ baseVersion: versionRef.current })
+                .catch((err) => {
+                setError(`Save failed: ${String(err)}`);
+                setSaveStatus("idle");
+                return false;
+            })
+                .finally(() => {
+                isSavingRef.current = false;
+                debounceRef.current = null;
+            });
+        }, debounceMs);
+    }, [commitSave, debounceMs, documentId]);
+    const setContent = useCallback((next) => {
+        setLocal(next);
+        localRef.current = next;
+        scheduleSave();
+    }, [scheduleSave]);
+    useEffect(() => {
+        if (saveStatus !== "saved" ||
+            !queuedSaveRef.current ||
+            isSavingRef.current ||
+            conflictRef.current ||
+            localRef.current === baseRef.current) {
+            return;
+        }
+        queuedSaveRef.current = false;
+        scheduleSave();
+    }, [saveStatus, scheduleSave]);
+    const resync = useCallback(async () => {
+        if (!documentId) {
+            return;
+        }
+        try {
+            const readRemote = adapter.resyncDocument ?? adapter.readDocument;
+            const result = await readRemote(documentId);
+            applyRemoteSnapshot(result, true);
+        }
+        catch (err) {
+            setError(`Failed to resync: ${String(err)}`);
+        }
+    }, [adapter, applyRemoteSnapshot, documentId]);
+    const forceSave = useCallback(async () => {
+        if (!documentId || isSavingRef.current) {
+            return false;
+        }
+        isSavingRef.current = true;
+        setSaveStatus("saving");
+        try {
+            return await commitSave({ baseVersion: null, force: true });
+        }
+        catch (err) {
+            setError(`Force save failed: ${String(err)}`);
+            setSaveStatus("idle");
+            return false;
+        }
+        finally {
+            isSavingRef.current = false;
+        }
+    }, [commitSave, documentId]);
+    const saveNow = useCallback(async () => {
+        if (!documentId) {
+            return false;
+        }
+        if (debounceRef.current) {
+            clearTimeout(debounceRef.current);
+            debounceRef.current = null;
+        }
+        if (isSavingRef.current || conflictRef.current) {
+            return false;
+        }
+        isSavingRef.current = true;
+        setSaveStatus("saving");
+        try {
+            return await commitSave({ baseVersion: versionRef.current });
+        }
+        catch (err) {
+            setError(`Save failed: ${String(err)}`);
+            setSaveStatus("idle");
+            return false;
+        }
+        finally {
+            isSavingRef.current = false;
+        }
+    }, [commitSave, documentId]);
+    return useMemo(() => ({
+        conflict,
+        conflictDetails,
+        error,
+        forceSave,
+        isDirty,
+        isFocused,
+        isLoading,
+        resync,
+        revision,
+        saveNow,
+        saveStatus,
+        setContent,
+        setFocused,
+        updatedAt,
+        value: local,
+        version,
+    }), [
+        conflict,
+        conflictDetails,
+        error,
+        forceSave,
+        isDirty,
+        isFocused,
+        isLoading,
+        local,
+        resync,
+        revision,
+        saveNow,
+        saveStatus,
+        setContent,
+        setFocused,
+        updatedAt,
+        version,
+    ]);
+};

package/dist/document/useMdKitDocument.test.d.ts

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

package/dist/document/useMdKitDocument.test.js

@@ -0,0 +1,151 @@
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { useMdKitDocument } from "./useMdKitDocument";
+describe("useMdKitDocument", () => {
+    afterEach(() => {
+        vi.clearAllTimers();
+        vi.useRealTimers();
+    });
+    it("marks autosave as pending during the debounce window", async () => {
+        const adapter = {
+            readDocument: vi.fn(async () => ({
+                content: "Initial content",
+                updatedAt: "2026-01-01T00:00:00.000Z",
+                version: 1,
+            })),
+            resyncDocument: vi.fn(async () => ({
+                content: "Initial content",
+                updatedAt: "2026-01-01T00:00:00.000Z",
+                version: 1,
+            })),
+            writeDocument: vi.fn(async () => ({
+                updatedAt: "2026-01-01T00:00:01.000Z",
+                version: 2,
+            })),
+        };
+        const { result } = renderHook(() => useMdKitDocument({
+            adapter,
+            debounceMs: 250,
+            documentId: "docs/example.md",
+            pollMs: 0,
+        }));
+        await waitFor(() => {
+            expect(result.current.value).toBe("Initial content");
+        });
+        vi.useFakeTimers();
+        act(() => {
+            result.current.setContent("Changed content");
+        });
+        expect(result.current.isDirty).toBe(true);
+        expect(result.current.saveStatus).toBe("pending");
+        expect(adapter.writeDocument).not.toHaveBeenCalled();
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(250);
+        });
+        expect(result.current.saveStatus).toBe("saved");
+        expect(result.current.isDirty).toBe(false);
+        expect(adapter.writeDocument).toHaveBeenCalledWith({
+            baseVersion: 1,
+            content: "Changed content",
+            documentId: "docs/example.md",
+        });
+    });
+    it("exposes remote, local, and base content when a save conflicts", async () => {
+        const adapter = {
+            readDocument: vi
+                .fn()
+                .mockResolvedValueOnce({
+                content: "Base content",
+                updatedAt: "2026-01-01T00:00:00.000Z",
+                version: 1,
+            })
+                .mockResolvedValueOnce({
+                content: "Remote content",
+                updatedAt: "2026-01-01T00:00:02.000Z",
+                version: 2,
+            }),
+            resyncDocument: vi.fn(),
+            writeDocument: vi.fn(async () => ({
+                conflict: true,
+                updatedAt: "2026-01-01T00:00:02.000Z",
+                version: 2,
+            })),
+        };
+        const { result } = renderHook(() => useMdKitDocument({
+            adapter,
+            documentId: "docs/example.md",
+            pollMs: 0,
+        }));
+        await waitFor(() => {
+            expect(result.current.value).toBe("Base content");
+        });
+        act(() => {
+            result.current.setContent("Local content");
+        });
+        await act(async () => {
+            await result.current.saveNow();
+        });
+        expect(result.current.conflict).toBe(true);
+        expect(result.current.conflictDetails).toEqual({
+            baseContent: "Base content",
+            localContent: "Local content",
+            remoteContent: "Remote content",
+            remoteUpdatedAt: "2026-01-01T00:00:02.000Z",
+            remoteVersion: 2,
+        });
+    });
+    it("force saves local content after a conflict", async () => {
+        const adapter = {
+            readDocument: vi
+                .fn()
+                .mockResolvedValueOnce({
+                content: "Base content",
+                updatedAt: "2026-01-01T00:00:00.000Z",
+                version: 1,
+            })
+                .mockResolvedValueOnce({
+                content: "Remote content",
+                updatedAt: "2026-01-01T00:00:02.000Z",
+                version: 2,
+            }),
+            resyncDocument: vi.fn(),
+            writeDocument: vi
+                .fn()
+                .mockResolvedValueOnce({
+                conflict: true,
+                updatedAt: "2026-01-01T00:00:02.000Z",
+                version: 2,
+            })
+                .mockResolvedValueOnce({
+                updatedAt: "2026-01-01T00:00:03.000Z",
+                version: 3,
+            }),
+        };
+        const { result } = renderHook(() => useMdKitDocument({
+            adapter,
+            documentId: "docs/example.md",
+            pollMs: 0,
+        }));
+        await waitFor(() => {
+            expect(result.current.value).toBe("Base content");
+        });
+        act(() => {
+            result.current.setContent("Local content");
+        });
+        await act(async () => {
+            await result.current.saveNow();
+        });
+        expect(result.current.conflict).toBe(true);
+        await act(async () => {
+            await result.current.forceSave();
+        });
+        expect(result.current.conflict).toBe(false);
+        expect(result.current.isDirty).toBe(false);
+        expect(adapter.writeDocument).toHaveBeenLastCalledWith({
+            baseVersion: null,
+            content: "Local content",
+            documentId: "docs/example.md",
+            force: true,
+        });
+    });
+});

package/dist/fastify.d.ts

@@ -0,0 +1,3 @@
+export { registerMdKitFastify } from "./transport/fastify";
+export type { RegisterMdKitFastifyOptions } from "./transport/fastify";
+export type { MdKitRestoreDocumentVersionInput, MdKitTransportStore, } from "./transport/store";

package/dist/fastify.js

@@ -0,0 +1 @@
+export { registerMdKitFastify } from "./transport/fastify";

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { useMdKitCollaboration } from "./collaboration/useMdKitCollaboration";
+export { createMdKitDocumentRecord, detectMdKitDocumentConflict, normalizeMdKitVersionToken, restoreMdKitDocumentVersion, writeMdKitDocumentRecord, } from "./core/documentEngine";
+export { useMdKitDocument } from "./document/useMdKitDocument";
+export { MdKitConflictPanel } from "./document/MdKitConflictPanel";
+export { MdKitDocumentToolbar } from "./document/MdKitDocumentToolbar";
+export { MdKitEditor } from "./markdown/MdKitEditor";
+export { MdKitThemeEditor } from "./theme/MdKitThemeEditor";
+export { createMdKitRestAdapter } from "./transport/rest";
+export { createMdKitEditorThemeStyle, darkMdKitEditorTheme, defaultMdKitEditorTheme, } from "./theme/editorTheme";
+export { VersionHistoryPanel } from "./versioning/VersionHistoryPanel";
+export { useMdKitDocumentVersions } from "./versioning/useMdKitDocumentVersions";
+export type { CreateMdKitDocumentRecordInput, MdKitDocumentRecord, RestoreMdKitDocumentVersionInput, RestoreMdKitDocumentVersionResult, WriteMdKitDocumentRecordInput, WriteMdKitDocumentRecordResult, } from "./core/documentEngine";
+export type { MdKitCollaborationParticipant, MdKitCollaborationSession, MdKitCollaborationStatus, MdKitDocumentAdapter, MdKitDocumentSnapshot, MdKitDocumentVersionDetail, MdKitDocumentVersionSummary, MdKitDocumentVersionToken, MdKitDocumentWriteInput, MdKitDocumentWriteResult, } from "./document/documentTypes";
+export type { MdKitDocumentConflictDetails, MdKitDocumentController, } from "./document/useMdKitDocument";
+export type { MdKitConflictPanelProps } from "./document/MdKitConflictPanel";
+export type { MdKitDocumentToolbarProps } from "./document/MdKitDocumentToolbar";
+export type { MdKitEditorProps } from "./markdown/MdKitEditor";
+export type { MdKitEditorDebugEvent } from "./markdown/editorDebug";
+export type { MdKitThemeEditorProps } from "./theme/MdKitThemeEditor";
+export type { CreateMdKitRestAdapterOptions } from "./transport/rest";
+export type { MdKitEditorTheme, MdKitEditorThemeStyle, } from "./theme/editorTheme";
+export type { MdKitDocumentVersionsController, UseMdKitDocumentVersionsOptions, } from "./versioning/useMdKitDocumentVersions";
+export type { VersionHistoryPanelProps } from "./versioning/VersionHistoryPanel";

package/dist/index.js

@@ -0,0 +1,11 @@
+export { useMdKitCollaboration } from "./collaboration/useMdKitCollaboration";
+export { createMdKitDocumentRecord, detectMdKitDocumentConflict, normalizeMdKitVersionToken, restoreMdKitDocumentVersion, writeMdKitDocumentRecord, } from "./core/documentEngine";
+export { useMdKitDocument } from "./document/useMdKitDocument";
+export { MdKitConflictPanel } from "./document/MdKitConflictPanel";
+export { MdKitDocumentToolbar } from "./document/MdKitDocumentToolbar";
+export { MdKitEditor } from "./markdown/MdKitEditor";
+export { MdKitThemeEditor } from "./theme/MdKitThemeEditor";
+export { createMdKitRestAdapter } from "./transport/rest";
+export { createMdKitEditorThemeStyle, darkMdKitEditorTheme, defaultMdKitEditorTheme, } from "./theme/editorTheme";
+export { VersionHistoryPanel } from "./versioning/VersionHistoryPanel";
+export { useMdKitDocumentVersions } from "./versioning/useMdKitDocumentVersions";

package/dist/markdown/MarkdownBubbleMenu.d.ts

@@ -0,0 +1,6 @@
+import type { Editor } from "@tiptap/react";
+type MarkdownBubbleMenuProps = {
+    editor: Editor;
+};
+export declare const MarkdownBubbleMenu: ({ editor }: MarkdownBubbleMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/markdown/MarkdownBubbleMenu.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { BubbleMenu } from "@tiptap/react/menus";
+import { Bold, Code2, Heading1, Heading2, Italic, Link2, List, ListOrdered, Quote, Strikethrough, } from "lucide-react";
+import { joinClassNames } from "../ui/joinClassNames";
+const setLink = (editor) => {
+    const previousUrl = editor.getAttributes("link").href;
+    const nextUrl = window.prompt("URL", previousUrl);
+    if (nextUrl === null) {
+        return;
+    }
+    if (nextUrl === "") {
+        editor.chain().focus().extendMarkRange("link").unsetLink().run();
+        return;
+    }
+    editor
+        .chain()
+        .focus()
+        .extendMarkRange("link")
+        .setLink({ href: nextUrl })
+        .run();
+};
+const ToolbarButton = ({ ariaLabel, children, isActive, onClick, }) => (_jsx("button", { type: "button", className: joinClassNames("hsk-toolbar-button", isActive && "hsk-toolbar-button-active"), "aria-label": ariaLabel, onClick: onClick, onMouseDown: (event) => event.preventDefault(), children: children }));
+export const MarkdownBubbleMenu = ({ editor }) => (_jsxs(BubbleMenu, { appendTo: () => document.body, className: "hsk-toolbar", editor: editor, options: {
+        placement: "top",
+        strategy: "fixed",
+    }, shouldShow: ({ editor: currentEditor, state }) => {
+        const { empty } = state.selection;
+        return currentEditor.isEditable && !empty;
+    }, children: [_jsx(ToolbarButton, { ariaLabel: "Bold", isActive: editor.isActive("bold"), onClick: () => editor.chain().focus().toggleBold().run(), children: _jsx(Bold, {}) }), _jsx(ToolbarButton, { ariaLabel: "Italic", isActive: editor.isActive("italic"), onClick: () => editor.chain().focus().toggleItalic().run(), children: _jsx(Italic, {}) }), _jsx(ToolbarButton, { ariaLabel: "Strikethrough", isActive: editor.isActive("strike"), onClick: () => editor.chain().focus().toggleStrike().run(), children: _jsx(Strikethrough, {}) }), _jsx(ToolbarButton, { ariaLabel: "Code block", isActive: editor.isActive("codeBlock"), onClick: () => editor.chain().focus().toggleCodeBlock().run(), children: _jsx(Code2, {}) }), _jsx("div", { className: "hsk-toolbar-divider" }), _jsx(ToolbarButton, { ariaLabel: "Heading 1", isActive: editor.isActive("heading", { level: 1 }), onClick: () => editor.chain().focus().toggleHeading({ level: 1 }).run(), children: _jsx(Heading1, {}) }), _jsx(ToolbarButton, { ariaLabel: "Heading 2", isActive: editor.isActive("heading", { level: 2 }), onClick: () => editor.chain().focus().toggleHeading({ level: 2 }).run(), children: _jsx(Heading2, {}) }), _jsx("div", { className: "hsk-toolbar-divider" }), _jsx(ToolbarButton, { ariaLabel: "Bullet list", isActive: editor.isActive("bulletList"), onClick: () => editor.chain().focus().toggleBulletList().run(), children: _jsx(List, {}) }), _jsx(ToolbarButton, { ariaLabel: "Ordered list", isActive: editor.isActive("orderedList"), onClick: () => editor.chain().focus().toggleOrderedList().run(), children: _jsx(ListOrdered, {}) }), _jsx(ToolbarButton, { ariaLabel: "Blockquote", isActive: editor.isActive("blockquote"), onClick: () => editor.chain().focus().toggleBlockquote().run(), children: _jsx(Quote, {}) }), _jsx("div", { className: "hsk-toolbar-divider" }), _jsx(ToolbarButton, { ariaLabel: "Link", isActive: editor.isActive("link"), onClick: () => setLink(editor), children: _jsx(Link2, {}) })] }));