@rightkit/document-workspace 0.0.0-stage → 0.1.1

package/dist/app/useDraftConfirmGate.js

@@ -0,0 +1,47 @@
+import { useCallback, useState } from "react";
+import { resolveDocumentDrafts } from "./draftResolution.js";
+/**
+ * The draft-confirm chooser state + its gate. `requestDraftAwareViewChange` wraps a view change so
+ * a modified block draft first opens the Done/Discard/Cancel chooser (Done commits, Discard drops,
+ * Cancel stays on the current view with the editor open); a draft-free document proceeds
+ * immediately. Extracted verbatim from useDocuments; bodies are unchanged.
+ */
+export function useDraftConfirmGate({ blockDrafts }) {
+    const [draftConfirm, setDraftConfirm] = useState(null);
+    const confirmDraftDone = useCallback(async () => {
+        const c = draftConfirm;
+        if (!c)
+            return;
+        setDraftConfirm(null);
+        const outcome = await resolveDocumentDrafts(blockDrafts, c.documentPath, c.intent, "done");
+        if (outcome === "resolved")
+            c.onResolved();
+    }, [draftConfirm, blockDrafts]);
+    const confirmDraftDiscard = useCallback(async () => {
+        const c = draftConfirm;
+        if (!c)
+            return;
+        setDraftConfirm(null);
+        const outcome = await resolveDocumentDrafts(blockDrafts, c.documentPath, c.intent, "discard");
+        if (outcome === "resolved")
+            c.onResolved();
+    }, [draftConfirm, blockDrafts]);
+    const confirmDraftCancel = useCallback(() => setDraftConfirm(null), []);
+    // Gate a view change on the active document's modified drafts: open the Done/Discard/Cancel
+    // chooser when a draft exists, else proceed immediately.
+    const requestDraftAwareViewChange = useCallback((path, proceed) => {
+        if (blockDrafts.snapshotModified(path).length > 0) {
+            setDraftConfirm({ documentPath: path, intent: "view-change", onResolved: proceed });
+            return;
+        }
+        proceed();
+    }, [blockDrafts]);
+    return {
+        draftConfirm,
+        setDraftConfirm,
+        confirmDraftDone,
+        confirmDraftDiscard,
+        confirmDraftCancel,
+        requestDraftAwareViewChange,
+    };
+}

package/dist/app/useFileDragOverlay.d.ts

@@ -0,0 +1,12 @@
+import { type DragEvent } from "react";
+/** Root-level file-drag "Drop to open" overlay state + handlers, extracted from App.tsx. */
+export declare function useFileDragOverlay(): {
+    dragOver: boolean;
+    rootDragProps: {
+        onDragEnter: (e: DragEvent) => void;
+        onDragOver: (e: DragEvent) => void;
+        onDragLeave: (e: DragEvent) => void;
+        onDrop: () => void;
+    };
+};
+export declare function DropOverlay(): import("react").JSX.Element;

package/dist/app/useFileDragOverlay.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, useState } from "react";
+const hasFileDrag = (types) => {
+    if (!types)
+        return false;
+    if (typeof types.includes === "function")
+        return types.includes("Files");
+    const domStringList = types;
+    return typeof domStringList.contains === "function" && domStringList.contains("Files");
+};
+/** Root-level file-drag "Drop to open" overlay state + handlers, extracted from App.tsx. */
+export function useFileDragOverlay() {
+    const [dragOver, setDragOver] = useState(false);
+    const dragCounter = useRef(0);
+    const rootDragProps = {
+        onDragEnter: (e) => {
+            if (hasFileDrag(e.dataTransfer?.types)) {
+                e.preventDefault();
+                dragCounter.current++;
+                setDragOver(true);
+            }
+        },
+        onDragOver: (e) => {
+            if (hasFileDrag(e.dataTransfer?.types)) {
+                e.preventDefault();
+                if (e.dataTransfer)
+                    e.dataTransfer.dropEffect = "copy";
+            }
+        },
+        onDragLeave: (e) => {
+            if (dragOver || hasFileDrag(e.dataTransfer?.types)) {
+                e.preventDefault();
+                dragCounter.current--;
+                if (dragCounter.current <= 0) {
+                    dragCounter.current = 0;
+                    setDragOver(false);
+                }
+            }
+        },
+        onDrop: () => {
+            dragCounter.current = 0;
+            setDragOver(false);
+        },
+    };
+    return { dragOver, rootDragProps };
+}
+export function DropOverlay() {
+    return (_jsx("div", { className: "fixed inset-0 z-[100] pointer-events-none flex items-center justify-center bg-copper/10 border-2 border-dashed border-copper/50", children: _jsx("div", { className: "rounded-lg bg-panel-2 px-6 py-4 shadow-2xl border border-copper/30 font-sans text-sm text-copper-hi", children: "Drop to open" }) }));
+}

