@aseity/idocs-preview 0.3.0 → 0.4.0

package/dist/core/editor.js

@@ -0,0 +1,527 @@
+import {} from './display.js';
+import { copyBytes, PreviewError, } from './protocol.js';
+import { decodeCompact, glyphOffset, glyphX } from './wire.js';
+function caretXForOffset(line, target) {
+    const glyphs = line.glyphs;
+    const count = glyphs.length;
+    if (count === 0)
+        return line.x;
+    for (let i = 0; i < count; i += 1) {
+        const gOff = glyphOffset(glyphs, i);
+        const gX = glyphX(glyphs, i);
+        if (gOff === target || (gOff > target && i === 0))
+            return gX;
+        if (gOff > target) {
+            const prevOff = glyphOffset(glyphs, i - 1);
+            const prevX = glyphX(glyphs, i - 1);
+            const span = Math.max(0, gOff - prevOff);
+            if (span === 0)
+                return gX;
+            const t = Math.max(0, target - prevOff) / span;
+            return prevX + (gX - prevX) * t;
+        }
+    }
+    return line.x + line.width;
+}
+function hitFromSegment(line, seg, xPt) {
+    const source = seg.source;
+    if (source.kind === 'atomic') {
+        return {
+            kind: 'atomic',
+            reason: source.reason,
+            ...(source.role !== undefined ? { role: source.role } : {}),
+            ...(source.before !== undefined ? { before: source.before } : {}),
+            ...(source.after !== undefined ? { after: source.after } : {}),
+        };
+    }
+    const stops = source.stops;
+    if (stops.length === 0)
+        return { kind: 'unmapped' };
+    let best = stops[0];
+    let bestX = caretXForOffset(line, best.displayOffset);
+    let bestDist = Math.abs(xPt - bestX);
+    for (let i = 1; i < stops.length; i += 1) {
+        const stop = stops[i];
+        const sx = caretXForOffset(line, stop.displayOffset);
+        const dist = Math.abs(xPt - sx);
+        const prefer = dist < bestDist - 1e-9 || (Math.abs(dist - bestDist) <= 1e-9 && xPt >= sx);
+        if (prefer) {
+            best = stop;
+            bestX = sx;
+            bestDist = dist;
+        }
+    }
+    return {
+        kind: 'editable',
+        anchor: best.anchor,
+        displayOffset: best.displayOffset,
+        x: bestX,
+    };
+}
+export function locateLineSource(line, xPt) {
+    const segments = line.sourceSegments;
+    if (!segments || segments.length === 0) {
+        if (line.occurrence?.kind === 'readOnlyStory') {
+            return { kind: 'atomic', reason: 'unsupportedStory' };
+        }
+        if (line.occurrence?.kind === 'repeatedHeader') {
+            return { kind: 'atomic', reason: 'repeatedHeader' };
+        }
+        return { kind: 'unmapped' };
+    }
+    let positive = [];
+    for (let i = 0; i < segments.length; i += 1) {
+        const seg = segments[i];
+        if (seg.start >= seg.end)
+            continue;
+        const left = caretXForOffset(line, seg.start);
+        const right = caretXForOffset(line, seg.end);
+        if (right - left > 1e-9)
+            positive.push({ idx: i, left, right });
+    }
+    if (positive.length === 0) {
+        positive = [];
+        for (let i = 0; i < segments.length; i += 1) {
+            const seg = segments[i];
+            if (seg.start < seg.end) {
+                positive.push({
+                    idx: i,
+                    left: caretXForOffset(line, seg.start),
+                    right: caretXForOffset(line, seg.end),
+                });
+            }
+        }
+    }
+    let chosenIdx;
+    if (positive.length === 0) {
+        chosenIdx = segments.length - 1;
+    }
+    else if (xPt <= positive[0].left) {
+        chosenIdx = positive[0].idx;
+    }
+    else if (xPt >= positive[positive.length - 1].right) {
+        const lastSeg = segments[segments.length - 1];
+        chosenIdx =
+            lastSeg.start === lastSeg.end && lastSeg.source.kind === 'editable'
+                ? segments.length - 1
+                : positive[positive.length - 1].idx;
+    }
+    else {
+        let editableBoundary;
+        let containing;
+        for (const item of positive) {
+            if (xPt >= item.left && xPt <= item.right) {
+                if (segments[item.idx].source.kind === 'editable') {
+                    editableBoundary = item.idx;
+                    break;
+                }
+                if (containing === undefined)
+                    containing = item.idx;
+            }
+        }
+        if (editableBoundary !== undefined) {
+            chosenIdx = editableBoundary;
+        }
+        else if (containing !== undefined) {
+            chosenIdx = containing;
+        }
+        else {
+            let bestIdx = positive[0].idx;
+            let bestDist = Infinity;
+            for (const item of positive) {
+                const dist = xPt < item.left ? item.left - xPt : Math.max(0, xPt - item.right);
+                if (dist < bestDist) {
+                    bestDist = dist;
+                    bestIdx = item.idx;
+                }
+            }
+            chosenIdx = bestIdx;
+        }
+    }
+    return hitFromSegment(line, segments[chosenIdx], xPt);
+}
+export function lineCaretX(line, anchor) {
+    const segments = line.sourceSegments;
+    if (!segments)
+        return null;
+    for (const seg of segments) {
+        if (seg.source.kind !== 'editable')
+            continue;
+        for (const stop of seg.source.stops) {
+            if (stop.anchor.session === anchor.session &&
+                stop.anchor.flow === anchor.flow &&
+                stop.anchor.offset === anchor.offset &&
+                stop.anchor.affinity === anchor.affinity) {
+                return caretXForOffset(line, stop.displayOffset);
+            }
+        }
+    }
+    for (const seg of segments) {
+        if (seg.source.kind !== 'editable')
+            continue;
+        for (const stop of seg.source.stops) {
+            if (stop.anchor.session === anchor.session &&
+                stop.anchor.flow === anchor.flow &&
+                stop.anchor.offset === anchor.offset &&
+                stop.anchor.affinity === 'downstream' &&
+                !(anchor.affinity === 'upstream' && line.index > 0 && stop.displayOffset === 0)) {
+                return caretXForOffset(line, stop.displayOffset);
+            }
+        }
+    }
+    return null;
+}
+const textEncoder = new TextEncoder();
+function toSourceBytes(source) {
+    return typeof source === 'string' ? textEncoder.encode(source) : copyBytes(source);
+}
+async function readAnswer(read, name) {
+    if (!read)
+        return null;
+    try {
+        const bytes = await read(name);
+        return bytes ? copyBytes(bytes) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function openEditorWith(worker, options) {
+    const post = (message, transfer = []) => worker.postMessage(message, transfer);
+    const jobs = new Map();
+    const listeners = new Set();
+    const editorId = 1;
+    let nextId = 1;
+    let disposed = false;
+    let broken;
+    let chain = Promise.resolve();
+    let pendingMutations = 0;
+    let lastReadyFrame = null;
+    let currentState = {
+        revision: '0',
+        dirty: false,
+        selection: null,
+        canUndo: false,
+        canRedo: false,
+        layout: { kind: 'pending', previous: null },
+    };
+    let renderScheduled = false;
+    let renderInFlight = false;
+    let renderRequestedAgain = false;
+    let renderTimer;
+    const notify = () => {
+        if (disposed)
+            return;
+        const snap = currentState;
+        for (const listener of listeners)
+            listener(snap);
+    };
+    const send = (message, transfer = []) => {
+        if (disposed)
+            return Promise.reject(new Error('The editor session is disposed'));
+        if (broken)
+            return Promise.reject(broken);
+        if (!('id' in message)) {
+            post(message, transfer);
+            return Promise.reject(new Error('Invalid request id'));
+        }
+        const id = message.id;
+        return new Promise((resolve, reject) => {
+            jobs.set(id, { resolve, reject });
+            post(message, transfer);
+        });
+    };
+    const enqueue = (task, mutates = false) => {
+        if (mutates)
+            pendingMutations += 1;
+        const run = chain
+            .then(() => {
+            if (disposed)
+                throw new Error('The editor session is disposed');
+            if (broken)
+                throw broken;
+            return task();
+        })
+            .finally(() => {
+            if (mutates) {
+                pendingMutations -= 1;
+                if (pendingMutations === 0 && (renderRequestedAgain || (currentState.layout.kind === 'pending' && !renderScheduled && !renderInFlight))) {
+                    scheduleRender();
+                }
+            }
+        });
+        chain = run.catch(() => { });
+        return run;
+    };
+    const expectJson = async (message, transfer = []) => {
+        const reply = await send(message, transfer);
+        if (reply.type !== 'editorJson') {
+            throw new PreviewError({ code: 'internal-error', message: 'Unexpected worker response', diagnostics: [] });
+        }
+        return JSON.parse(reply.json);
+    };
+    const requestRender = async () => {
+        const reply = await send({ type: 'editorRender', id: nextId++, editorId });
+        if (reply.type !== 'editorRendered') {
+            throw new PreviewError({ code: 'internal-error', message: 'Unexpected worker response', diagnostics: [] });
+        }
+        const document = decodeCompact(reply.json, reply.data, reply.images);
+        const meta = JSON.parse(reply.metaJson);
+        return {
+            frame: { revision: meta.revision, document, stats: meta.stats },
+            meta,
+        };
+    };
+    const runRenderLoop = async () => {
+        if (disposed || broken || renderInFlight)
+            return;
+        renderInFlight = true;
+        try {
+            while (!disposed && !broken) {
+                if (pendingMutations > 0) {
+                    renderRequestedAgain = true;
+                    break;
+                }
+                renderRequestedAgain = false;
+                const targetRevision = currentState.revision;
+                try {
+                    const rendered = await requestRender();
+                    if (disposed)
+                        return;
+                    lastReadyFrame = rendered.frame;
+                    if (rendered.meta.revision === currentState.revision && !renderRequestedAgain && pendingMutations === 0) {
+                        currentState = {
+                            ...currentState,
+                            dirty: rendered.meta.dirty,
+                            canUndo: rendered.meta.canUndo,
+                            canRedo: rendered.meta.canRedo,
+                            layout: { kind: 'ready', frame: rendered.frame },
+                        };
+                        notify();
+                        break;
+                    }
+                    renderRequestedAgain = true;
+                }
+                catch (error) {
+                    if (disposed)
+                        return;
+                    const message = error instanceof Error ? error.message : String(error);
+                    const diagnostics = error instanceof PreviewError ? error.diagnostics : [];
+                    currentState = {
+                        ...currentState,
+                        layout: {
+                            kind: 'failed',
+                            revision: targetRevision,
+                            message,
+                            diagnostics,
+                            previous: lastReadyFrame,
+                        },
+                    };
+                    notify();
+                    if (!renderRequestedAgain)
+                        break;
+                }
+            }
+        }
+        finally {
+            renderInFlight = false;
+            if (renderRequestedAgain && pendingMutations === 0) {
+                scheduleRender();
+            }
+        }
+    };
+    const scheduleRender = () => {
+        if (disposed || broken)
+            return;
+        if (renderInFlight) {
+            renderRequestedAgain = true;
+            return;
+        }
+        if (!renderScheduled) {
+            renderScheduled = true;
+            renderTimer = setTimeout(() => {
+                renderTimer = undefined;
+                renderScheduled = false;
+                if (disposed || broken)
+                    return;
+                if (pendingMutations === 0) {
+                    void runRenderLoop();
+                }
+                else {
+                    renderRequestedAgain = true;
+                }
+            }, 0);
+        }
+    };
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        if (renderTimer !== undefined) {
+            clearTimeout(renderTimer);
+            renderTimer = undefined;
+        }
+        try {
+            post({ type: 'editorDispose', editorId });
+        }
+        catch {
+        }
+        worker.terminate?.();
+        for (const job of jobs.values())
+            job.reject(new Error('The editor session is disposed'));
+        jobs.clear();
+        listeners.clear();
+    };
+    worker.addEventListener('message', async (event) => {
+        const message = event.data;
+        const job = jobs.get(message.id);
+        if (!job)
+            return;
+        if (message.type === 'needs') {
+            const answers = await Promise.all(message.needs.map(async (need) => ({
+                need,
+                bytes: await readAnswer(options.readResource, need.name),
+            })));
+            if (disposed)
+                return;
+            post({ type: 'resources', id: message.id, answers }, answers.flatMap((a) => (a.bytes ? [a.bytes.buffer] : [])));
+            return;
+        }
+        jobs.delete(message.id);
+        if (message.type === 'failed') {
+            job.reject(new PreviewError(message.error));
+            return;
+        }
+        job.resolve(message);
+    });
+    const onWorkerFail = (event) => {
+        if (disposed || broken)
+            return;
+        const detail = event.message;
+        broken = new PreviewError({
+            code: 'worker-unavailable',
+            message: `The preview worker failed (${event.type}${detail ? `: ${detail}` : ''})`,
+            diagnostics: [],
+        });
+        worker.terminate?.();
+        for (const job of jobs.values())
+            job.reject(broken);
+        jobs.clear();
+    };
+    worker.addEventListener('error', onWorkerFail);
+    worker.addEventListener('messageerror', onWorkerFail);
+    worker.start?.();
+    post({ type: 'init', wasmUrl: options.runtime?.wasmUrl?.toString() });
+    try {
+        const bytes = toSourceBytes(options.source);
+        const openMeta = await expectJson({
+            type: 'editorOpen',
+            id: nextId++,
+            editorId,
+            name: options.name ?? 'document.idoc',
+            bytes,
+        }, [bytes.buffer]);
+        currentState = {
+            revision: openMeta.revision,
+            dirty: openMeta.dirty,
+            selection: null,
+            canUndo: openMeta.canUndo,
+            canRedo: openMeta.canRedo,
+            layout: { kind: 'pending', previous: null },
+        };
+        const rendered = await requestRender();
+        lastReadyFrame = rendered.frame;
+        currentState = {
+            revision: rendered.meta.revision,
+            dirty: rendered.meta.dirty,
+            selection: null,
+            canUndo: rendered.meta.canUndo,
+            canRedo: rendered.meta.canRedo,
+            layout: { kind: 'ready', frame: rendered.frame },
+        };
+    }
+    catch (error) {
+        dispose();
+        throw error;
+    }
+    const applyCommit = (res) => {
+        currentState = {
+            revision: res.commit.revision,
+            dirty: res.dirty,
+            selection: res.commit.selection,
+            canUndo: res.canUndo,
+            canRedo: res.canRedo,
+            layout: { kind: 'pending', previous: lastReadyFrame },
+        };
+        notify();
+        scheduleRender();
+        return res.commit;
+    };
+    return {
+        state: () => currentState,
+        subscribe(listener) {
+            if (disposed)
+                return () => { };
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        range({ revision, start, end }) {
+            return enqueue(() => expectJson({
+                type: 'editorRange',
+                id: nextId++,
+                editorId,
+                revision,
+                startJson: JSON.stringify(start),
+                endJson: JSON.stringify(end),
+            }));
+        },
+        apply({ base, edit }) {
+            return enqueue(async () => applyCommit(await expectJson({
+                type: 'editorApply',
+                id: nextId++,
+                editorId,
+                base,
+                editJson: JSON.stringify(edit),
+            })), true);
+        },
+        undo({ base }) {
+            return enqueue(async () => applyCommit(await expectJson({ type: 'editorUndo', id: nextId++, editorId, base })), true);
+        },
+        redo({ base }) {
+            return enqueue(async () => applyCommit(await expectJson({ type: 'editorRedo', id: nextId++, editorId, base })), true);
+        },
+        snapshot() {
+            return enqueue(() => expectJson({ type: 'editorSnapshot', id: nextId++, editorId }));
+        },
+        markSaved({ revision }) {
+            return enqueue(async () => {
+                const res = await expectJson({
+                    type: 'editorMarkSaved',
+                    id: nextId++,
+                    editorId,
+                    revision,
+                });
+                currentState = { ...currentState, dirty: res.dirty };
+                notify();
+            });
+        },
+        refresh({ base, source }) {
+            return enqueue(async () => {
+                const bytes = toSourceBytes(source);
+                return applyCommit(await expectJson({ type: 'editorRefresh', id: nextId++, editorId, base, bytes }, [bytes.buffer]));
+            }, true);
+        },
+        exportDocx() {
+            return enqueue(async () => {
+                const reply = await send({ type: 'editorExportDocx', id: nextId++, editorId });
+                if (reply.type !== 'exported') {
+                    throw new PreviewError({ code: 'internal-error', message: 'Unexpected worker response', diagnostics: [] });
+                }
+                return reply.bytes;
+            });
+        },
+        dispose,
+    };
+}