@aseity/idocs-preview 0.3.0 → 0.4.0

package/dist/core/engine.js

@@ -1,15 +1,12 @@
-// The Worker side: owns the wasm instance and answers the protocol in
-// protocol.ts. `serve` takes any message endpoint, so Node tests run the same
-// code behind a MessageChannel. Layout is synchronous inside one wasm call;
-// resources the host has not answered yet come back as `needs`, and the open
-// is retried once they arrive.
-import init, { exportDocx, openDocument } from '../../wasm/idocs_wasm.js';
+import init, { exportDocx, openDocument, WasmEditorSession } from '../../wasm/idocs_wasm.js';
 import { canvasMeasure } from './fonts.js';
+const textDecoder = new TextDecoder();
 export function serve(endpoint, options = {}) {
     let ready;
     const start = (wasm = options.wasm) => (ready ??= init(wasm === undefined ? undefined : { module_or_path: wasm }));
     const measure = options.measure === undefined ? canvasMeasure() : (options.measure ?? undefined);
     const pending = new Map();
+    const editors = new Map();
     const post = (message, transfer = []) => endpoint.postMessage(message, transfer);
     const attempt = (id) => {
         const job = pending.get(id);
@@ -19,17 +16,7 @@ export function serve(endpoint, options = {}) {
         try {
             if (!measure)
                 throw new Error('Browser font measurement requires OffscreenCanvas 2D');
-            if (job.type === 'exportDocx') {
-                outcome = exportDocx(job.bytes, job.name, job.assets, measure);
-            }
-            else {
-                if (job.progressive)
-                    post({ type: 'pageReset', id });
-                const onPage = job.progressive ? (packet) => {
-                    post({ type: 'page', id, ...packet }, [packet.data.buffer, ...packet.images.map(bytes => bytes.buffer)]);
-                } : undefined;
-                outcome = openDocument(job.kind, job.bytes, job.name, job.assets, measure, onPage);
-            }
+            outcome = job.run(measure);
         }
         catch (error) {
             pending.delete(id);
@@ -49,15 +36,79 @@ export function serve(endpoint, options = {}) {
             post({ type: 'exported', id, bytes: outcome.bytes }, [outcome.bytes.buffer]);
             return;
         }
-        post({ type: 'opened', id, json: outcome.json, images: outcome.images, data: outcome.data }, [outcome.data.buffer, ...outcome.images.map((bytes) => bytes.buffer)]);
+        if (job.kind === 'editorJson') {
+            post({ type: 'editorJson', id, json: outcome.json });
+            return;
+        }
+        const transfers = [
+            outcome.data.buffer,
+            ...outcome.images.map((bytes) => bytes.buffer),
+        ];
+        if (job.kind === 'editorRendered') {
+            post({
+                type: 'editorRendered',
+                id,
+                json: outcome.json,
+                images: outcome.images,
+                data: outcome.data,
+                metaJson: outcome.metaJson ?? '{}',
+            }, transfers);
+            return;
+        }
+        post({ type: 'opened', id, json: outcome.json, images: outcome.images, data: outcome.data }, transfers);
+    };
+    const enqueueOpen = (message) => {
+        const assets = new Map();
+        const progressive = message.progressive ?? false;
+        pending.set(message.id, {
+            kind: 'open',
+            assets,
+            run: (activeMeasure) => {
+                if (progressive)
+                    post({ type: 'pageReset', id: message.id });
+                const onPage = progressive
+                    ? (packet) => {
+                        post({ type: 'page', id: message.id, ...packet }, [packet.data.buffer, ...packet.images.map((b) => b.buffer)]);
+                    }
+                    : undefined;
+                return openDocument(message.kind, message.bytes, message.name, assets, activeMeasure, onPage);
+            },
+        });
+    };
+    const enqueueEditorCall = (id, editorId, kind, exec) => {
+        const existing = editors.get(editorId);
+        if (!existing) {
+            pending.set(id, {
+                kind,
+                assets: new Map(),
+                run: () => ({
+                    status: 'failed',
+                    json: JSON.stringify({ code: 'session-closed', message: 'The editor session is closed', diagnostics: [] }),
+                }),
+            });
+            return;
+        }
+        pending.set(id, {
+            kind,
+            assets: existing.assets,
+            run: (activeMeasure) => exec(existing, activeMeasure),
+        });
     };
     endpoint.addEventListener('message', async (event) => {
         const message = event.data;
         if (message.type === 'init') {
-            // Start fetching early; a failure is reported to the first open.
             start(message.wasmUrl).catch(() => { });
             return;
         }
+        if (message.type === 'editorDispose') {
+            const existing = editors.get(message.editorId);
+            if (existing) {
+                existing.session.dispose();
+                existing.session.free?.();
+                editors.delete(message.editorId);
+            }
+            return;
+        }
         try {
             await start();
         }
@@ -67,26 +118,69 @@ export function serve(endpoint, options = {}) {
             post({ type: 'failed', id, error: { code: 'wasm-unavailable', message: String(error), diagnostics: [] } });
             return;
         }
-        if (message.type === 'exportDocx') {
-            pending.set(message.id, { type: 'exportDocx', name: message.name, bytes: message.bytes, assets: new Map() });
-        }
-        else if (message.type === 'open') {
-            pending.set(message.id, {
-                type: 'open',
-                kind: message.kind,
-                progressive: message.progressive ?? false,
-                name: message.name,
-                bytes: message.bytes,
-                assets: new Map(),
-            });
-        }
-        else if (message.type === 'resources') {
-            const job = pending.get(message.id);
-            if (!job)
-                return;
-            for (const { need, bytes } of message.answers) {
-                job.assets.set(need.name, bytes);
+        switch (message.type) {
+            case 'exportDocx': {
+                const assets = new Map();
+                pending.set(message.id, {
+                    kind: 'exportDocx',
+                    assets,
+                    run: (activeMeasure) => exportDocx(message.bytes, message.name, assets, activeMeasure),
+                });
+                break;
+            }
+            case 'open':
+                enqueueOpen(message);
+                break;
+            case 'resources': {
+                const job = pending.get(message.id);
+                if (!job)
+                    return;
+                for (const { need, bytes } of message.answers) {
+                    job.assets.set(need.name, bytes);
+                }
+                break;
+            }
+            case 'editorOpen': {
+                const session = new WasmEditorSession();
+                const assets = new Map();
+                editors.set(message.editorId, { session, assets });
+                const source = textDecoder.decode(message.bytes);
+                pending.set(message.id, {
+                    kind: 'editorJson',
+                    assets,
+                    run: (activeMeasure) => session.open(source, message.name, assets, activeMeasure),
+                });
+                break;
+            }
+            case 'editorRange':
+                enqueueEditorCall(message.id, message.editorId, 'editorJson', ({ session }) => session.range(message.revision, message.startJson, message.endJson));
+                break;
+            case 'editorApply':
+                enqueueEditorCall(message.id, message.editorId, 'editorJson', ({ session, assets }, m) => session.apply(message.base, message.editJson, assets, m));
+                break;
+            case 'editorUndo':
+                enqueueEditorCall(message.id, message.editorId, 'editorJson', ({ session, assets }, m) => session.undo(message.base, assets, m));
+                break;
+            case 'editorRedo':
+                enqueueEditorCall(message.id, message.editorId, 'editorJson', ({ session, assets }, m) => session.redo(message.base, assets, m));
+                break;
+            case 'editorRefresh': {
+                const source = textDecoder.decode(message.bytes);
+                enqueueEditorCall(message.id, message.editorId, 'editorJson', ({ session, assets }, m) => session.refresh(message.base, source, assets, m));
+                break;
             }
+            case 'editorMarkSaved':
+                enqueueEditorCall(message.id, message.editorId, 'editorJson', ({ session }) => session.markSaved(message.revision));
+                break;
+            case 'editorSnapshot':
+                enqueueEditorCall(message.id, message.editorId, 'editorJson', ({ session }) => session.snapshot());
+                break;
+            case 'editorRender':
+                enqueueEditorCall(message.id, message.editorId, 'editorRendered', ({ session, assets }, m) => session.render(assets, m));
+                break;
+            case 'editorExportDocx':
+                enqueueEditorCall(message.id, message.editorId, 'editorExport', ({ session, assets }, m) => session.exportDocx(assets, m));
+                break;
         }
         attempt(message.id);
     });

package/dist/core/index.d.ts

@@ -1,16 +1,11 @@
-import type { DocumentKind, Endpoint, PreviewDocument, PreviewPage } from './protocol.js';
+import { type OpenEditorOptions, type EditorSession, lineCaretX, locateLineSource } from './editor.js';
+import { type DocumentKind, type PreviewDocument, type PreviewPage, type Read, type SessionOptions } from './protocol.js';
 export type * from './display.js';
 export type * from './protocol.js';
-export interface SessionOptions {
-    /** Worker script address; defaults to the bundled worker beside this module. */
-    workerUrl?: string | URL;
-    /** `.wasm` address; defaults to the file next to the wasm glue. */
-    wasmUrl?: string | URL;
-    /** An already created worker (a MessagePort works too); `workerUrl` is then ignored. */
-    worker?: Endpoint;
-}
+export { PreviewError, type Read, type SessionOptions, } from './protocol.js';
+export type { Commit, Edit, EditRange, EditorFrame, EditorSession, EditorState, ImageAlign, InsertBlock, LayoutState, LineHit, Mark, OpenEditorOptions, RenderStats, Selection, SourceSnapshot, TableAction, } from './editor.js';
+export { lineCaretX, locateLineSource };
 type Bytes = Uint8Array | ArrayBuffer;
-export type Read = (name: string) => Bytes | null | undefined | Promise<Bytes | null | undefined>;
 export interface OpenOptions {
     /** Receive provisional pages while the worker builds the remaining display list. */
     onPage?: (page: PreviewPage) => void;
@@ -25,15 +20,6 @@ export interface OpenOptions {
     /** Reads a path relative to the source document (images). Throw or return null when absent. */
     readResource?: Read;
 }
-export declare class PreviewError extends Error {
-    code: string;
-    diagnostics: PreviewDocument['diagnostics'];
-    constructor(error: {
-        code: string;
-        message: string;
-        diagnostics: PreviewDocument['diagnostics'];
-    });
-}
 export type ExportOptions = Pick<OpenOptions, 'name' | 'readResource'>;
 export interface Session {
     exportDocx(bytes: Bytes, options?: ExportOptions): Promise<Uint8Array>;
@@ -45,5 +31,6 @@ export interface Session {
      */
     dispose(): void;
 }
+export declare function openEditor(options: OpenEditorOptions): Promise<EditorSession>;
 export declare function createSession(options?: SessionOptions): Session;
 export type { Measure } from './fonts.js';

package/dist/core/index.js

@@ -1,14 +1,8 @@
+import { openEditorWith, lineCaretX, locateLineSource, } from './editor.js';
+import { copyBytes, PreviewError, } from './protocol.js';
 import { decodeCompact } from './wire.js';
-export class PreviewError extends Error {
-    code;
-    diagnostics;
-    constructor(error) {
-        super(error.message);
-        this.name = 'PreviewError';
-        this.code = error.code;
-        this.diagnostics = error.diagnostics;
-    }
-}
+export { PreviewError, } from './protocol.js';
+export { lineCaretX, locateLineSource };
 function isZip(bytes) {
     return bytes[0] === 0x50 && bytes[1] === 0x4b;
 }
@@ -18,18 +12,20 @@ function isWordFile(bytes, name) {
         OLE_MAGIC.every((byte, i) => bytes[i] === byte) ||
         /\.(docx|docm|dotx|dotm|doc)$/i.test(name ?? ''));
 }
-/** A private copy whose buffer can be transferred (a Node Buffer may share its pool). */
-function copyBytes(bytes) {
-    return new Uint8Array(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes));
-}
-export function createSession(options = {}) {
-    const worker = options.worker ??
+function createWorker(options = {}) {
+    return (options.worker ??
         (options.workerUrl
             ? new Worker(options.workerUrl, { type: 'module' })
             : // Literally `new Worker(new URL(...), ...)`: the form bundlers
                 // (Turbopack, webpack, Vite) recognize to bundle the worker with its
                 // imports. Behind `??` they copy the file as a bare asset instead.
-                new Worker(new URL('./worker.js', import.meta.url), { type: 'module' }));
+                new Worker(new URL('./worker.js', import.meta.url), { type: 'module' })));
+}
+export function openEditor(options) {
+    return openEditorWith(createWorker(options.runtime), options);
+}
+export function createSession(options = {}) {
+    const worker = createWorker(options);
     const post = (message, transfer = []) => worker.postMessage(message, transfer);
     const jobs = new Map();
     let next = 1;

package/dist/core/protocol.d.ts

@@ -76,6 +76,27 @@ export interface PreviewDocument {
     /** For `.idoc`: what export to DOCX would lose. For DOCX: what DOCX conversion lost. */
     conversionLosses: ConversionLoss[];
 }
+export type PreviewDiagnostic = Diagnostic;
+export interface SessionOptions {
+    /** Worker script address; defaults to the bundled worker beside this module. */
+    workerUrl?: string | URL;
+    /** `.wasm` address; defaults to the file next to the wasm glue. */
+    wasmUrl?: string | URL;
+    /** An already created worker (a MessagePort works too); `workerUrl` is then ignored. */
+    worker?: Endpoint;
+}
+export type Bytes = Uint8Array | ArrayBuffer;
+export type Read = (name: string) => Bytes | null | undefined | Promise<Bytes | null | undefined>;
+export declare class PreviewError extends Error {
+    code: string;
+    diagnostics: Diagnostic[];
+    constructor(error: {
+        code: string;
+        message: string;
+        diagnostics: Diagnostic[];
+    });
+}
+export declare function copyBytes(bytes: Bytes): Uint8Array;
 /** A lookup core made that the host has not answered yet. */
 export type ResourceNeed = {
     kind: 'asset';
@@ -105,6 +126,61 @@ export type ToWorker = {
         need: ResourceNeed;
         bytes: Uint8Array | null;
     }[];
+} | {
+    type: 'editorOpen';
+    id: number;
+    editorId: number;
+    name: string;
+    bytes: Uint8Array;
+} | {
+    type: 'editorRange';
+    id: number;
+    editorId: number;
+    revision: string;
+    startJson: string;
+    endJson: string;
+} | {
+    type: 'editorApply';
+    id: number;
+    editorId: number;
+    base: string;
+    editJson: string;
+} | {
+    type: 'editorUndo';
+    id: number;
+    editorId: number;
+    base: string;
+} | {
+    type: 'editorRedo';
+    id: number;
+    editorId: number;
+    base: string;
+} | {
+    type: 'editorRefresh';
+    id: number;
+    editorId: number;
+    base: string;
+    bytes: Uint8Array;
+} | {
+    type: 'editorMarkSaved';
+    id: number;
+    editorId: number;
+    revision: string;
+} | {
+    type: 'editorSnapshot';
+    id: number;
+    editorId: number;
+} | {
+    type: 'editorRender';
+    id: number;
+    editorId: number;
+} | {
+    type: 'editorExportDocx';
+    id: number;
+    editorId: number;
+} | {
+    type: 'editorDispose';
+    editorId: number;
 };
 export interface PreviewPage {
     page: DisplayPage;
@@ -135,6 +211,17 @@ export type FromWorker = {
     json: string;
     images: Uint8Array[];
     data: Uint8Array;
+} | {
+    type: 'editorJson';
+    id: number;
+    json: string;
+} | {
+    type: 'editorRendered';
+    id: number;
+    json: string;
+    images: Uint8Array[];
+    data: Uint8Array;
+    metaJson: string;
 } | {
     type: 'failed';
     id: number;

package/dist/core/protocol.js

@@ -1 +1,13 @@
-export {};
+export class PreviewError extends Error {
+    code;
+    diagnostics;
+    constructor(error) {
+        super(error.message);
+        this.name = 'PreviewError';
+        this.code = error.code;
+        this.diagnostics = error.diagnostics;
+    }
+}
+export function copyBytes(bytes) {
+    return new Uint8Array(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes));
+}

package/dist/view/edit-selection.d.ts

@@ -0,0 +1,80 @@
+import { type Anchor, type DisplayPage, type EditRange, type FlowId, type GeneratedRole, type ReadOnlyReason } from '../core/index.js';
+import { type HighlightBox, type PagePoint } from './selection.js';
+export interface CaretBox {
+    readonly page: number;
+    readonly x: number;
+    readonly top: number;
+    readonly bottom: number;
+    readonly baseline: number;
+    readonly height: number;
+    readonly turn?: [number, number];
+}
+export interface ReadOnlyTarget {
+    readonly page: number;
+    readonly path: string;
+    readonly reason: ReadOnlyReason;
+    readonly role?: GeneratedRole;
+    readonly box: HighlightBox;
+    readonly before?: Anchor;
+    readonly after?: Anchor;
+}
+export type EditPointHit = {
+    kind: 'editable';
+    anchor: Anchor;
+    caret: CaretBox;
+    page: number;
+    path: string;
+} | {
+    kind: 'readOnly';
+    target: ReadOnlyTarget;
+} | {
+    kind: 'empty';
+};
+export declare class EditDocumentIndex {
+    #private;
+    constructor(pages: readonly DisplayPage[]);
+    flowPath(flow: FlowId): string | undefined;
+    firstFlow(): FlowId | undefined;
+    flowBounds(flow: FlowId): {
+        start: Anchor;
+        end: Anchor;
+    } | undefined;
+    locatePoint(point: PagePoint): EditPointHit;
+    locatePointInFlow(flow: FlowId, point: PagePoint): Anchor | undefined;
+    wordRangeInFlow(flow: FlowId, point: PagePoint): {
+        start: Anchor;
+        end: Anchor;
+    } | undefined;
+    selectionPageBounds(range: EditRange): {
+        page: number;
+        bounds: {
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+        };
+    } | undefined;
+    caretForAnchor(anchor: Anchor): CaretBox | undefined;
+    highlightsForRange(range: EditRange, page: number): HighlightBox[];
+    selectedText(range: EditRange): string;
+    neighborStop(anchor: Anchor, direction: 'backward' | 'forward'): Anchor | undefined;
+    moveHorizontal(anchor: Anchor, direction: 'backward' | 'forward', granularity?: 'character' | 'word'): Anchor;
+    moveVertical(anchor: Anchor, direction: 'up' | 'down', preferredX?: number): {
+        anchor: Anchor;
+        preferredX: number;
+    };
+    moveLineBoundary(anchor: Anchor, edge: 'start' | 'end'): Anchor;
+    wordRangeAt(point: PagePoint): {
+        start: Anchor;
+        end: Anchor;
+    } | undefined;
+    flowRangeAt(point: PagePoint): {
+        start: Anchor;
+        end: Anchor;
+    } | undefined;
+}
+export declare function orderedAnchors(a: Anchor, b: Anchor): {
+    start: Anchor;
+    end: Anchor;
+    reversed: boolean;
+};