package/dist/app/useFormatApis.d.ts

@@ -0,0 +1,13 @@
+import type { DocxMenuApi } from "@rightkit/docx-editor/documents/docx/menuApi";
+import type { LoadedDocument } from "@rightkit/document-core/documents/types";
+import type { MarkdownExportApi } from "@rightkit/markdown-editor/documents/markdown/export/markdownExportTypes";
+/** Single-active-slot APIs the mounted format panes register (DOCX menu, PDF print, Markdown export)
+ * plus the print router that prefers them. Extracted verbatim from App.tsx. */
+export declare function useFormatApis(onPrint: (doc: LoadedDocument | null) => void): {
+    docxMenu: DocxMenuApi | null;
+    setDocxMenu: import("react").Dispatch<import("react").SetStateAction<DocxMenuApi | null>>;
+    markdownExport: MarkdownExportApi | null;
+    registerPdfPrint: (fn: (() => Promise<boolean>) | null) => void;
+    registerMarkdownExport: (api: MarkdownExportApi | null) => void;
+    handlePrint: (doc: LoadedDocument | null) => void;
+};

package/dist/app/useFormatApis.js

@@ -0,0 +1,62 @@
+import { useCallback, useState } from "react";
+import { toast } from "@rightkit/platform-ui/headless";
+import { logError } from "@rightkit/document-core/state/diagnostics";
+import { printHtmlMarkup } from "@rightkit/document-core/app/documentPrinting";
+/** Single-active-slot APIs the mounted format panes register (DOCX menu, PDF print, Markdown export)
+ * plus the print router that prefers them. Extracted verbatim from App.tsx. */
+export function useFormatApis(onPrint) {
+    const [docxMenu, setDocxMenu] = useState(null);
+    // The active PDF pane's own print function, using the PDFDocumentProxy it already has loaded/
+    // rendering on screen — NOT a fresh fetch of the same viewright-stream:// URL, which hung
+    // indefinitely with no error (see documentPrinting.ts printPdf's fallback for the no-registration
+    // case). Mirrors the docxMenu single-active-slot pattern above.
+    const [pdfPrint, setPdfPrint] = useState(null);
+    const [markdownExport, setMarkdownExport] = useState(null);
+    // MUST wrap in an extra arrow: React useState setters treat a bare function argument as an updater
+    // `(prev) => next`, so `setPdfPrint(fn)` would INVOKE the print function at registration time and
+    // store its Promise instead of the function. That made every later `pdfPrint()` call throw
+    // synchronously — no dialog, no toast, no timeout, which is exactly how PDF print "did nothing".
+    const registerPdfPrint = useCallback((fn) => setPdfPrint(() => fn), []);
+    const registerMarkdownExport = useCallback((api) => setMarkdownExport(api), []);
+    // Route PDF print through the active pane's registered function when available; every other
+    // format keeps using useDocuments' onPrint unchanged.
+    const handlePrint = useCallback((doc) => {
+        if (doc?.format === "pdf" && pdfPrint) {
+            void pdfPrint()
+                .then((printed) => {
+                if (printed)
+                    return;
+                logError("print:failed:pdf");
+                toast("Couldn't open print dialog", "error");
+            })
+                .catch(() => {
+                logError("print:failed:pdf");
+                toast("Couldn't open print dialog", "error");
+            });
+            return;
+        }
+        if (doc?.format === "md" && markdownExport?.documentPath === doc.path) {
+            void markdownExport
+                .createSnapshot()
+                .then(async (snapshot) => {
+                const printed = await printHtmlMarkup(snapshot.htmlFragment);
+                if (!printed)
+                    throw new Error("Print dialog did not open");
+                if (snapshot.warnings.length) {
+                    toast(`Printed with ${snapshot.warnings.length} warning${snapshot.warnings.length === 1 ? "" : "s"}`, "info");
+                }
+            })
+                .catch(() => {
+                logError("print:failed:md");
+                toast("Couldn't open print dialog", "error");
+            });
+            return;
+        }
+        if (doc?.format === "md") {
+            toast("Markdown renderer is still loading", "info");
+            return;
+        }
+        onPrint(doc);
+    }, [markdownExport, pdfPrint, onPrint]);
+    return { docxMenu, setDocxMenu, markdownExport, registerPdfPrint, registerMarkdownExport, handlePrint };
+}

