omni-viewer-core 0.3.0 → 0.5.0

package/dist/viewers/json/index.js

@@ -246,10 +246,13 @@ export async function mountJsonViewer(input, container, ctx, options = {}) {
         copyResultBtn.disabled = true;
         copyResultBtn.title = t('common.noClipboard');
     }
+    const replaceResultBtn = el('button', undefined, t('json.result.replace'));
+    replaceResultBtn.type = 'button';
+    on(replaceResultBtn, 'click', () => controller.dispatch({ type: 'apply-result-to-editor' }));
     const closeResultBtn = el('button', undefined, t('json.result.close'));
     closeResultBtn.type = 'button';
     on(closeResultBtn, 'click', () => controller.dispatch({ type: 'dismiss-result' }));
-    resultActions.append(copyResultBtn, closeResultBtn);
+    resultActions.append(copyResultBtn, replaceResultBtn, closeResultBtn);
     resultPanel.append(resultTitle, resultOutput, resultMarkup, resultTableWrap, resultActions);
     frame.append(toolbar, statusBar, diagnosticsBar, resultPanel, body);
     root.appendChild(frame);
@@ -475,6 +478,7 @@ export async function mountJsonViewer(input, container, ctx, options = {}) {
             if (isMarkup)
                 renderMarkupResult(state.toolResult.action, state.toolResult.output);
             copyResultBtn.disabled = !clipboard || !!state.toolResult.error;
+            replaceResultBtn.disabled = !!state.toolResult.error;
         }
         else {
             resultPanel.style.display = 'none';

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

@@ -1,4 +1,4 @@
-import type { ClipboardService, DocumentAssetsService, FileWritebackService, HostContext, NavigationService } from '../../host/index.js';
+import type { ClipboardService, DocumentAssetsService, FileSaveService, FileWritebackService, HostContext, NavigationService } from '../../host/index.js';
 import { type MarkdownParseOptions } from '../../parsers/markdown/index.js';
 import type { ResourceLimits } from '../../parsers/types.js';
 import { type MountOptions, type ViewerHandle, type ViewerInput } from '../types.js';
@@ -12,7 +12,7 @@ export declare const MARKDOWN_VIEWER_META: {
     extensions: string[];
     priority: number;
     requiredServices: readonly [];
-    optionalServices: readonly ["clipboard", "navigation", "documentAssets", "writeback"];
+    optionalServices: readonly ["clipboard", "navigation", "documentAssets", "writeback", "save"];
     inputOwnership: "borrows";
 };
 export interface MarkdownRenderer {
@@ -56,6 +56,7 @@ export type MarkdownViewerContext = HostContext & {
     navigation?: NavigationService;
     documentAssets?: DocumentAssetsService;
     writeback?: FileWritebackService;
+    save?: FileSaveService;
 };
 export interface MarkdownMountOptions extends MountOptions {
     limits?: ResourceLimits;

package/dist/viewers/markdown/index.js

@@ -12,7 +12,7 @@ export const MARKDOWN_VIEWER_META = {
     id: 'markdown', displayNameKey: 'markdown.title',
     extensions: ['md', 'markdown', 'mdown', 'mkdn', 'mkd'], priority: 10,
     requiredServices: [],
-    optionalServices: ['clipboard', 'navigation', 'documentAssets', 'writeback'],
+    optionalServices: ['clipboard', 'navigation', 'documentAssets', 'writeback', 'save'],
     inputOwnership: 'borrows'
 };
 const SANITIZE = {
@@ -323,22 +323,37 @@ export async function mountMarkdownViewer(input, container, ctx, deps, options =
         }
     };
     const saveSource = async () => {
-        if (!ctx.writeback) {
-            showMessage(t('common.noWriteback'));
-            setStatus('common.saveFailed', 'invalid');
+        const bytes = new TextEncoder().encode(controller.state.source);
+        if (ctx.writeback) {
+            try {
+                await ctx.writeback.write(bytes);
+                controller.dispatch({ type: 'mark-saved' });
+                setStatus('common.savedToOriginal', 'valid');
+                sourceCaption.textContent = t('common.savedToOriginal');
+            }
+            catch (error) {
+                ctx.logger.log('error', `markdown save failed: ${String(error)}`);
+                setStatus('common.saveFailed', 'invalid');
+                showMessage(errorText(error, t('common.saveFailed')));
+            }
             return;
         }
-        try {
-            await ctx.writeback.write(new TextEncoder().encode(controller.state.source));
-            controller.dispatch({ type: 'mark-saved' });
-            setStatus('common.savedToOriginal', 'valid');
-            sourceCaption.textContent = t('common.savedToOriginal');
-        }
-        catch (error) {
-            ctx.logger.log('error', `markdown save failed: ${String(error)}`);
-            setStatus('common.saveFailed', 'invalid');
-            showMessage(errorText(error, t('common.saveFailed')));
+        if (ctx.save) {
+            // Download fallback saves a copy, not the original — the dirty
+            // state is intentionally kept (no mark-saved).
+            try {
+                await ctx.save.saveFile(input.fileName, bytes, 'text/markdown');
+                setStatus('common.savedToOriginal', 'valid');
+            }
+            catch (error) {
+                ctx.logger.log('error', `markdown save failed: ${String(error)}`);
+                setStatus('common.saveFailed', 'invalid');
+                showMessage(errorText(error, t('common.saveFailed')));
+            }
+            return;
         }
+        showMessage(t('common.noWriteback'));
+        setStatus('common.saveFailed', 'invalid');
     };
     const copy = async (value, successKey) => {
         if (!ctx.clipboard)

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

@@ -1,4 +1,6 @@
-export declare const PDF_ZOOM_LEVELS: readonly [50, 75, 100, 125, 150, 200, 300];
+export declare const PDF_ZOOM_LEVELS: readonly [50, 75, 100, 125, 150, 175, 200, 225, 250, 275, 300];
+export declare const PDF_MIN_ZOOM = 25;
+export declare const PDF_MAX_ZOOM = 400;
 export type PdfZoom = number;
 export interface PdfTextAnnotation {
     id: string;
@@ -109,12 +111,22 @@ export type PdfAction = {
 };
 export interface PdfController {
     readonly state: PdfViewState;
+    /** Ordered button steps used by zoom-in/zoom-out. */
+    readonly zoomLevels: readonly number[];
+    readonly minZoom: number;
+    readonly maxZoom: number;
     dispatch(action: PdfAction): void;
     subscribe(listener: (state: PdfViewState) => void): () => void;
 }
+export interface PdfControllerOptions {
+    /** Custom button steps. Fit-to-width/height may still set an intermediate value. */
+    zoomLevels?: readonly number[];
+    minZoom?: number;
+    maxZoom?: number;
+}
 /** Persisted layer used to restore an editing session (sidecar rehydration). */
 export interface PdfControllerSeed {
     pageOrder?: readonly number[];
     annotations?: readonly PdfAnnotation[];
 }
-export declare function createPdfController(pageCount: number, seed?: PdfControllerSeed): PdfController;
+export declare function createPdfController(pageCount: number, seed?: PdfControllerSeed, options?: PdfControllerOptions): PdfController;

package/dist/viewers/pdf/controller.js

@@ -1,4 +1,8 @@
-export const PDF_ZOOM_LEVELS = [50, 75, 100, 125, 150, 200, 300];
+export const PDF_ZOOM_LEVELS = [
+    50, 75, 100, 125, 150, 175, 200, 225, 250, 275, 300
+];
+export const PDF_MIN_ZOOM = 25;
+export const PDF_MAX_ZOOM = 400;
 /**
  * PDF.js commonly returns one client rect per text span, even for a single
  * continuous selection. Join neighbouring spans on the same text line so
@@ -41,8 +45,18 @@ export function mergeHighlightRects(rects) {
         return merged;
     });
 }
-function nearestZoom(value) {
-    return PDF_ZOOM_LEVELS.reduce((best, candidate) => Math.abs(candidate - value) < Math.abs(best - value) ? candidate : best);
+function normalizedZoomOptions(options) {
+    const requestedMin = Number.isFinite(options.minZoom) ? Math.round(options.minZoom) : PDF_MIN_ZOOM;
+    const requestedMax = Number.isFinite(options.maxZoom) ? Math.round(options.maxZoom) : PDF_MAX_ZOOM;
+    const min = Math.max(1, Math.min(requestedMin, requestedMax));
+    const max = Math.max(min, Math.max(requestedMin, requestedMax));
+    const source = options.zoomLevels ?? PDF_ZOOM_LEVELS;
+    const levels = [...new Set(source
+            .filter(Number.isFinite)
+            .map((level) => Math.round(level))
+            .filter((level) => level >= min && level <= max))]
+        .sort((a, b) => a - b);
+    return { levels: levels.length > 0 ? levels : [min, max], min, max };
 }
 /** Highest `pdf-a<n>` suffix among seeded ids, so new ids never collide. */
 function maxSequence(annotations) {
@@ -59,10 +73,11 @@ function copyAnnotations(annotations) {
         ? { ...annotation, rects: annotation.rects.map((rect) => ({ ...rect })) }
         : { ...annotation });
 }
-export function createPdfController(pageCount, seed) {
+export function createPdfController(pageCount, seed, options = {}) {
     const original = Array.from({ length: Math.max(0, Math.floor(pageCount)) }, (_, i) => i + 1);
     const listeners = new Set();
-    let zoom = 100;
+    const zoomOptions = normalizedZoomOptions(options);
+    let zoom = Math.max(zoomOptions.min, Math.min(zoomOptions.max, 100));
     // A seeded order may only reference pages that still exist; an empty result
     // falls back to the natural order so the document is never left blank.
     const seededOrder = seed?.pageOrder?.filter((page) => page >= 1 && page <= original.length) ?? [];
@@ -95,6 +110,9 @@ export function createPdfController(pageCount, seed) {
     savedSignature = signature();
     return {
         get state() { return state(); },
+        zoomLevels: zoomOptions.levels,
+        minZoom: zoomOptions.min,
+        maxZoom: zoomOptions.max,
         subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
         dispatch(action) {
             if (action.type === 'undo') {
@@ -125,19 +143,19 @@ export function createPdfController(pageCount, seed) {
             const beforeSignature = tracksHistory ? signature() : undefined;
             switch (action.type) {
                 case 'zoom-in': {
-                    zoom = PDF_ZOOM_LEVELS.find((level) => level > zoom)
-                        ?? PDF_ZOOM_LEVELS[PDF_ZOOM_LEVELS.length - 1];
+                    zoom = zoomOptions.levels.find((level) => level > zoom)
+                        ?? zoomOptions.max;
                     break;
                 }
                 case 'zoom-out': {
-                    zoom = [...PDF_ZOOM_LEVELS].reverse().find((level) => level < zoom)
-                        ?? PDF_ZOOM_LEVELS[0];
+                    zoom = [...zoomOptions.levels].reverse().find((level) => level < zoom)
+                        ?? zoomOptions.min;
                     break;
                 }
                 case 'set-zoom': {
                     if (!Number.isFinite(action.zoom))
                         return;
-                    zoom = Math.max(25, Math.min(400, Math.round(action.zoom)));
+                    zoom = Math.max(zoomOptions.min, Math.min(zoomOptions.max, Math.round(action.zoom)));
                     break;
                 }
                 case 'reorder-pages': {

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

@@ -1,12 +1,73 @@
-import type { FilePickService, FileSaveService, FileWritebackService, HostContext } from '../../host/index.js';
+import type { FilePickService, FileSaveResult, FileSaveService, FileWritebackService, HostContext } from '../../host/index.js';
 import { type MountOptions, type ViewerHandle, type ViewerInput } from '../types.js';
-import { type PdfController } from './controller.js';
+import { type PdfController, type PdfControllerOptions, type PdfViewState } from './controller.js';
 import { type PdfLibModule } from './editing.js';
-export { createPdfController, PDF_ZOOM_LEVELS } from './controller.js';
-export type { PdfController, PdfAction, PdfViewState, PdfAnnotation } from './controller.js';
+export { createPdfController, PDF_MAX_ZOOM, PDF_MIN_ZOOM, PDF_ZOOM_LEVELS } from './controller.js';
+export type { PdfController, PdfControllerOptions, PdfAction, PdfViewState, PdfAnnotation } from './controller.js';
 export { pdfViewerCss } from './styles.js';
-export { buildEditedPdf, mergePdfBytes, savedPdfName } from './editing.js';
-export type { PdfLibModule } from './editing.js';
+export { buildEditedPdf, buildSavedPdf, mergePdfBytes, parseLayer, savedPdfName, SIDECAR_BASE_NAME, SIDECAR_LAYER_NAME } from './editing.js';
+export type { ParsedLayer, PdfLibModule } from './editing.js';
+/** Asset key passed to `HostContext.assets.resolveAssetUrl` by default. */
+export declare const PDF_WORKER_ASSET_KEY = "assets/pdfjs/pdf.worker.min.mjs";
+export type PdfSaveMode = 'hybrid' | 'flattened';
+export type PdfProcessingMode = 'auto' | 'host' | 'browser';
+export interface PdfToolbarAction {
+    id: string;
+    label: string;
+    title?: string;
+    ariaLabel?: string;
+    disabled?: boolean | (() => boolean);
+    onClick(): void | Promise<void>;
+}
+export interface PdfProcessingControl {
+    signal: AbortSignal;
+    onProgress(progress: number | undefined): void;
+}
+/** Optional host/Worker implementation for byte-heavy PDF operations. */
+export interface PdfProcessingService {
+    /** Request byte arrays are borrowed: implementations must not mutate or
+     * detach their buffers. A Worker adapter may copy/transfer internally. */
+    buildPdf?(request: {
+        source: Uint8Array;
+        state: PdfViewState;
+        mode: PdfSaveMode;
+    }, control: PdfProcessingControl): Promise<Uint8Array>;
+    mergePdfs?(request: {
+        first: Uint8Array;
+        second: Uint8Array;
+    }, control: PdfProcessingControl): Promise<Uint8Array>;
+}
+export type PdfOperationState = {
+    status: 'idle';
+} | {
+    status: 'running';
+    kind: 'save' | 'save-as' | 'merge';
+    progress?: number;
+} | {
+    status: 'succeeded';
+    kind: 'save' | 'save-as' | 'merge';
+} | {
+    status: 'failed';
+    kind: 'save' | 'save-as' | 'merge';
+    error: string;
+} | {
+    status: 'cancelled';
+    kind: 'save' | 'save-as' | 'merge';
+};
+export interface PdfMountOptions extends MountOptions, PdfControllerOptions {
+    /** Defaults to `hybrid` for v0.4 compatibility. */
+    saveMode?: PdfSaveMode;
+    /** `auto` delegates when a service method exists, `browser` always uses pdf-lib. */
+    processingMode?: PdfProcessingMode;
+    /** Maximum merge input requested from FilePickService. */
+    maxMergeBytes?: number;
+    toolbarActions?: readonly PdfToolbarAction[];
+    /** Safe default for VS Code CSP is false. */
+    isEvalSupported?: boolean;
+    /** Host-provided worker URL. Omit to resolve {@link PDF_WORKER_ASSET_KEY}. */
+    workerSrc?: string;
+    onSaveAsComplete?(result: FileSaveResult | void): void | Promise<void>;
+}
 /** Viewer metadata — single source for the registry codegen (DESIGN.md §7). */
 export declare const PDF_VIEWER_META: {
     id: string;
@@ -58,12 +119,13 @@ export interface PdfJsDocument {
 }
 export interface PdfJsLoadingTask {
     promise: Promise<PdfJsDocument>;
-    destroy(): void;
+    destroy(): void | Promise<void>;
 }
 export interface PdfJsModule {
     getDocument(options: {
         data: Uint8Array;
         password?: string;
+        isEvalSupported?: boolean;
     }): PdfJsLoadingTask;
     GlobalWorkerOptions: {
         workerSrc: string;
@@ -80,9 +142,18 @@ export interface PdfViewerDeps {
     /** Editing dependency (save / save-as / merge / annotation stamping).
      *  Absent -> editing controls disabled with a reason. */
     loadPdfLib?(): Promise<PdfLibModule>;
+    /** Host/extension-host/Web Worker implementation for large byte operations. */
+    processing?: PdfProcessingService;
 }
 export interface PdfViewerHandle extends ViewerHandle {
     readonly controller: PdfController;
+    readonly operation: PdfOperationState;
     isDirty(): boolean;
+    cancelOperation(): void;
+    refreshToolbarActions(): void;
 }
-export declare function mountPdfViewer(input: ViewerInput, container: HTMLElement, ctx: PdfViewerContext, deps: PdfViewerDeps, options?: MountOptions): Promise<PdfViewerHandle>;
+export declare function containPdfSignatureSize(width: number, height: number, maxWidth?: number, maxHeight?: number): {
+    width: number;
+    height: number;
+};
+export declare function mountPdfViewer(input: ViewerInput, container: HTMLElement, ctx: PdfViewerContext, deps: PdfViewerDeps, options?: PdfMountOptions): Promise<PdfViewerHandle>;