@progress/kendo-pdfviewer-common 0.3.0-dev.202409251459 → 0.3.0-dev.202410100645

package/dist/es2015/annotations/helpers/image-manager.js

@@ -0,0 +1,176 @@
+/* Copyright 2022 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var _ImageManager_instances, _a, _ImageManager_baseId, _ImageManager_id, _ImageManager_cache, _ImageManager_get;
+import { __awaiter, __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { fetchData, shadow } from "pdfjs-dist/legacy/build/pdf.mjs";
+import { getUuid } from "../shared/utils";
+/**
+ * Class to manage the images used by the editors.
+ * The main idea is to try to minimize the memory used by the images.
+ * The images are cached and reused when possible
+ * We use a refCounter to know when an image is not used anymore but we need to
+ * be able to restore an image after a remove+undo, so we keep a file reference
+ * or an url one.
+ */
+export class ImageManager {
+    constructor() {
+        _ImageManager_instances.add(this);
+        _ImageManager_baseId.set(this, getUuid());
+        _ImageManager_id.set(this, 0);
+        _ImageManager_cache.set(this, null);
+    }
+    static get _isSVGFittingCanvas() {
+        // By default, Firefox doesn't rescale without preserving the aspect ratio
+        // when drawing an SVG image on a canvas, see https://bugzilla.mozilla.org/1547776.
+        // The "workaround" is to append "svgView(preserveAspectRatio(none))" to the
+        // url, but according to comment #15, it seems that it leads to unexpected
+        // behavior in Safari.
+        const svg = `data:image/svg+xml;charset=UTF-8,<svg viewBox="0 0 1 1" width="1" height="1" xmlns="http://www.w3.org/2000/svg"><rect width="1" height="1" style="fill:red;"/></svg>`;
+        const canvas = new OffscreenCanvas(1, 3);
+        const ctx = canvas.getContext("2d", { willReadFrequently: true });
+        const image = new Image();
+        image.src = svg;
+        const promise = image.decode().then(() => {
+            ctx.drawImage(image, 0, 0, 1, 1, 0, 0, 1, 3);
+            return new Uint32Array(ctx.getImageData(0, 0, 1, 1).data.buffer)[0] === 0;
+        });
+        return shadow(this, "_isSVGFittingCanvas", promise);
+    }
+    getFromFile(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { lastModified, name, size, type } = file;
+            return __classPrivateFieldGet(this, _ImageManager_instances, "m", _ImageManager_get).call(this, `${lastModified}_${name}_${size}_${type}`, file);
+        });
+    }
+    getFromUrl(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _ImageManager_instances, "m", _ImageManager_get).call(this, url, url);
+        });
+    }
+    getFromId(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _ImageManager_cache, __classPrivateFieldGet(this, _ImageManager_cache, "f") || new Map(), "f");
+            const data = __classPrivateFieldGet(this, _ImageManager_cache, "f").get(id);
+            if (!data) {
+                return null;
+            }
+            if (data.bitmap) {
+                data.refCounter += 1;
+                return data;
+            }
+            if (data.file) {
+                return this.getFromFile(data.file);
+            }
+            return this.getFromUrl(data.url);
+        });
+    }
+    getSvgUrl(id) {
+        const data = __classPrivateFieldGet(this, _ImageManager_cache, "f").get(id);
+        if (!(data === null || data === void 0 ? void 0 : data.isSvg)) {
+            return null;
+        }
+        return data.svgUrl;
+    }
+    deleteId(id) {
+        __classPrivateFieldSet(this, _ImageManager_cache, __classPrivateFieldGet(this, _ImageManager_cache, "f") || new Map(), "f");
+        const data = __classPrivateFieldGet(this, _ImageManager_cache, "f").get(id);
+        if (!data) {
+            return;
+        }
+        data.refCounter -= 1;
+        if (data.refCounter !== 0) {
+            return;
+        }
+        data.bitmap = null;
+    }
+    // We can use the id only if it belongs this manager.
+    // We must take care of having the right manager because we can copy/paste
+    // some images from other documents, hence it'd be a pity to use an id from an
+    // other manager.
+    isValidId(id) {
+        return id.startsWith(`image_${__classPrivateFieldGet(this, _ImageManager_baseId, "f")}_`);
+    }
+}
+_a = ImageManager, _ImageManager_baseId = new WeakMap(), _ImageManager_id = new WeakMap(), _ImageManager_cache = new WeakMap(), _ImageManager_instances = new WeakSet(), _ImageManager_get = function _ImageManager_get(key, rawData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _b, _c;
+        __classPrivateFieldSet(this, _ImageManager_cache, __classPrivateFieldGet(this, _ImageManager_cache, "f") || new Map(), "f");
+        let data = __classPrivateFieldGet(this, _ImageManager_cache, "f").get(key);
+        if (data === null) {
+            // We already tried to load the image but it failed.
+            return null;
+        }
+        if (data === null || data === void 0 ? void 0 : data.bitmap) {
+            data.refCounter += 1;
+            return data;
+        }
+        try {
+            data || (data = {
+                bitmap: null,
+                id: `image_${__classPrivateFieldGet(this, _ImageManager_baseId, "f")}_${__classPrivateFieldSet(this, _ImageManager_id, (_c = __classPrivateFieldGet(this, _ImageManager_id, "f"), _b = _c++, _c), "f"), _b}`,
+                refCounter: 0,
+                isSvg: false,
+            });
+            let image;
+            if (typeof rawData === "string") {
+                data.url = rawData;
+                image = yield fetchData(rawData, "blob");
+            }
+            else {
+                image = data.file = rawData;
+            }
+            if (image.type === "image/svg+xml") {
+                // Unfortunately, createImageBitmap doesn't work with SVG images.
+                // (see https://bugzilla.mozilla.org/1841972).
+                const mustRemoveAspectRatioPromise = _a._isSVGFittingCanvas;
+                const fileReader = new FileReader();
+                const imageElement = new Image();
+                const imagePromise = new Promise((resolve, reject) => {
+                    imageElement.onload = () => {
+                        data.bitmap = imageElement;
+                        data.isSvg = true;
+                        // @ts-expect-error(TS:2794)
+                        resolve();
+                    };
+                    fileReader.onload = () => __awaiter(this, void 0, void 0, function* () {
+                        const url = (data.svgUrl = fileReader.result);
+                        // We need to set the preserveAspectRatio to none in order to let
+                        // the image fits the canvas when resizing.
+                        // @ts-expect-error(TS:2332)
+                        imageElement.src = (yield mustRemoveAspectRatioPromise)
+                            ? `${url}#svgView(preserveAspectRatio(none))`
+                            : url;
+                    });
+                    imageElement.onerror = fileReader.onerror = reject;
+                });
+                fileReader.readAsDataURL(image);
+                yield imagePromise;
+            }
+            else {
+                data.bitmap = yield createImageBitmap(image);
+            }
+            data.refCounter = 1;
+        }
+        catch (e) {
+            console.error(e);
+            data = null;
+        }
+        __classPrivateFieldGet(this, _ImageManager_cache, "f").set(key, data);
+        if (data) {
+            __classPrivateFieldGet(this, _ImageManager_cache, "f").set(data.id, data);
+        }
+        return data;
+    });
+};