package/dist/app/useFormatDirtyState.d.ts

@@ -0,0 +1,29 @@
+import { type Dispatch, type SetStateAction } from "react";
+import type { ImageSaveFunction, ImageSavePayload } from "@rightkit/media-ui";
+import type { PdfSaveFunction } from "@rightkit/document-core/documents/pdf/pdfEditor";
+import type { PdfSavePlan } from "@rightkit/document-core/documents/pdf/pdfEditModel";
+interface FormatDirtyStateDeps {
+    setError: Dispatch<SetStateAction<string | null>>;
+    setDocxDirty: Dispatch<SetStateAction<Set<string>>>;
+    setPdfDirty: Dispatch<SetStateAction<Set<string>>>;
+    setImageDirty: Dispatch<SetStateAction<Set<string>>>;
+    markSelfSaved: (path: string) => void;
+    refreshFingerprint: (path: string) => void;
+    onDirty?: (path: string) => void;
+}
+export declare function useFormatDirtyState({ setError, setDocxDirty, setPdfDirty, setImageDirty, markSelfSaved, refreshFingerprint, onDirty, }: FormatDirtyStateDeps): {
+    docxSaver: import("react").RefObject<(() => Promise<ArrayBuffer | null>) | null>;
+    imageSaver: import("react").RefObject<ImageSaveFunction | null>;
+    docxSaversRef: import("react").RefObject<Map<string, () => Promise<ArrayBuffer | null>>>;
+    pdfSaversRef: import("react").RefObject<Map<string, PdfSaveFunction>>;
+    pdfSavePlansRef: import("react").RefObject<Map<string, () => Promise<PdfSavePlan>>>;
+    imageSaversRef: import("react").RefObject<Map<string, ImageSaveFunction>>;
+    onDocxSave: (path: string, buffer: ArrayBuffer) => Promise<void>;
+    onDocxChange: (path: string) => void;
+    onPdfDirtyChange: (path: string, dirty: boolean) => void;
+    onImageChange: (path: string) => void;
+    clearImageDirty: (path: string) => void;
+    restoreImageDirty: (path: string) => void;
+    writeImagePayload: (path: string, payload: ImageSavePayload) => Promise<void>;
+};
+export {};

package/dist/app/useFormatDirtyState.js

@@ -0,0 +1,81 @@
+import { useCallback, useRef } from "react";
+import { writeDocumentBytes } from "@rightkit/document-core/state/tauriBridge";
+import { errorMessage } from "@rightkit/document-core/state/errors";
+export function useFormatDirtyState({ setError, setDocxDirty, setPdfDirty, setImageDirty, markSelfSaved, refreshFingerprint, onDirty, }) {
+    const docxSaver = useRef(null);
+    const pdfSaversRef = useRef(new Map());
+    const pdfSavePlansRef = useRef(new Map());
+    const imageSaver = useRef(null);
+    const docxSaversRef = useRef(new Map());
+    const imageSaversRef = useRef(new Map());
+    // One dirty-set pattern for DOCX and image: a path is added or removed through these helpers,
+    // each a no-op when the set already matches (so repeated edits never churn state).
+    const addDirtyPath = useCallback((setter, path) => {
+        setter((s) => (s.has(path) ? s : new Set(s).add(path)));
+    }, []);
+    const removeDirtyPath = useCallback((setter, path) => {
+        setter((s) => {
+            if (!s.has(path))
+                return s;
+            const n = new Set(s);
+            n.delete(path);
+            return n;
+        });
+    }, []);
+    const onDocxSave = useCallback(async (path, buffer) => {
+        try {
+            await writeDocumentBytes(path, buffer);
+            markSelfSaved(path);
+            refreshFingerprint(path);
+            removeDirtyPath(setDocxDirty, path);
+        }
+        catch (e) {
+            setError(errorMessage(e));
+        }
+    }, [markSelfSaved, refreshFingerprint, removeDirtyPath, setDocxDirty, setError]);
+    const onDocxChange = useCallback((path) => {
+        addDirtyPath(setDocxDirty, path);
+        onDirty?.(path);
+    }, [addDirtyPath, onDirty, setDocxDirty]);
+    const onPdfDirtyChange = useCallback((path, dirty) => {
+        setPdfDirty((paths) => {
+            if (dirty === paths.has(path))
+                return paths;
+            const next = new Set(paths);
+            if (dirty)
+                next.add(path);
+            else
+                next.delete(path);
+            return next;
+        });
+        if (dirty)
+            onDirty?.(path);
+    }, [onDirty, setPdfDirty]);
+    const onImageChange = useCallback((path) => {
+        addDirtyPath(setImageDirty, path);
+        onDirty?.(path);
+    }, [addDirtyPath, onDirty, setImageDirty]);
+    const clearImageDirty = useCallback((path) => removeDirtyPath(setImageDirty, path), [removeDirtyPath, setImageDirty]);
+    const restoreImageDirty = useCallback((path) => addDirtyPath(setImageDirty, path), [addDirtyPath, setImageDirty]);
+    const writeImagePayload = useCallback(async (path, payload) => {
+        await writeDocumentBytes(path, payload.buffer);
+        markSelfSaved(path);
+        refreshFingerprint(path);
+        removeDirtyPath(setImageDirty, path);
+    }, [markSelfSaved, refreshFingerprint, removeDirtyPath, setImageDirty]);
+    return {
+        docxSaver,
+        imageSaver,
+        docxSaversRef,
+        pdfSaversRef,
+        pdfSavePlansRef,
+        imageSaversRef,
+        onDocxSave,
+        onDocxChange,
+        onPdfDirtyChange,
+        onImageChange,
+        clearImageDirty,
+        restoreImageDirty,
+        writeImagePayload,
+    };
+}

