web-doc 0.6.2 → 0.8.0

package/dist/edit/docx/session.js

@@ -0,0 +1,467 @@
+import { readDescription, readOutline } from "../ai/outline.js";
+import { resolveTargets } from "../ai/targets.js";
+import { buildToolSet, callTool as runTool } from "../ai/tools.js";
+import { ViewerError } from "../../errors.js";
+export class DocxSession {
+    format = "docx";
+    #core;
+    #tools;
+    #access;
+    constructor(core, access) {
+        this.#core = core;
+        this.#access = access;
+    }
+    get sessionId() {
+        return this.#core.sessionId;
+    }
+    get state() {
+        return this.#core.state;
+    }
+    get schemas() {
+        return this.#core.schemas;
+    }
+    apply(operations, options) {
+        return this.#core.apply(operations, options);
+    }
+    applyJson(operations, options) {
+        return this.#core.applyJson(operations, options);
+    }
+    undo(options) {
+        return this.#core.undo(options);
+    }
+    redo(options) {
+        return this.#core.redo(options);
+    }
+    reset(options) {
+        return this.#core.reset(options);
+    }
+    save(options) {
+        return this.#core.save(options);
+    }
+    markSaved(stateToken) {
+        this.#core.markSaved(stateToken);
+    }
+    addAsset(data, options) {
+        return this.#core.addAsset(data, options);
+    }
+    getElements(query = {}, options) {
+        return this.#core.readItems(options, async (engine, signal) => {
+            const elements = (await engine.getElements({}, signal));
+            const pages = query.pageIndex === undefined
+                ? this.#access.cachedPages()
+                : [query.pageIndex];
+            const placement = await this.#placement(pages, signal);
+            return placeElements(elements, placement).filter((element) => matchesQuery(element, query));
+        });
+    }
+    getElement(id, options) {
+        return this.#core.readItem(options, async (engine, signal) => {
+            // A table is placed through its cell paragraphs, so every element is
+            // read and the one asked for picked out of the joined list.
+            const elements = (await engine.getElements({}, signal));
+            if (!elements.some((element) => element.id === id))
+                return undefined;
+            const placement = await this.#placement(this.#access.cachedPages(), signal);
+            return placeElements(elements, placement).find((element) => element.id === id);
+        });
+    }
+    elementsAt(pageIndex, point, options) {
+        return this.#core.readItems(options, async (engine, signal) => {
+            const runs = await this.#access.getTextRuns(pageIndex, signal);
+            const hit = new Set();
+            for (const run of runs)
+                if (run.paragraphId && rectContains(runRect(run), point))
+                    hit.add(`p:${run.paragraphId}`);
+            if (hit.size === 0)
+                return [];
+            const elements = (await engine.getElements({}, signal));
+            const placed = placeElements(elements, await this.#placement([pageIndex], signal));
+            const paragraphs = placed.filter((element) => hit.has(element.id));
+            const tables = new Set(paragraphs
+                .map((element) => element.parentId)
+                .filter((id) => id !== undefined));
+            return [
+                ...paragraphs,
+                ...placed.filter((element) => tables.has(element.id)),
+            ];
+        });
+    }
+    async findText(query, options = {}) {
+        // A page range bounds the matches by where they are placed, which
+        // only the geometry knows: the engine then searches without a limit
+        // and the limit applies to the matches on those pages.
+        const { pageRange } = options;
+        const engineOptions = { ...options };
+        if (pageRange)
+            delete engineOptions.maxResults;
+        const found = await this.#core.findText(query, engineOptions);
+        const placed = await this.#placeTargets(found.items, options);
+        const items = pageRange
+            ? placed
+                .filter((target) => target.pageIndex >= pageRange[0] &&
+                target.pageIndex <= pageRange[1])
+                .slice(0, options.maxResults ?? placed.length)
+            : placed;
+        return Object.freeze({ ...found, items });
+    }
+    getOutline(options) {
+        return readOutline(this, this.#core.limits, options);
+    }
+    describe(options) {
+        return readDescription(this, this.#core.limits, options);
+    }
+    resolveTargets(query, options) {
+        return resolveTargets(this, query, options);
+    }
+    createCheckpoint(label) {
+        return this.#core.createCheckpoint(label);
+    }
+    listCheckpoints() {
+        return this.#core.listCheckpoints();
+    }
+    restoreCheckpoint(id, options) {
+        return this.#core.restoreCheckpoint(id, options);
+    }
+    dropCheckpoint(id) {
+        this.#core.dropCheckpoint(id);
+    }
+    get tools() {
+        return (this.#tools ??= buildToolSet(this.format, this.schemas));
+    }
+    callTool(call, options) {
+        return runTool(this, this.tools, call, options);
+    }
+    getRevisions(elementId, options) {
+        return this.#core.readItems(options, (engine, signal) => docxReads(engine).revisions(elementId, signal));
+    }
+    replaceText(fields, options) {
+        return this.apply([{ op: "replaceText", ...fields }], options);
+    }
+    setTextStyle(fields, options) {
+        return this.apply([{ op: "setTextStyle", ...fields }], options);
+    }
+    setParagraphStyle(fields, options) {
+        return this.apply([{ op: "setParagraphStyle", ...fields }], options);
+    }
+    insertParagraph(fields, options) {
+        return this.apply([{ op: "insertParagraph", ...fields }], options);
+    }
+    deleteElement(fields, options) {
+        return this.apply([{ op: "deleteElement", ...fields }], options);
+    }
+    moveElement(fields, options) {
+        return this.apply([{ op: "moveElement", ...fields }], options);
+    }
+    insertTable(fields, options) {
+        return this.apply([{ op: "insertTable", ...fields }], options);
+    }
+    setTableCell(fields, options) {
+        return this.apply([{ op: "setTableCell", ...fields }], options);
+    }
+    insertImage(fields, options) {
+        return this.apply([{ op: "insertImage", ...fields }], options);
+    }
+    /** The union of every paragraph's runs on the given pages. */
+    async #placement(pages, signal) {
+        const placement = new Map();
+        for (const pageIndex of [...new Set(pages)].sort((a, b) => a - b)) {
+            const runs = await this.#access.getTextRuns(pageIndex, signal);
+            for (const run of runs) {
+                if (!run.paragraphId)
+                    continue;
+                let pages = placement.get(run.paragraphId);
+                if (!pages) {
+                    pages = new Map();
+                    placement.set(run.paragraphId, pages);
+                }
+                const current = pages.get(pageIndex);
+                pages.set(pageIndex, current ? union(current, runRect(run)) : runRect(run));
+            }
+        }
+        return placement;
+    }
+    /**
+     * Rectangles and pages for text matches: the runs of the match's
+     * paragraph on the page that holds it, cut to the matched characters
+     * when the run text can be aligned with the paragraph text, else the
+     * paragraph's runs on its first page. Pages are read from the viewer's
+     * cache first, then from the requested range, then in order.
+     */
+    async #placeTargets(targets, options) {
+        if (targets.length === 0)
+            return targets;
+        const signal = options.signal;
+        const runsByPage = new Map();
+        const load = async (pageIndex) => {
+            let runs = runsByPage.get(pageIndex);
+            if (!runs) {
+                runs = await this.#access.getTextRuns(pageIndex, signal);
+                runsByPage.set(pageIndex, runs);
+            }
+            return runs;
+        };
+        const pageCount = this.#core.state.pageCount;
+        const cached = this.#access.cachedPages();
+        const scan = options.pageRange
+            ? range(options.pageRange[0], options.pageRange[1], pageCount)
+            : range(0, pageCount - 1, pageCount);
+        /** Pages that hold runs of a paragraph, found so far. */
+        const pagesOf = new Map();
+        const holds = async (pageIndex, paragraphId) => (await load(pageIndex)).some((run) => run.paragraphId === paragraphId);
+        // A paragraph's pages are contiguous: the first page found to hold
+        // it, among the cached pages and then the scanned ones, is grown
+        // in both directions until a page without it.
+        const locate = async (paragraphId) => {
+            const known = pagesOf.get(paragraphId);
+            if (known)
+                return known;
+            let seed;
+            for (const pageIndex of [...cached, ...scan]) {
+                if (await holds(pageIndex, paragraphId)) {
+                    seed = pageIndex;
+                    break;
+                }
+            }
+            const pages = [];
+            if (seed !== undefined) {
+                pages.push(seed);
+                for (let pageIndex = seed - 1; pageIndex >= 0 && (await holds(pageIndex, paragraphId)); pageIndex -= 1)
+                    pages.unshift(pageIndex);
+                for (let pageIndex = seed + 1; pageIndex < pageCount && (await holds(pageIndex, paragraphId)); pageIndex += 1)
+                    pages.push(pageIndex);
+            }
+            pagesOf.set(paragraphId, pages);
+            return pages;
+        };
+        const fold = (value) => options.caseSensitive ? value : value.toLocaleLowerCase();
+        const occurrences = new Map();
+        const out = [];
+        for (const target of targets) {
+            const elementId = target.elementIds[0];
+            const paragraphId = elementId?.startsWith("p:")
+                ? elementId.slice(2)
+                : undefined;
+            const pages = paragraphId ? await locate(paragraphId) : [];
+            if (!paragraphId || pages.length === 0) {
+                out.push(target);
+                continue;
+            }
+            const runs = [];
+            for (const pageIndex of pages)
+                for (const run of await load(pageIndex))
+                    if (run.paragraphId === paragraphId)
+                        runs.push({ run, pageIndex });
+            const key = `${paragraphId}\u0000${fold(target.text)}`;
+            const occurrence = occurrences.get(key) ?? 0;
+            occurrences.set(key, occurrence + 1);
+            const rects = matchRects(runs, fold(target.text), occurrence, fold);
+            const placed = rects.length > 0
+                ? rects
+                : runs
+                    .filter((entry) => entry.pageIndex === pages[0])
+                    .map((entry) => ({
+                    pageIndex: entry.pageIndex,
+                    rect: runRect(entry.run),
+                }));
+            out.push({
+                ...target,
+                pageIndex: placed[0]?.pageIndex ?? target.pageIndex,
+                rects: placed.map((entry) => entry.rect),
+            });
+        }
+        return out;
+    }
+}
+function range(first, last, pageCount) {
+    const out = [];
+    for (let index = Math.max(0, first); index <= Math.min(last, pageCount - 1); index += 1)
+        out.push(index);
+    return out;
+}
+/** The `occurrence`-th match of `needle` in the runs' text, cut to run boxes. */
+function matchRects(runs, needle, occurrence, fold) {
+    if (needle.length === 0)
+        return [];
+    const text = fold(runs.map((entry) => entry.run.text).join(""));
+    let at = -1;
+    for (let found = 0; found <= occurrence; found += 1) {
+        at = text.indexOf(needle, at + 1);
+        if (at < 0)
+            return [];
+    }
+    const end = at + needle.length;
+    const out = [];
+    let offset = 0;
+    for (const { run, pageIndex } of runs) {
+        const runStart = offset;
+        const runEnd = offset + run.text.length;
+        offset = runEnd;
+        if (runEnd <= at || runStart >= end || run.text.length === 0)
+            continue;
+        const from = Math.max(at, runStart) - runStart;
+        const to = Math.min(end, runEnd) - runStart;
+        const box = runRect(run);
+        const scale = box.width / run.text.length;
+        out.push({
+            pageIndex,
+            rect: {
+                x: box.x + from * scale,
+                y: box.y,
+                width: (to - from) * scale,
+                height: box.height,
+            },
+        });
+    }
+    return out;
+}
+function runRect(run) {
+    return { x: run.x, y: run.y, width: run.width, height: run.height };
+}
+function union(a, b) {
+    const x = Math.min(a.x, b.x);
+    const y = Math.min(a.y, b.y);
+    return {
+        x,
+        y,
+        width: Math.max(a.x + a.width, b.x + b.width) - x,
+        height: Math.max(a.y + a.height, b.y + b.height) - y,
+    };
+}
+function rectContains(rect, point) {
+    return (point.x >= rect.x &&
+        point.x <= rect.x + rect.width &&
+        point.y >= rect.y &&
+        point.y <= rect.y + rect.height);
+}
+function rectsIntersect(a, b) {
+    return (a.x < b.x + b.width &&
+        b.x < a.x + a.width &&
+        a.y < b.y + b.height &&
+        b.y < a.y + a.height);
+}
+function fragmentsOf(pages) {
+    if (!pages)
+        return [];
+    return [...pages.entries()]
+        .sort((a, b) => a[0] - b[0])
+        .map(([pageIndex, bounds]) => ({ pageIndex, bounds }));
+}
+function withFragments(element, fragments) {
+    const first = fragments[0];
+    return {
+        ...element,
+        pageIndex: first ? first.pageIndex : -1,
+        bounds: first ? first.bounds : { x: 0, y: 0, width: 0, height: 0 },
+        fragments,
+    };
+}
+/** Characters a paragraph may hold without the renderer drawing a text run for it. */
+const INVISIBLE = /^[\ufffc\s]*$/;
+/**
+ * A paragraph that draws no run (empty, or holding only pictures) is
+ * placed by estimate right after the placed paragraph before it in the
+ * same body or cell, else right before the one after it: a picture
+ * paragraph takes its largest picture's extent, an empty one a line of
+ * its neighbour's height. Nothing is estimated for a paragraph with text,
+ * whose runs simply lie on a page not read yet.
+ */
+function estimateRunless(elements, placed) {
+    const paragraphs = elements.filter((element) => element.kind === "paragraph");
+    const sizeOf = (paragraph) => {
+        const pictures = elements.filter((candidate) => candidate.kind === "image" &&
+            candidate.parentId === paragraph.id &&
+            candidate.imageSize);
+        if (pictures.length === 0)
+            return undefined;
+        return {
+            width: Math.max(...pictures.map((picture) => picture.imageSize.width)),
+            height: Math.max(...pictures.map((picture) => picture.imageSize.height)),
+        };
+    };
+    for (const [index, paragraph] of paragraphs.entries()) {
+        const current = placed.get(paragraph.id);
+        if (current.pageIndex >= 0 || !INVISIBLE.test(paragraph.text ?? ""))
+            continue;
+        const sibling = (step) => {
+            for (let at = index + step; at >= 0 && at < paragraphs.length; at += step) {
+                const other = paragraphs[at];
+                if (other.parentId !== paragraph.parentId)
+                    continue;
+                const fragments = placed.get(other.id)?.fragments ?? [];
+                const fragment = step < 0 ? fragments.at(-1) : fragments[0];
+                if (fragment)
+                    return fragment;
+                if (!INVISIBLE.test(other.text ?? ""))
+                    return undefined;
+            }
+            return undefined;
+        };
+        const before = sibling(-1);
+        const after = before ? undefined : sibling(1);
+        const anchor = before ?? after;
+        if (!anchor)
+            continue;
+        const size = sizeOf(paragraph) ?? {
+            width: anchor.bounds.width,
+            height: anchor.bounds.height,
+        };
+        const bounds = before
+            ? {
+                x: before.bounds.x,
+                y: before.bounds.y + before.bounds.height,
+                ...size,
+            }
+            : {
+                x: after.bounds.x,
+                y: Math.max(0, after.bounds.y - size.height),
+                ...size,
+            };
+        placed.set(paragraph.id, withFragments(paragraph, [{ pageIndex: anchor.pageIndex, bounds }]));
+    }
+}
+/** Joins the engine's elements with the runs' placement. */
+export function placeElements(elements, placement) {
+    const placed = new Map();
+    // Paragraphs first; tables and inline objects derive from them.
+    for (const element of elements)
+        if (element.kind === "paragraph")
+            placed.set(element.id, withFragments(element, fragmentsOf(placement.get(element.id.slice(2)))));
+    estimateRunless(elements, placed);
+    for (const element of elements) {
+        if (element.kind === "table") {
+            const pages = new Map();
+            for (const candidate of elements) {
+                if (candidate.kind !== "paragraph" || candidate.parentId !== element.id)
+                    continue;
+                for (const fragment of placed.get(candidate.id)?.fragments ?? []) {
+                    const current = pages.get(fragment.pageIndex);
+                    pages.set(fragment.pageIndex, current ? union(current, fragment.bounds) : fragment.bounds);
+                }
+            }
+            placed.set(element.id, withFragments(element, fragmentsOf(pages)));
+        }
+        else if (element.kind !== "paragraph") {
+            const parent = element.parentId
+                ? placed.get(element.parentId)
+                : undefined;
+            placed.set(element.id, withFragments(element, parent?.fragments ?? []));
+        }
+    }
+    return elements.map((element) => placed.get(element.id) ?? element);
+}
+function matchesQuery(element, query) {
+    if (query.kinds && !query.kinds.includes(element.kind))
+        return false;
+    if (query.pageIndex === undefined)
+        return true;
+    const fragment = element.fragments?.find((candidate) => candidate.pageIndex === query.pageIndex);
+    if (!fragment)
+        return false;
+    return !query.intersects || rectsIntersect(fragment.bounds, query.intersects);
+}
+function docxReads(engine) {
+    const candidate = engine;
+    if (typeof candidate.revisions !== "function")
+        throw new ViewerError("edit-unsupported", "The engine does not provide the DOCX reads", { details: { format: "docx", reason: "no-reads" } });
+    return candidate;
+}

package/dist/edit/docx/structure-ops.d.ts

@@ -0,0 +1,6 @@
+import type { DocxOperationHandler } from "./operations.js";
+import type { DocxDeleteElementOperation, DocxInsertImageOperation, DocxInsertParagraphOperation, DocxMoveElementOperation } from "./types.js";
+export declare const insertParagraphHandler: DocxOperationHandler<DocxInsertParagraphOperation>;
+export declare const deleteElementHandler: DocxOperationHandler<DocxDeleteElementOperation>;
+export declare const moveElementHandler: DocxOperationHandler<DocxMoveElementOperation>;
+export declare const insertImageHandler: DocxOperationHandler<DocxInsertImageOperation>;