omni-viewer-core 0.11.1 → 0.12.1

package/dist/viewers/csv/controller.d.ts

@@ -115,7 +115,12 @@ export interface CsvController {
     /** Whole document in original order as normalized CSV (save/writeback —
      *  ignores search and sort so hidden rows are never dropped). */
     toDocumentCsv(): string;
-    /** Mark the current edit depth as the saved point (clears dirty). */
+    /**
+     * Mark the current edit depth as the saved point (clears dirty). Writes are
+     * async and the grid stays editable during one, so the caller must confirm
+     * that `toDocumentCsv()` still equals what it wrote before calling this —
+     * otherwise an edit made mid-write is recorded as being on disk.
+     */
     markSaved(): void;
     /** Decoded source text (raw view). */
     readonly rawText: string;

package/dist/viewers/csv/index.js

@@ -216,13 +216,25 @@ export async function mountCsvViewer(input, container, ctx, options = {}) {
         saveAsBtn.title = t('common.noFileSave');
     }
     const dirtyBadge = el('span', 'omni-csv__dirty');
+    /**
+     * Clear dirty only if the document still equals the bytes that reached the
+     * file. The grid stays editable across the async write, so a cell changed
+     * mid-write would otherwise be recorded as saved — and a host trusting
+     * `isDirty()` would discard it on re-mount. When it differs, dirty is left
+     * set: the next save resolves it, and erring toward "unsaved" cannot lose
+     * work.
+     */
+    function markSavedIfUnchanged(written) {
+        if (controller.toDocumentCsv() === written)
+            controller.markSaved();
+    }
     async function saveDocument(service) {
         try {
             // Save covers the whole document in original order — never the
             // filtered/sorted display result (docs §6).
-            const bytes = new TextEncoder().encode(controller.toDocumentCsv());
-            await service.write(bytes);
-            controller.markSaved();
+            const written = controller.toDocumentCsv();
+            await service.write(new TextEncoder().encode(written));
+            markSavedIfUnchanged(written);
             showToast(t('common.savedToOriginal'));
         }
         catch (error) {
@@ -237,9 +249,9 @@ export async function mountCsvViewer(input, container, ctx, options = {}) {
         const name = saveAsFileName(input.fileName, state.delimiter);
         const mime = state.delimiter === '\t' ? 'text/tab-separated-values' : 'text/csv';
         try {
-            const bytes = new TextEncoder().encode(controller.toDocumentCsv());
-            await service.saveFile(name, bytes, mime);
-            controller.markSaved();
+            const written = controller.toDocumentCsv();
+            await service.saveFile(name, new TextEncoder().encode(written), mime);
+            markSavedIfUnchanged(written);
             showToast(t('common.saved', { name }));
         }
         catch (error) {

package/dist/viewers/diagram-controller.d.ts

@@ -19,8 +19,14 @@ export type DiagramAction = {
     type: 'undo';
 } | {
     type: 'redo';
-} | {
+}
+/** `source` is the text that actually reached the file. Writes are async and
+ *  the editor stays live during one, so the current source at completion is
+ *  not necessarily what was written (mirrors the latex/markdown controllers).
+ *  Omitted = "what is in the editor now". */
+ | {
     type: 'mark-saved';
+    source?: string;
 };
 export interface DiagramViewState {
     mode: DiagramViewMode;

package/dist/viewers/diagram-controller.js

@@ -38,7 +38,8 @@ export function createDiagramController(text, theme) {
                 setSource(redo.pop());
             }
             else if (action.type === 'mark-saved') {
-                state = { ...state, savedSource: state.source, dirty: false };
+                const savedSource = action.source ?? state.source;
+                state = { ...state, savedSource, dirty: state.source !== savedSource };
             }
             emit();
         },

package/dist/viewers/diagram.d.ts

@@ -8,6 +8,11 @@ export type DiagramViewerContext = HostContext & {
     writeback?: FileWritebackService;
     save?: FileSaveService;
 };
+/** Diagram mount handle: `isDirty()` lets a host guard a re-mount against
+ *  discarding unsaved source edits (DESIGN.md §3-②). */
+export interface DiagramViewerHandle extends ViewerHandle {
+    isDirty(): boolean;
+}
 export interface DiagramMountOptions extends MountOptions {
     renderMermaid?(id: string, source: string, theme?: DiagramTheme): Promise<string>;
     renderPlantUml?(source: string, document: Document, theme?: DiagramTheme): SVGElement | string;
@@ -20,5 +25,5 @@ export interface DiagramMountOptions extends MountOptions {
 export declare function mountDiagramViewer(kind: DiagramKind, parsed: {
     source: string;
     warnings: string[];
-}, input: ViewerInput, container: HTMLElement, ctx: DiagramViewerContext, options?: DiagramMountOptions): Promise<ViewerHandle>;
+}, input: ViewerInput, container: HTMLElement, ctx: DiagramViewerContext, options?: DiagramMountOptions): Promise<DiagramViewerHandle>;
 export declare function sanitizeSvg(svg: string, maxBytes?: number, maxNodes?: number): SVGElement;

package/dist/viewers/diagram.js

@@ -181,13 +181,20 @@ export async function mountDiagramViewer(kind, parsed, input, container, ctx, op
         }
     };
     const saveSource = async () => {
-        const bytes = new TextEncoder().encode(controller.state.source);
+        // Snapshot once: the write is async and the editor stays live, so
+        // `controller.state.source` after the await may already be a later edit
+        // than the bytes that reached the file.
+        const saved = controller.state.source;
+        const bytes = new TextEncoder().encode(saved);
         if (ctx.writeback) {
+            // The caption is the dirty indicator: leave syncState's verdict alone
+            // when an edit arrived mid-write and the source is still unsaved.
             try {
                 await ctx.writeback.write(bytes);
-                controller.dispatch({ type: 'mark-saved' });
+                controller.dispatch({ type: 'mark-saved', source: saved });
                 setStatus('common.savedToOriginal', 'valid');
-                sourceCaption.textContent = t('common.savedToOriginal');
+                if (!controller.state.dirty)
+                    sourceCaption.textContent = t('common.savedToOriginal');
             }
             catch (error) {
                 ctx.logger.log('error', `diagram save failed: ${String(error)}`);
@@ -296,7 +303,11 @@ export async function mountDiagramViewer(kind, parsed, input, container, ctx, op
                 container.classList.remove(VIEWER_ROOT_CLASS, `omni-viewer--${kind}`);
             else
                 root.replaceChildren();
-        }
+        },
+        // The controller, not the textarea: `mark-saved` (a successful writeback)
+        // is the only thing that clears it, so a failed save or a Save As copy
+        // stays dirty.
+        isDirty: () => controller.state.dirty
     };
 }
 let nextId = 1;

package/dist/viewers/latex/controller.d.ts

@@ -12,8 +12,17 @@ export type LatexAction = {
     type: 'undo';
 } | {
     type: 'redo';
-} | {
+}
+/**
+ * `source` is the text that actually reached the file. Writes are async and
+ * the editor stays live during one, so the current source at completion is
+ * not necessarily what was written — omitting it would mark an edit made
+ * mid-write as saved and let a host discard it. Omitted = "what is in the
+ * editor now", which is only correct for synchronous saves.
+ */
+ | {
     type: 'mark-saved';
+    source?: string;
 };
 export interface LatexViewState {
     mode: LatexViewMode;

package/dist/viewers/latex/controller.js

@@ -52,7 +52,8 @@ export function createLatexController(text, mode = 'preview') {
                 setSource(redo.pop());
             }
             else if (action.type === 'mark-saved') {
-                state = { ...state, savedSource: state.source, dirty: false };
+                const savedSource = action.source ?? state.source;
+                state = { ...state, savedSource, dirty: state.source !== savedSource };
             }
             emit();
         },

package/dist/viewers/latex/index.d.ts

@@ -28,6 +28,12 @@ export interface LatexViewerDeps {
     math?: MathRenderer;
     createDOMPurify?(window: Window): DomPurify;
 }
+/** LaTeX mount handle: dirty inspection lets hosts guard a re-mount (file
+ *  change, refresh) against discarding unsaved edits, without reaching into the
+ *  viewer's DOM (csv/image/pdf expose the same method). */
+export interface LatexViewerHandle extends ViewerHandle {
+    isDirty(): boolean;
+}
 export interface LatexMountOptions extends MountOptions {
     /** Forwarded to the parser (limits, cancellation). */
     parse?: LatexParseOptions;
@@ -57,7 +63,7 @@ export declare const LATEX_VIEWER_META: {
     optionalServices: readonly ["clipboard", "navigation", "writeback", "save"];
     inputOwnership: "borrows";
 };
-export declare function mountLatexViewer(input: ViewerInput, container: HTMLElement, ctx: LatexViewerContext, options?: LatexMountOptions): Promise<ViewerHandle>;
+export declare function mountLatexViewer(input: ViewerInput, container: HTMLElement, ctx: LatexViewerContext, options?: LatexMountOptions): Promise<LatexViewerHandle>;
 /**
  * Commands that produce no glyphs but that math engines do not implement.
  * Collecting the document's own macros (L18) means a text-mode macro can now

package/dist/viewers/latex/index.js

@@ -543,11 +543,15 @@ export async function mountLatexViewer(input, container, ctx, options = {}) {
         }
     };
     const saveSource = async () => {
-        const bytes = new TextEncoder().encode(controller.state.source);
+        // Snapshot once: the write is async and the editor stays live, so
+        // `controller.state.source` after the await may already be a later edit
+        // than the bytes that reached the file.
+        const saved = controller.state.source;
+        const bytes = new TextEncoder().encode(saved);
         if (ctx.writeback) {
             try {
                 await ctx.writeback.write(bytes);
-                controller.dispatch({ type: 'mark-saved' });
+                controller.dispatch({ type: 'mark-saved', source: saved });
                 setStatus('common.savedToOriginal', 'valid');
             }
             catch (error) {
@@ -641,7 +645,10 @@ export async function mountLatexViewer(input, container, ctx, options = {}) {
         teardown();
         throw new MountAbortedError();
     }
-    return { dispose: teardown };
+    // Reads the controller rather than the textarea: the source of truth for
+    // "unsaved" is `source !== savedSource`, which undo restores and `mark-saved`
+    // clears. A Save As copy never dispatches `mark-saved`, so it stays dirty.
+    return { dispose: teardown, isDirty: () => controller.state.dirty };
 }
 function errorText(error, fallback) {
     return error instanceof Error ? error.message : fallback;

package/dist/viewers/markdown/controller.d.ts

@@ -18,8 +18,13 @@ export type MarkdownAction = {
     type: 'undo';
 } | {
     type: 'redo';
-} | {
+}
+/** `source` is the text that actually reached the file. Writes are async and
+ *  the editor stays live during one, so the current source at completion is
+ *  not necessarily what was written. Omitted = "what is in the editor now". */
+ | {
     type: 'mark-saved';
+    source?: string;
 } | {
     type: 'copy-code';
     code: string;

package/dist/viewers/markdown/controller.js

@@ -52,7 +52,8 @@ export function createMarkdownController(text, _headings) {
                 setSource(redo.pop());
             }
             else if (action.type === 'mark-saved') {
-                state = { ...state, savedSource: state.source, dirty: false };
+                const savedSource = action.source ?? state.source;
+                state = { ...state, savedSource, dirty: state.source !== savedSource };
             }
             emit();
         },

package/dist/viewers/markdown/index.d.ts

@@ -56,6 +56,11 @@ export type MarkdownViewerContext = HostContext & {
     writeback?: FileWritebackService;
     save?: FileSaveService;
 };
+/** Markdown mount handle: `isDirty()` lets a host guard a re-mount against
+ *  discarding unsaved source edits (DESIGN.md §3-②). */
+export interface MarkdownViewerHandle extends ViewerHandle {
+    isDirty(): boolean;
+}
 export interface MarkdownMountOptions extends MountOptions {
     limits?: ResourceLimits;
     markdownLimits?: MarkdownParseOptions['markdownLimits'];
@@ -64,4 +69,4 @@ export interface MarkdownMountOptions extends MountOptions {
      *  wants it configurable should drive this from its own settings. */
     scrollSync?: boolean;
 }
-export declare function mountMarkdownViewer(input: ViewerInput, container: HTMLElement, ctx: MarkdownViewerContext, deps: MarkdownViewerDeps, options?: MarkdownMountOptions): Promise<ViewerHandle>;
+export declare function mountMarkdownViewer(input: ViewerInput, container: HTMLElement, ctx: MarkdownViewerContext, deps: MarkdownViewerDeps, options?: MarkdownMountOptions): Promise<MarkdownViewerHandle>;

package/dist/viewers/markdown/index.js

@@ -546,13 +546,20 @@ export async function mountMarkdownViewer(input, container, ctx, deps, options =
         }
     };
     const saveSource = async () => {
-        const bytes = new TextEncoder().encode(controller.state.source);
+        // Snapshot once: the write is async and the editor stays live, so
+        // `controller.state.source` after the await may already be a later edit
+        // than the bytes that reached the file.
+        const saved = controller.state.source;
+        const bytes = new TextEncoder().encode(saved);
         if (ctx.writeback) {
+            // The caption is the dirty indicator: leave syncState's verdict alone
+            // when an edit arrived mid-write and the source is still unsaved.
             try {
                 await ctx.writeback.write(bytes);
-                controller.dispatch({ type: 'mark-saved' });
+                controller.dispatch({ type: 'mark-saved', source: saved });
                 setStatus('common.savedToOriginal', 'valid');
-                sourceCaption.textContent = t('common.savedToOriginal');
+                if (!controller.state.dirty)
+                    sourceCaption.textContent = t('common.savedToOriginal');
             }
             catch (error) {
                 ctx.logger.log('error', `markdown save failed: ${String(error)}`);
@@ -739,9 +746,15 @@ export async function mountMarkdownViewer(input, container, ctx, deps, options =
         releaseAssets();
         throw new MountAbortedError();
     }
-    return { dispose() { disposed = true; renderVersion++; if (liveTimer)
+    return {
+        dispose() { disposed = true; renderVersion++; if (liveTimer)
             clearTimeout(liveTimer); releaseAssets(); for (const dispose of disposers.splice(0))
-            dispose(); shell.remove(); } };
+            dispose(); shell.remove(); },
+        // The controller, not the textarea: `mark-saved` (a successful writeback)
+        // is the only thing that clears it, so a failed save or a download copy
+        // stays dirty.
+        isDirty: () => controller.state.dirty
+    };
 }
 /** Flat text for an outline entry. Rendered math contributes twice to
  *  `textContent` — KaTeX emits a visual copy alongside a MathML twin — so the

package/dist/viewers/mermaid/index.d.ts

@@ -1,9 +1,10 @@
-import { diagramViewerCss, type DiagramMountOptions, type DiagramViewerContext } from '../diagram.js';
-import type { ViewerHandle, ViewerInput } from '../types.js';
+import { diagramViewerCss, type DiagramMountOptions, type DiagramViewerContext, type DiagramViewerHandle } from '../diagram.js';
+import type { ViewerInput } from '../types.js';
 export { parseMermaid } from '../../parsers/mermaid/index.js';
 export { diagramViewerCss as mermaidViewerCss };
 export type MermaidViewerContext = DiagramViewerContext;
 export type MermaidMountOptions = DiagramMountOptions;
+export type MermaidViewerHandle = DiagramViewerHandle;
 export declare const MERMAID_VIEWER_META: {
     id: string;
     displayNameKey: string;
@@ -13,4 +14,4 @@ export declare const MERMAID_VIEWER_META: {
     optionalServices: readonly ["clipboard", "writeback", "save"];
     inputOwnership: "borrows";
 };
-export declare function mountMermaidViewer(input: ViewerInput, container: HTMLElement, ctx: MermaidViewerContext, options?: MermaidMountOptions): Promise<ViewerHandle>;
+export declare function mountMermaidViewer(input: ViewerInput, container: HTMLElement, ctx: MermaidViewerContext, options?: MermaidMountOptions): Promise<MermaidViewerHandle>;

package/dist/viewers/pdf/controller.d.ts

@@ -123,8 +123,18 @@ export type PdfAction = {
     type: 'undo';
 } | {
     type: 'redo';
-} | {
+}
+/**
+ * `savedState` is the page order and annotations that actually reached the
+ * file. Builds and writes are async and the document stays editable during
+ * one, so the state at completion is not necessarily what was written —
+ * omitting it would mark an edit made mid-save as saved and let a host
+ * discard it. Omitted = "the current state", which is only correct for a
+ * synchronous save.
+ */
+ | {
     type: 'mark-saved';
+    savedState?: Pick<PdfViewState, 'pageOrder' | 'annotations'>;
 };
 export interface PdfController {
     readonly state: PdfViewState;

package/dist/viewers/pdf/controller.js

@@ -217,7 +217,14 @@ export function createPdfController(pageCount, seed, options = {}) {
                     selectedAnnotationId = action.id;
                     break;
                 case 'mark-saved':
-                    savedSignature = signature();
+                    // Same shape as `signature()` so an unchanged document still
+                    // compares equal (state copies preserve key order).
+                    savedSignature = action.savedState
+                        ? JSON.stringify({
+                            pageOrder: action.savedState.pageOrder,
+                            annotations: action.savedState.annotations
+                        })
+                        : signature();
                     break;
             }
             if (before && beforeSignature !== signature()) {

package/dist/viewers/pdf/index.js

@@ -106,6 +106,9 @@ export async function mountPdfViewer(input, container, ctx, deps, options = {})
     let thumbRecords = [];
     let renderEpoch = 0;
     let currentPage = 1;
+    /** Page requested by an explicit navigation, held against the scroll event
+     *  that navigation queues. Cleared once the reader scrolls themselves. */
+    let navigatedTo;
     let tool = 'view';
     let highlightColor = '#ffeb3b';
     let underlineColor = '#000000';
@@ -1359,12 +1362,29 @@ export async function mountPdfViewer(input, container, ctx, deps, options = {})
         // coordinate-based movement is enough. Combining this with
         // scrollIntoView applied the same offset twice.
         pages.scrollTop = Math.max(0, pages.scrollTop + page.top - viewport.top);
+        // The scrollport clamps at its end, so pages inside the final screenful
+        // — the pages appended by a merge, typically — never reach the top of
+        // the viewport. Pin the requested page against the scroll event this
+        // assignment queues; without it the listener re-selects the page that
+        // does straddle the top and the click appears to land one page early.
+        // Read the value back so the pin carries the clamped landing position.
+        navigatedTo = { pageNumber: record.pageNumber, scrollTop: pages.scrollTop };
         requestAnimationFrame(() => {
             ctx.logger.log('info', `[pdf navigation] result page=${record.pageNumber} scrollTop=${pages.scrollTop} ` +
                 `delta=${pages.scrollTop - before}`);
         });
     }
     function syncCurrentPageFromViewport() {
+        if (navigatedTo) {
+            // Still resting where the navigation left us: honour the request.
+            // Any other offset means the reader has scrolled since, so the
+            // viewport takes over again.
+            if (Math.abs(pages.scrollTop - navigatedTo.scrollTop) <= 1) {
+                setCurrentPage(navigatedTo.pageNumber);
+                return;
+            }
+            navigatedTo = undefined;
+        }
         const viewport = pages.getBoundingClientRect();
         const visible = records.filter((record) => {
             const box = record.wrapper.getBoundingClientRect();
@@ -1387,6 +1407,9 @@ export async function mountPdfViewer(input, container, ctx, deps, options = {})
     async function rebuildLayout() {
         if (!doc || disposed)
             return;
+        // Page boxes are about to move (merge, reorder, delete, zoom), so a
+        // pin taken against the old layout no longer describes anything.
+        navigatedTo = undefined;
         // Preserve the source page the reader is actually viewing.  `currentPage`
         // alone is not sufficient here: the lazy-render observer deliberately
         // observes pages outside the viewport as well.
@@ -1757,13 +1780,20 @@ export async function mountPdfViewer(input, container, ctx, deps, options = {})
     async function save() {
         if (!ctx.writeback || saveBtn.disabled)
             return;
+        // Pin what is being written before the build starts: only the save/merge
+        // buttons are disabled while an operation runs, so pages and annotations
+        // can still change across the await. Taking the state at completion would
+        // mark those changes as saved and let a host discard them on re-mount.
+        // `stateForSave()` only rasterizes text for output, so the pre-raster
+        // state is what this write represents.
+        const { pageOrder, annotations } = controller.state;
         const result = await runOperation('save', async (control) => {
             const data = await buildOutput(stateForSave(), control);
             await ctx.writeback.write(data);
         });
         if (result.status === 'succeeded') {
             mergedSinceSave = false;
-            controller.dispatch({ type: 'mark-saved' });
+            controller.dispatch({ type: 'mark-saved', savedState: { pageOrder, annotations } });
             refreshChrome();
             status.textContent = t('common.savedToOriginal');
         }

package/dist/viewers/plantuml/index.d.ts

@@ -1,9 +1,10 @@
-import { diagramViewerCss, type DiagramMountOptions, type DiagramViewerContext } from '../diagram.js';
-import type { ViewerHandle, ViewerInput } from '../types.js';
+import { diagramViewerCss, type DiagramMountOptions, type DiagramViewerContext, type DiagramViewerHandle } from '../diagram.js';
+import type { ViewerInput } from '../types.js';
 export { parsePlantUml } from '../../parsers/plantuml/index.js';
 export { diagramViewerCss as plantumlViewerCss };
 export type PlantUmlViewerContext = DiagramViewerContext;
 export type PlantUmlMountOptions = DiagramMountOptions;
+export type PlantUmlViewerHandle = DiagramViewerHandle;
 export declare const PLANTUML_VIEWER_META: {
     id: string;
     displayNameKey: string;
@@ -13,4 +14,4 @@ export declare const PLANTUML_VIEWER_META: {
     optionalServices: readonly ["clipboard", "writeback", "save"];
     inputOwnership: "borrows";
 };
-export declare function mountPlantUmlViewer(input: ViewerInput, container: HTMLElement, ctx: PlantUmlViewerContext, options?: PlantUmlMountOptions): Promise<ViewerHandle>;
+export declare function mountPlantUmlViewer(input: ViewerInput, container: HTMLElement, ctx: PlantUmlViewerContext, options?: PlantUmlMountOptions): Promise<PlantUmlViewerHandle>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omni-viewer-core",
-  "version": "0.11.1",
+  "version": "0.12.1",
   "description": "Shared parsing + rendering core for Omni Viewer (vscode / chrome / obsidian / web)",
   "type": "module",
   "license": "MIT",