package/dist/app/useGlobalShortcuts.d.ts

@@ -0,0 +1,47 @@
+import type { LoadedDocument, SearchProvider } from "@rightkit/document-core/documents/types";
+import type { DocxMenuApi } from "@rightkit/docx-editor/documents/docx/menuApi";
+interface Options {
+    active: LoadedDocument | null;
+    activeEditable: boolean;
+    searchProvider: SearchProvider | null;
+    canOpenFind?: boolean;
+    docxMenu: DocxMenuApi | null;
+    newDocument: () => void;
+    onOpenDialog: () => void;
+    onPrint: (doc: LoadedDocument | null) => void;
+    onSave: (doc: LoadedDocument) => void;
+    onSaveAs: (doc: LoadedDocument) => void;
+    requestClose: (path: string) => void;
+    togglePalette: () => void;
+    openFind: (replace: boolean) => void;
+    /** HTML Ctrl+S: one dirty page saves directly; several open the page-aware chooser. */
+    onHtmlSaveShortcut: (entryPath: string) => void;
+    /** Re-read the active doc from disk (browser-style refresh) — for non-HTML formats. HTML refresh is
+     *  routed through a window event so the HtmlDocument reloads its current page + rebuilds the preview. */
+    reloadActiveFromDisk: (doc: LoadedDocument) => void;
+    /** Open whatever's on the clipboard (Ctrl+V / Ctrl+Shift+V): text → new draft, image → temp .bmp,
+     *  files → open like drag-drop. Only fires outside a text field so editors keep their own paste. */
+    openFromClipboard: () => void;
+    /** Tab navigation: cycle next (+1) / previous (-1) through the open tabs. */
+    cycleTab: (dir: 1 | -1) => void;
+    /** Jump to the Nth open tab (0-based; the help overlay maps Ctrl+1..9). */
+    jumpToTab: (index: number) => void;
+    /** Reopen the most-recently-closed file/web tab (Ctrl+Shift+T). */
+    reopenClosed: () => void;
+    /** Reset the active surface's zoom/font size to its default (Ctrl+0). */
+    resetZoom: () => void;
+    /** Toggle source/text word wrap (Alt+Z). */
+    toggleWordWrap: () => void;
+    /** Toggle the sidebar (Ctrl+E / Ctrl+\). */
+    toggleSidebar: () => void;
+    /** Toggle the tab-overview card grid (Ctrl/Cmd+Shift+A). */
+    toggleTabOverview: () => void;
+    /** Show the keyboard-shortcut help overlay (?). */
+    showHelp: () => void;
+    /** Whether the find bar is currently open (drives F3 step-vs-open). */
+    findOpen: boolean;
+    /** Toggle distraction-free reading (Ctrl+Shift+F) — hides sidebar + toolbars. */
+    toggleDistractionFree: () => void;
+}
+export declare function useGlobalShortcuts({ active, activeEditable, searchProvider, canOpenFind, docxMenu, newDocument, onOpenDialog, onPrint, onSave, onSaveAs, requestClose, togglePalette, openFind, onHtmlSaveShortcut, reloadActiveFromDisk, openFromClipboard, cycleTab, jumpToTab, reopenClosed, resetZoom, toggleWordWrap, toggleSidebar, toggleTabOverview, showHelp, findOpen, toggleDistractionFree, }: Options): void;
+export {};