web-doc 0.6.2 → 0.7.0

package/dist/edit/pdf/engine/existing-text.js

@@ -0,0 +1,424 @@
+import { objectBounds, OBJECT_TEXT } from "./elements.js";
+import { firstNonWinAnsi, isStandardFamily, parseCmap, } from "./fonts.js";
+import { pageToUser } from "./geometry.js";
+import { parseColor, setText, textBoxReplaceText, textBoxSetTextStyle, textBoxTarget, } from "./text-box.js";
+/*
+ * Edits to text objects that already exist in the file. The object is changed
+ * in place only when its font provably covers the new text; otherwise it is
+ * replaced by a new object in a font that does, at the same place, size and
+ * colour, and the receipt says so.
+ */
+export const replaceText = {
+    validate(operation, context, issue) {
+        const box = textBoxTarget(operation.target, context);
+        if (box) {
+            const spliced = splice(box.spec.text, operation, issue);
+            if (spliced === undefined)
+                return;
+            return textBoxReplaceText.validate(wholeTextOperation(operation, spliced), context, issue);
+        }
+        const target = textTarget(operation.target, context, issue);
+        if (!target)
+            return;
+        const whole = splice(target.element.text ?? "", operation, issue);
+        if (whole === undefined)
+            return;
+        if (!validateScript(operation.text, issue))
+            return;
+        if (canKeepFont(context, target, whole))
+            return;
+        const request = {
+            family: target.element.textStyle?.fontFamily ?? "Helvetica",
+            bold: target.element.textStyle?.bold ?? false,
+            italic: target.element.textStyle?.italic ?? false,
+            text: operation.text,
+        };
+        // The file's own family is only a hint: what matters is whether some
+        // available font can draw the new text.
+        let problem = context.fonts.problem(request);
+        if (problem?.code === "unknown-font")
+            problem = context.fonts.problem({ ...request, family: "Helvetica" });
+        if (problem)
+            issue(problem.path, problem.code, problem.message);
+    },
+    apply(operation, context) {
+        const box = textBoxTarget(operation.target, context);
+        if (box)
+            return textBoxReplaceText.apply(wholeTextOperation(operation, splice(box.spec.text, operation)), context);
+        const target = textTarget(operation.target, context);
+        const previous = target.element.text ?? "";
+        const whole = splice(previous, operation);
+        if (canKeepFont(context, target, whole)) {
+            const kept = replaceInPlace(context, target, whole);
+            if (kept)
+                return result(target.location);
+        }
+        const span = spanOf(operation, previous);
+        const before = previous.slice(0, span.start);
+        const after = previous.slice(span.end);
+        if (!before && !after)
+            return replaceWithFallback(context, target, operation.text);
+        return (splitAround(context, target, before, operation.text, after) ??
+            replaceWithFallback(context, target, whole));
+    },
+};
+/** The same operation as a whole-text replacement with `text`. */
+function wholeTextOperation(operation, text) {
+    const { range: _range, ...rest } = operation;
+    return { ...rest, text };
+}
+/** The target's text with the operation's range replaced; the whole text without one. */
+function splice(previous, operation, issue = () => { }) {
+    const { range } = operation;
+    if (!range)
+        return operation.text;
+    const onTarget = (position) => position.elementId === operation.target &&
+        Number.isInteger(position.offset) &&
+        position.offset >= 0 &&
+        position.offset <= previous.length;
+    if (!onTarget(range.start) ||
+        !onTarget(range.end) ||
+        range.start.offset > range.end.offset) {
+        issue("/range", "invalid-range", `The range must lie inside the target's text (0–${previous.length})`);
+        return undefined;
+    }
+    const { start, end } = spanOf(operation, previous);
+    return previous.slice(0, start) + operation.text + previous.slice(end);
+}
+function spanOf(operation, previous) {
+    if (!operation.range)
+        return { start: 0, end: previous.length };
+    return {
+        start: operation.range.start.offset,
+        end: operation.range.end.offset,
+    };
+}
+export const setTextStyle = {
+    validate(operation, context, issue) {
+        if (textBoxTarget(operation.target, context))
+            return textBoxSetTextStyle.validate(operation, context, issue);
+        if (!textTarget(operation.target, context, issue))
+            return;
+        for (const field of [
+            "fontFamily",
+            "bold",
+            "italic",
+            "align",
+            "lineHeight",
+        ])
+            if (operation.style[field] !== undefined)
+                issue(`/style/${field}`, "unsupported-style", `Only color and fontSize can change on existing text; ${field} cannot`);
+    },
+    apply(operation, context) {
+        if (textBoxTarget(operation.target, context))
+            return textBoxSetTextStyle.apply(operation, context);
+        const target = textTarget(operation.target, context);
+        const { lib } = context.pdfium;
+        const { location } = target;
+        if (operation.style.color !== undefined) {
+            const [r, g, b] = parseColor(operation.style.color);
+            context.withPage(location.pageIndex, (page) => {
+                lib.FPDFPageObj_SetFillColor(lib.FPDFPage_GetObject(page, location.indexes[0]), r, g, b, 255);
+            });
+        }
+        if (operation.style.fontSize !== undefined)
+            resize(context, target, operation.style.fontSize);
+        return result(location);
+    },
+};
+function textTarget(target, context, issue = () => { }) {
+    const location = context.locate(target);
+    const element = location && context.element(target);
+    if (!location || !element) {
+        issue("/target", "unknown-target", `No element ${target}`);
+        return undefined;
+    }
+    if (element.kind !== "text" || location.record.type !== OBJECT_TEXT) {
+        issue("/target", "unsupported-target", "Only text objects and text boxes carry text");
+        return undefined;
+    }
+    return { location, element };
+}
+/** Right-to-left scripts need shaping the MVP does not do. */
+function validateScript(text, issue) {
+    for (const character of text) {
+        const code = character.codePointAt(0);
+        if ((code >= 0x0590 && code <= 0x08ff) ||
+            (code >= 0xfb1d && code <= 0xfdff) ||
+            (code >= 0xfe70 && code <= 0xfeff)) {
+            issue("/text", "unsupported-script", `Right-to-left text such as "${character}" cannot be edited yet`);
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Whether the object's own font can draw `text`: a standard font for WinAnsi
+ * text, or an embedded TrueType program whose cmap covers every character
+ * (which also answers for subsets, since their cmaps hold only what they
+ * kept).
+ */
+function canKeepFont(context, target, text) {
+    const { pdfium } = context;
+    const { lib } = pdfium;
+    return context.withPage(target.location.pageIndex, (page) => {
+        const object = lib.FPDFPage_GetObject(page, target.location.indexes[0]);
+        const font = lib.FPDFTextObj_GetFont(object);
+        if (!lib.FPDFFont_GetIsEmbedded(font)) {
+            const base = pdfium.readUtf8String((buffer, bytes) => lib.FPDFFont_GetBaseFontName(font, buffer, bytes));
+            return (isStandardFamily(base.split(/[-,]/)[0] ?? "") &&
+                firstNonWinAnsi(text) === undefined);
+        }
+        const coverage = fontCoverage(pdfium, font);
+        if (!coverage)
+            return false;
+        for (const character of text) {
+            const code = character.codePointAt(0);
+            if (code !== 0x0a && code !== 0x20 && !coverage.drawable(code))
+                return false;
+        }
+        return true;
+    });
+}
+function fontCoverage(pdfium, font) {
+    const { lib } = pdfium;
+    const size = pdfium.readNumbers(1, "i32", ([out]) => lib.FPDFFont_GetFontData(font, 0, 0, out))?.[0];
+    if (!size)
+        return undefined;
+    const buffer = pdfium.malloc(size);
+    try {
+        const out = pdfium.malloc(4);
+        try {
+            if (!lib.FPDFFont_GetFontData(font, buffer, size, out))
+                return undefined;
+        }
+        finally {
+            pdfium.free(out);
+        }
+        const data = pdfium.readBytes(buffer, size);
+        const tag = String.fromCharCode(data[0], data[1], data[2], data[3]);
+        const truetype = (data[0] === 0 && data[1] === 1 && data[2] === 0 && data[3] === 0) ||
+            tag === "true";
+        return truetype ? parseCmap(data) : undefined;
+    }
+    finally {
+        pdfium.free(buffer);
+    }
+}
+/** Sets the text and confirms PDFium reads it back; false means it must be replaced. */
+function replaceInPlace(context, target, text) {
+    const { pdfium } = context;
+    const { lib } = pdfium;
+    const index = target.location.indexes[0];
+    const previous = target.element.text ?? "";
+    context.withPage(target.location.pageIndex, (page) => {
+        setText(pdfium, lib.FPDFPage_GetObject(page, index), text);
+    });
+    const readBack = context.withPage(target.location.pageIndex, (page) => {
+        const textPage = lib.FPDFText_LoadPage(page);
+        try {
+            return pdfium.readWideString((buffer, bytes) => lib.FPDFTextObj_GetText(lib.FPDFPage_GetObject(page, index), textPage, buffer, bytes));
+        }
+        finally {
+            lib.FPDFText_ClosePage(textPage);
+        }
+    });
+    if (readBack === text)
+        return true;
+    // Put the old text back so the fallback path starts from a known state.
+    context.withPage(target.location.pageIndex, (page) => {
+        setText(pdfium, lib.FPDFPage_GetObject(page, index), previous);
+    });
+    return false;
+}
+/**
+ * Splits the object around a replaced span: the parts before and after keep
+ * the object's font, size, colour and baseline, the middle part is drawn in
+ * a font that covers it, and the parts follow each other by their advances.
+ * The first part keeps the element's id. Returns nothing when a part cannot
+ * be written back in the original font, leaving the page as it was.
+ */
+function splitAround(context, target, before, middle, after) {
+    const { pdfium, measurer } = context;
+    const { lib } = pdfium;
+    const { location, element } = target;
+    const style = element.textStyle;
+    const index = location.indexes[0];
+    const fallback = context.fonts.resolve(pdfium, context.document, {
+        family: style.fontFamily,
+        bold: style.bold,
+        italic: style.italic,
+        text: middle,
+    });
+    const createdIds = [];
+    const written = context.withPage(location.pageIndex, (page) => {
+        const old = lib.FPDFPage_GetObject(page, index);
+        const oldFont = lib.FPDFTextObj_GetFont(old);
+        const matrix = pdfium.readNumbers(6, "float", ([pointer]) => lib.FPDFPageObj_GetMatrix(old, pointer)) ?? [1, 0, 0, 1, 0, 0];
+        const size = pdfium.readNumbers(1, "float", ([pointer]) => lib.FPDFTextObj_GetFontSize(old, pointer))?.[0] ?? style.fontSize;
+        const [a, b, c, d, e, f] = matrix;
+        const [r, g, bl] = parseColor(style.color);
+        const parts = [
+            { text: before, font: oldFont },
+            { text: middle, font: fallback.handle },
+            { text: after, font: oldFont },
+        ].filter((part) => part.text.length > 0);
+        const objects = [];
+        let cursor = 0;
+        for (const part of parts) {
+            const object = lib.FPDFPageObj_CreateTextObj(context.document, part.font, size);
+            if (object) {
+                setText(pdfium, object, part.text);
+                lib.FPDFPageObj_SetFillColor(object, r, g, bl, 255);
+                lib.FPDFPageObj_Transform(object, a, b, c, d, e + cursor * a, f + cursor * b);
+            }
+            objects.push(object);
+            cursor += measurer.advance(part.font, size, part.text);
+        }
+        // Every part must read back as written, or the original font cannot
+        // encode its share and the whole object goes to the fallback instead.
+        if (objects.some((object) => object === 0)) {
+            for (const object of objects)
+                if (object)
+                    lib.FPDFPageObj_Destroy(object);
+            return false;
+        }
+        lib.FPDFPage_RemoveObject(page, old);
+        objects.forEach((object, at) => lib.FPDFPage_InsertObjectAtIndex(page, object, index + at));
+        const textPage = lib.FPDFText_LoadPage(page);
+        let faithful = true;
+        try {
+            objects.forEach((object, at) => {
+                const read = pdfium.readWideString((buffer, bytes) => lib.FPDFTextObj_GetText(object, textPage, buffer, bytes));
+                // PDFium appends a generated space to an object a gap follows.
+                if (read.trimEnd() !== parts[at].text.trimEnd())
+                    faithful = false;
+            });
+        }
+        finally {
+            lib.FPDFText_ClosePage(textPage);
+        }
+        if (!faithful) {
+            for (const object of objects) {
+                lib.FPDFPage_RemoveObject(page, object);
+                lib.FPDFPageObj_Destroy(object);
+            }
+            lib.FPDFPage_InsertObjectAtIndex(page, old, index);
+            return false;
+        }
+        lib.FPDFPageObj_Destroy(old);
+        return true;
+    });
+    if (!written)
+        return undefined;
+    const partCount = [before, middle, after].filter(Boolean).length;
+    const records = Array.from({ length: partCount }, (_, at) => {
+        if (at === 0)
+            return { id: location.record.id, type: OBJECT_TEXT };
+        const id = context.newId(location.pageIndex);
+        createdIds.push(id);
+        return { id, type: OBJECT_TEXT };
+    });
+    context.spliceObjects(location.pageIndex, index, 1, records);
+    return {
+        createdIds,
+        changedPages: [location.pageIndex],
+        warnings: [
+            {
+                code: "font-substitution",
+                message: fallback.substitution ??
+                    `${style.fontFamily} cannot draw the new text; ${fallback.family} is used for it`,
+                details: { elementId: location.record.id },
+            },
+        ],
+    };
+}
+/** Replaces the object with one in a covering font at the same place, size and colour. */
+function replaceWithFallback(context, target, text) {
+    const { pdfium } = context;
+    const { lib } = pdfium;
+    const { location, element } = target;
+    const style = element.textStyle;
+    const index = location.indexes[0];
+    const font = context.fonts.resolve(pdfium, context.document, {
+        family: style.fontFamily,
+        bold: style.bold,
+        italic: style.italic,
+        text,
+    });
+    context.withPage(location.pageIndex, (page) => {
+        const old = lib.FPDFPage_GetObject(page, index);
+        const matrix = pdfium.readNumbers(6, "float", ([pointer]) => lib.FPDFPageObj_GetMatrix(old, pointer)) ?? [1, 0, 0, 1, 0, 0];
+        const size = pdfium.readNumbers(1, "float", ([pointer]) => lib.FPDFTextObj_GetFontSize(old, pointer))?.[0] ?? style.fontSize;
+        const object = lib.FPDFPageObj_CreateTextObj(context.document, font.handle, size);
+        setText(pdfium, object, text);
+        const [r, g, b] = parseColor(style.color);
+        lib.FPDFPageObj_SetFillColor(object, r, g, b, 255);
+        const [a, bb, c, d, e, f] = matrix;
+        lib.FPDFPageObj_Transform(object, a, bb, c, d, e, f);
+        lib.FPDFPage_RemoveObject(page, old);
+        lib.FPDFPageObj_Destroy(old);
+        lib.FPDFPage_InsertObjectAtIndex(page, object, index);
+    });
+    context.spliceObjects(location.pageIndex, index, 1, [
+        { id: location.record.id, type: OBJECT_TEXT },
+    ]);
+    return {
+        createdIds: [],
+        changedPages: [location.pageIndex],
+        warnings: [
+            {
+                code: "font-substitution",
+                message: font.substitution ??
+                    `${style.fontFamily} cannot draw the new text; ${font.family} is used`,
+                details: { elementId: location.record.id },
+            },
+        ],
+    };
+}
+/**
+ * Gives the object a new font size by rebuilding it with the same font, text,
+ * colour and matrix, then moving it so its top-left corner stays put.
+ */
+function resize(context, target, fontSize) {
+    const { pdfium } = context;
+    const { lib } = pdfium;
+    const { location } = target;
+    const index = location.indexes[0];
+    const geometry = context.geometry(location.pageIndex);
+    const before = target.element.bounds;
+    context.withPage(location.pageIndex, (page) => {
+        const old = lib.FPDFPage_GetObject(page, index);
+        const textPage = lib.FPDFText_LoadPage(page);
+        let text;
+        try {
+            text = pdfium.readWideString((buffer, bytes) => lib.FPDFTextObj_GetText(old, textPage, buffer, bytes));
+        }
+        finally {
+            lib.FPDFText_ClosePage(textPage);
+        }
+        const matrix = pdfium.readNumbers(6, "float", ([pointer]) => lib.FPDFPageObj_GetMatrix(old, pointer)) ?? [1, 0, 0, 1, 0, 0];
+        const color = pdfium.readNumbers(4, "i32", ([r, g, b, a]) => lib.FPDFPageObj_GetFillColor(old, r, g, b, a)) ?? [0, 0, 0, 255];
+        const object = lib.FPDFPageObj_CreateTextObj(context.document, lib.FPDFTextObj_GetFont(old), fontSize);
+        setText(pdfium, object, text);
+        lib.FPDFPageObj_SetFillColor(object, color[0], color[1], color[2], color[3]);
+        const [a, b, c, d, e, f] = matrix;
+        lib.FPDFPageObj_Transform(object, a, b, c, d, e, f);
+        lib.FPDFPage_RemoveObject(page, old);
+        lib.FPDFPageObj_Destroy(old);
+        lib.FPDFPage_InsertObjectAtIndex(page, object, index);
+        // Anchor the top-left corner where it was.
+        const after = objectBounds(pdfium, object, geometry);
+        if (after) {
+            const from = pageToUser(geometry, 0, 0);
+            const to = pageToUser(geometry, before.x - after.x, before.y - after.y);
+            lib.FPDFPageObj_Transform(object, 1, 0, 0, 1, to.x - from.x, to.y - from.y);
+        }
+    });
+    context.spliceObjects(location.pageIndex, index, 1, [
+        { id: location.record.id, type: OBJECT_TEXT },
+    ]);
+}
+function result(location) {
+    return { createdIds: [], changedPages: [location.pageIndex], warnings: [] };
+}

package/dist/edit/pdf/engine/fonts.d.ts

@@ -0,0 +1,78 @@
+import type { EditWorkerFont } from "../../../worker-protocol.js";
+import type { Pdfium } from "./pdfium.js";
+export declare const FALLBACK_FAMILY = "Noto Sans";
+export declare function isStandardFamily(family: string): boolean;
+/** The standard-14 name for a family and style, e.g. Helvetica + bold. */
+export declare function standardFontName(family: string, bold: boolean, italic: boolean): string | undefined;
+/** The first character a standard font cannot encode, if any. */
+export declare function firstNonWinAnsi(text: string): string | undefined;
+export interface FontRequest {
+    readonly family: string;
+    readonly bold: boolean;
+    readonly italic: boolean;
+    readonly text: string;
+}
+export interface ResolvedFont {
+    readonly handle: number;
+    /** Family actually used. */
+    readonly family: string;
+    /** Set when the font is not the one asked for. */
+    readonly substitution?: string;
+}
+/** Why a request cannot be satisfied. */
+export interface FontProblem {
+    readonly path: string;
+    readonly code: "unknown-font" | "font-unavailable";
+    readonly message: string;
+}
+/**
+ * Host-registered fonts and the fallback face, fetched on demand and loaded
+ * into whichever PDFium document needs them.
+ */
+export declare class FontLibrary {
+    #private;
+    constructor(fetchBytes: (url: string) => Promise<Uint8Array>);
+    setFallbackUrl(url: string | undefined): void;
+    register(fonts: readonly EditWorkerFont[]): void;
+    /** Whether `family` names a registered font. */
+    hasFamily(family: string): boolean;
+    /**
+     * Fetches whatever the given texts and families may need, so that
+     * validation and drawing can run synchronously afterwards.
+     */
+    prepare(requests: readonly {
+        family: string;
+        text: string;
+    }[]): Promise<void>;
+    /** Checks a request against what is loaded; `undefined` means it will resolve. */
+    problem(request: FontRequest): FontProblem | undefined;
+    /** The font to draw `request` with in `document`; `prepare` must have run. */
+    resolve(pdfium: Pdfium, document: number, request: FontRequest): ResolvedFont;
+    /** Closes the fonts loaded into a document that is going away. */
+    release(pdfium: Pdfium, document: number): void;
+    covers(bytes: Uint8Array, text: string): boolean;
+}
+export interface CmapCoverage {
+    has(codePoint: number): boolean;
+    /** Mapped to a glyph with outline data; false for an emptied glyph of a subset font. */
+    drawable(codePoint: number): boolean;
+    /** The glyph id a code point maps to, when the font's cmap was parsed. */
+    glyph(codePoint: number): number | undefined;
+}
+export declare function parseCmap(bytes: Uint8Array): CmapCoverage;
+/**
+ * Measures text with PDFium's own metrics by building throw-away text
+ * objects, so layout agrees with what PDFium draws. Advances are cached per
+ * character and font at 1000 pt and scale linearly.
+ */
+export declare class TextMeasurer {
+    #private;
+    constructor(pdfium: Pdfium, document: number);
+    /** Width of `text` in points at `fontSize`, without kerning. */
+    advance(font: number, fontSize: number, text: string): number;
+    /** Ascent above and descent below the baseline, in points, both positive. */
+    metrics(font: number, fontSize: number): {
+        ascent: number;
+        descent: number;
+    };
+}