package/dist/es2015/annotations/helpers/text-accessibility-manager.js

@@ -0,0 +1,212 @@
+/* Copyright 2022 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var _TextAccessibilityManager_instances, _a, _TextAccessibilityManager_enabled, _TextAccessibilityManager_textChildren, _TextAccessibilityManager_textNodes, _TextAccessibilityManager_waitingElements, _TextAccessibilityManager_compareElementPositions, _TextAccessibilityManager_addIdToAriaOwns;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { binarySearchFirstItem } from "../shared/ui_utils";
+/**
+ * This class aims to provide some methods:
+ *  - to reorder elements in the DOM with respect to the visual order;
+ *  - to create a link, using aria-owns, between spans in the textLayer and
+ *    annotations in the annotationLayer. The goal is to help to know
+ *    where the annotations are in the text flow.
+ */
+class TextAccessibilityManager {
+    constructor() {
+        _TextAccessibilityManager_instances.add(this);
+        _TextAccessibilityManager_enabled.set(this, false);
+        _TextAccessibilityManager_textChildren.set(this, null);
+        _TextAccessibilityManager_textNodes.set(this, new Map());
+        _TextAccessibilityManager_waitingElements.set(this, new Map());
+    }
+    setTextMapping(textDivs) {
+        __classPrivateFieldSet(this, _TextAccessibilityManager_textChildren, textDivs, "f");
+    }
+    /**
+     * Function called when the text layer has finished rendering.
+     */
+    enable() {
+        if (__classPrivateFieldGet(this, _TextAccessibilityManager_enabled, "f")) {
+            // throw new Error("TextAccessibilityManager is already enabled.");
+        }
+        if (!__classPrivateFieldGet(this, _TextAccessibilityManager_textChildren, "f")) {
+            throw new Error("Text divs and strings have not been set.");
+        }
+        __classPrivateFieldSet(this, _TextAccessibilityManager_enabled, true, "f");
+        __classPrivateFieldSet(this, _TextAccessibilityManager_textChildren, __classPrivateFieldGet(this, _TextAccessibilityManager_textChildren, "f").slice(), "f");
+        __classPrivateFieldGet(this, _TextAccessibilityManager_textChildren, "f").sort(__classPrivateFieldGet(_a, _a, "m", _TextAccessibilityManager_compareElementPositions));
+        if (__classPrivateFieldGet(this, _TextAccessibilityManager_textNodes, "f").size > 0) {
+            // Some links have been made before this manager has been disabled, hence
+            // we restore them.
+            const textChildren = __classPrivateFieldGet(this, _TextAccessibilityManager_textChildren, "f");
+            for (const [id, nodeIndex] of __classPrivateFieldGet(this, _TextAccessibilityManager_textNodes, "f")) {
+                const element = document.getElementById(id);
+                if (!element) {
+                    // If the page was *fully* reset the element no longer exists, and it
+                    // will be re-inserted later (i.e. when the annotationLayer renders).
+                    __classPrivateFieldGet(this, _TextAccessibilityManager_textNodes, "f").delete(id);
+                    continue;
+                }
+                __classPrivateFieldGet(this, _TextAccessibilityManager_instances, "m", _TextAccessibilityManager_addIdToAriaOwns).call(this, id, textChildren[nodeIndex]);
+            }
+        }
+        for (const [element, isRemovable] of __classPrivateFieldGet(this, _TextAccessibilityManager_waitingElements, "f")) {
+            this.addPointerInTextLayer(element, isRemovable);
+        }
+        __classPrivateFieldGet(this, _TextAccessibilityManager_waitingElements, "f").clear();
+    }
+    disable() {
+        if (!__classPrivateFieldGet(this, _TextAccessibilityManager_enabled, "f")) {
+            return;
+        }
+        // Don't clear this.#textNodes which is used to rebuild the aria-owns
+        // in case it's re-enabled at some point.
+        __classPrivateFieldGet(this, _TextAccessibilityManager_waitingElements, "f").clear();
+        __classPrivateFieldSet(this, _TextAccessibilityManager_textChildren, null, "f");
+        __classPrivateFieldSet(this, _TextAccessibilityManager_enabled, false, "f");
+    }
+    /**
+     * Remove an aria-owns id from a node in the text layer.
+     * @param {HTMLElement} element
+     */
+    removePointerInTextLayer(element) {
+        if (!__classPrivateFieldGet(this, _TextAccessibilityManager_enabled, "f")) {
+            __classPrivateFieldGet(this, _TextAccessibilityManager_waitingElements, "f").delete(element);
+            return;
+        }
+        const children = __classPrivateFieldGet(this, _TextAccessibilityManager_textChildren, "f");
+        if (!children || children.length === 0) {
+            return;
+        }
+        const { id } = element;
+        const nodeIndex = __classPrivateFieldGet(this, _TextAccessibilityManager_textNodes, "f").get(id);
+        if (nodeIndex === undefined) {
+            return;
+        }
+        const node = children[nodeIndex];
+        __classPrivateFieldGet(this, _TextAccessibilityManager_textNodes, "f").delete(id);
+        let owns = node.getAttribute("aria-owns");
+        if (owns === null || owns === void 0 ? void 0 : owns.includes(id)) {
+            owns = owns
+                .split(" ")
+                .filter(x => x !== id)
+                .join(" ");
+            if (owns) {
+                node.setAttribute("aria-owns", owns);
+            }
+            else {
+                node.removeAttribute("aria-owns");
+                node.setAttribute("role", "presentation");
+            }
+        }
+    }
+    /**
+     * Find the text node which is the nearest and add an aria-owns attribute
+     * in order to correctly position this editor in the text flow.
+     * @param {HTMLElement} element
+     * @param {boolean} isRemovable
+     * @returns {string|null} The id in the struct tree if any.
+     */
+    addPointerInTextLayer(element, isRemovable) {
+        // todo: mocked highlight editor is null here
+        if (!element) {
+            console.warn("no element");
+            return;
+        }
+        const { id } = element;
+        if (!id) {
+            return null;
+        }
+        if (!__classPrivateFieldGet(this, _TextAccessibilityManager_enabled, "f")) {
+            // The text layer needs to be there, so we postpone the association.
+            __classPrivateFieldGet(this, _TextAccessibilityManager_waitingElements, "f").set(element, isRemovable);
+            return null;
+        }
+        if (isRemovable) {
+            this.removePointerInTextLayer(element);
+        }
+        const children = __classPrivateFieldGet(this, _TextAccessibilityManager_textChildren, "f");
+        if (!children || children.length === 0) {
+            return null;
+        }
+        const index = binarySearchFirstItem(children, node => __classPrivateFieldGet(_a, _a, "m", _TextAccessibilityManager_compareElementPositions).call(_a, element, node) < 0);
+        const nodeIndex = Math.max(0, index - 1);
+        const child = children[nodeIndex];
+        __classPrivateFieldGet(this, _TextAccessibilityManager_instances, "m", _TextAccessibilityManager_addIdToAriaOwns).call(this, id, child);
+        __classPrivateFieldGet(this, _TextAccessibilityManager_textNodes, "f").set(id, nodeIndex);
+        const parent = child.parentNode;
+        // return parent?.classList.contains("markedContent") ? parent.id : null;
+        return (parent === null || parent === void 0 ? void 0 : parent.classList.contains("markedContent")) ||
+            (parent === null || parent === void 0 ? void 0 : parent.classList.contains("k-marked-content")) ? parent.id : null;
+    }
+    /**
+     * Move a div in the DOM in order to respect the visual order.
+     * @param {HTMLDivElement} element
+     * @returns {string|null} The id in the struct tree if any.
+     */
+    moveElementInDOM(container, element, contentElement, isRemovable) {
+        const id = this.addPointerInTextLayer(contentElement, isRemovable);
+        if (!container.hasChildNodes()) {
+            container.append(element);
+            return id;
+        }
+        // todo: use children to skip text nodes
+        // const children = Array.from(container.childNodes).filter(
+        const children = Array.from(container.children).filter(node => node !== element);
+        if (children.length === 0) {
+            return id;
+        }
+        const elementToCompare = contentElement || element;
+        const index = binarySearchFirstItem(children, node => __classPrivateFieldGet(_a, _a, "m", _TextAccessibilityManager_compareElementPositions).call(_a, elementToCompare, node) < 0);
+        if (index === 0) {
+            children[0].before(element);
+        }
+        else {
+            children[index - 1].after(element);
+        }
+        return id;
+    }
+}
+_a = TextAccessibilityManager, _TextAccessibilityManager_enabled = new WeakMap(), _TextAccessibilityManager_textChildren = new WeakMap(), _TextAccessibilityManager_textNodes = new WeakMap(), _TextAccessibilityManager_waitingElements = new WeakMap(), _TextAccessibilityManager_instances = new WeakSet(), _TextAccessibilityManager_compareElementPositions = function _TextAccessibilityManager_compareElementPositions(e1, e2) {
+    const rect1 = e1.getBoundingClientRect();
+    const rect2 = e2.getBoundingClientRect();
+    if (rect1.width === 0 && rect1.height === 0) {
+        return +1;
+    }
+    if (rect2.width === 0 && rect2.height === 0) {
+        return -1;
+    }
+    const top1 = rect1.y;
+    const bot1 = rect1.y + rect1.height;
+    const mid1 = rect1.y + rect1.height / 2;
+    const top2 = rect2.y;
+    const bot2 = rect2.y + rect2.height;
+    const mid2 = rect2.y + rect2.height / 2;
+    if (mid1 <= top2 && mid2 >= bot1) {
+        return -1;
+    }
+    if (mid2 <= top1 && mid1 >= bot2) {
+        return +1;
+    }
+    const centerX1 = rect1.x + rect1.width / 2;
+    const centerX2 = rect2.x + rect2.width / 2;
+    return centerX1 - centerX2;
+}, _TextAccessibilityManager_addIdToAriaOwns = function _TextAccessibilityManager_addIdToAriaOwns(id, node) {
+    const owns = node.getAttribute("aria-owns");
+    if (!(owns === null || owns === void 0 ? void 0 : owns.includes(id))) {
+        node.setAttribute("aria-owns", owns ? `${owns} ${id}` : id);
+    }
+    node.removeAttribute("role");
+};
+export { TextAccessibilityManager };

package/dist/es2015/annotations/helpers/tools.js

@@ -0,0 +1,19 @@
+/* Copyright 2022 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export function bindEvents(obj, element, names) {
+    for (const name of names) {
+        element.addEventListener(name, obj[name].bind(obj));
+    }
+}