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

package/dist/es2015/annotations/helpers/annotation-storage.js

@@ -0,0 +1,294 @@
+/* Copyright 2020 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 _AnnotationStorage_instances, _AnnotationStorage_modified, _AnnotationStorage_modifiedIds, _AnnotationStorage_storage, _AnnotationStorage_setModified, _PrintAnnotationStorage_serializable;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { objectFromMap } from "../shared/utils";
+import { AnnotationEditor } from "../../annotations/editors/annotation-editor";
+import { MurmurHash3_64 } from "../shared/murmurhash3";
+import { shadow } from "pdfjs-dist/legacy/build/pdf.mjs";
+const SerializableEmpty = Object.freeze({
+    map: null,
+    hash: "",
+    transfer: undefined,
+});
+/**
+ * Key/value storage for annotation data in forms.
+ */
+class AnnotationStorage {
+    constructor() {
+        _AnnotationStorage_instances.add(this);
+        // todo: props
+        this.onSetModified = null;
+        this.onResetModified = null;
+        this.onAnnotationEditor = null;
+        // todo: props
+        _AnnotationStorage_modified.set(this, false);
+        _AnnotationStorage_modifiedIds.set(this, null);
+        _AnnotationStorage_storage.set(this, new Map());
+        // Callbacks to signal when the modification state is set or reset.
+        // This is used by the viewer to only bind on `beforeunload` if forms
+        // are actually edited to prevent doing so unconditionally since that
+        // can have undesirable effects.
+        this.onSetModified = null;
+        this.onResetModified = null;
+        this.onAnnotationEditor = null;
+    }
+    /**
+     * Get the value for a given key if it exists, or return the default value.
+     * @param {string} key
+     * @param {Object} defaultValue
+     * @returns {Object}
+     */
+    getValue(key, defaultValue) {
+        const value = __classPrivateFieldGet(this, _AnnotationStorage_storage, "f").get(key);
+        if (value === undefined) {
+            return defaultValue;
+        }
+        return Object.assign(defaultValue, value);
+    }
+    /**
+     * Get the value for a given key.
+     * @param {string} key
+     * @returns {Object}
+     */
+    getRawValue(key) {
+        return __classPrivateFieldGet(this, _AnnotationStorage_storage, "f").get(key);
+    }
+    /**
+     * Remove a value from the storage.
+     * @param {string} key
+     */
+    remove(key) {
+        __classPrivateFieldGet(this, _AnnotationStorage_storage, "f").delete(key);
+        if (__classPrivateFieldGet(this, _AnnotationStorage_storage, "f").size === 0) {
+            this.resetModified();
+        }
+        if (typeof this.onAnnotationEditor === "function") {
+            for (const value of __classPrivateFieldGet(this, _AnnotationStorage_storage, "f").values()) {
+                if (value instanceof AnnotationEditor) {
+                    return;
+                }
+            }
+            this.onAnnotationEditor(null);
+        }
+    }
+    /**
+     * Set the value for a given key
+     * @param {string} key
+     * @param {Object} value
+     */
+    setValue(key, value) {
+        const obj = __classPrivateFieldGet(this, _AnnotationStorage_storage, "f").get(key);
+        let modified = false;
+        if (obj !== undefined) {
+            for (const [entry, val] of Object.entries(value)) {
+                if (obj[entry] !== val) {
+                    modified = true;
+                    obj[entry] = val;
+                }
+            }
+        }
+        else {
+            modified = true;
+            __classPrivateFieldGet(this, _AnnotationStorage_storage, "f").set(key, value);
+        }
+        if (modified) {
+            __classPrivateFieldGet(this, _AnnotationStorage_instances, "m", _AnnotationStorage_setModified).call(this);
+        }
+        if (value instanceof AnnotationEditor &&
+            typeof this.onAnnotationEditor === "function") {
+            this.onAnnotationEditor(value.constructor._type);
+        }
+    }
+    /**
+     * Check if the storage contains the given key.
+     * @param {string} key
+     * @returns {boolean}
+     */
+    has(key) {
+        return __classPrivateFieldGet(this, _AnnotationStorage_storage, "f").has(key);
+    }
+    /**
+     * @returns {Object | null}
+     */
+    getAll() {
+        return __classPrivateFieldGet(this, _AnnotationStorage_storage, "f").size > 0 ? objectFromMap(__classPrivateFieldGet(this, _AnnotationStorage_storage, "f")) : null;
+    }
+    /**
+     * @param {Object} obj
+     */
+    setAll(obj) {
+        for (const [key, val] of Object.entries(obj)) {
+            this.setValue(key, val);
+        }
+    }
+    get size() {
+        return __classPrivateFieldGet(this, _AnnotationStorage_storage, "f").size;
+    }
+    resetModified() {
+        if (__classPrivateFieldGet(this, _AnnotationStorage_modified, "f")) {
+            __classPrivateFieldSet(this, _AnnotationStorage_modified, false, "f");
+            if (typeof this.onResetModified === "function") {
+                this.onResetModified();
+            }
+        }
+    }
+    /**
+     * @returns {PrintAnnotationStorage}
+     */
+    get print() {
+        return new PrintAnnotationStorage(this);
+    }
+    /**
+     * PLEASE NOTE: Only intended for usage within the API itself.
+     * @ignore
+     */
+    get serializable() {
+        if (__classPrivateFieldGet(this, _AnnotationStorage_storage, "f").size === 0) {
+            return SerializableEmpty;
+        }
+        const map = new Map(), hash = new MurmurHash3_64(null), transfer = [];
+        const context = Object.create(null);
+        let hasBitmap = false;
+        for (const [key, val] of __classPrivateFieldGet(this, _AnnotationStorage_storage, "f")) {
+            const serialized = val instanceof AnnotationEditor
+                ? val.serialize(/* isForCopying = */ false, context)
+                : val;
+            if (serialized) {
+                map.set(key, serialized);
+                hash.update(`${key}:${JSON.stringify(serialized)}`);
+                hasBitmap || (hasBitmap = !!serialized.bitmap);
+            }
+        }
+        if (hasBitmap) {
+            // We must transfer the bitmap data separately, since it can be changed
+            // during serialization with SVG images.
+            for (const value of map.values()) {
+                if (value.bitmap) {
+                    transfer.push(value.bitmap);
+                }
+            }
+        }
+        return map.size > 0
+            ? { map, hash: hash.hexdigest(), transfer }
+            : SerializableEmpty;
+    }
+    get editorStats() {
+        var _a;
+        let stats = null;
+        const typeToEditor = new Map();
+        for (const value of __classPrivateFieldGet(this, _AnnotationStorage_storage, "f").values()) {
+            if (!(value instanceof AnnotationEditor)) {
+                continue;
+            }
+            const editorStats = value.telemetryFinalData;
+            if (!editorStats) {
+                continue;
+            }
+            const { type } = editorStats;
+            if (!typeToEditor.has(type)) {
+                typeToEditor.set(type, Object.getPrototypeOf(value).constructor);
+            }
+            stats || (stats = Object.create(null));
+            const map = (stats[type] || (stats[type] = new Map()));
+            for (const [key, val] of Object.entries(editorStats)) {
+                if (key === "type") {
+                    continue;
+                }
+                let counters = map.get(key);
+                if (!counters) {
+                    counters = new Map();
+                    map.set(key, counters);
+                }
+                const count = (_a = counters.get(val)) !== null && _a !== void 0 ? _a : 0;
+                counters.set(val, count + 1);
+            }
+        }
+        for (const [type, editor] of typeToEditor) {
+            stats[type] = editor.computeTelemetryFinalData(stats[type]);
+        }
+        return stats;
+    }
+    resetModifiedIds() {
+        __classPrivateFieldSet(this, _AnnotationStorage_modifiedIds, null, "f");
+    }
+    /**
+     * @returns {{ids: Set<string>, hash: string}}
+     */
+    get modifiedIds() {
+        if (__classPrivateFieldGet(this, _AnnotationStorage_modifiedIds, "f")) {
+            return __classPrivateFieldGet(this, _AnnotationStorage_modifiedIds, "f");
+        }
+        const ids = [];
+        for (const value of __classPrivateFieldGet(this, _AnnotationStorage_storage, "f").values()) {
+            if (!(value instanceof AnnotationEditor) ||
+                !value.annotationElementId ||
+                !(value.serialize())) {
+                continue;
+            }
+            ids.push(value.annotationElementId);
+        }
+        return (__classPrivateFieldSet(this, _AnnotationStorage_modifiedIds, {
+            ids: new Set(ids),
+            hash: ids.join(","),
+        }, "f"));
+    }
+}
+_AnnotationStorage_modified = new WeakMap(), _AnnotationStorage_modifiedIds = new WeakMap(), _AnnotationStorage_storage = new WeakMap(), _AnnotationStorage_instances = new WeakSet(), _AnnotationStorage_setModified = function _AnnotationStorage_setModified() {
+    if (!__classPrivateFieldGet(this, _AnnotationStorage_modified, "f")) {
+        __classPrivateFieldSet(this, _AnnotationStorage_modified, true, "f");
+        if (typeof this.onSetModified === "function") {
+            this.onSetModified();
+        }
+    }
+};
+/**
+ * A special `AnnotationStorage` for use during printing, where the serializable
+ * data is *frozen* upon initialization, to prevent scripting from modifying its
+ * contents. (Necessary since printing is triggered synchronously in browsers.)
+ */
+class PrintAnnotationStorage extends AnnotationStorage {
+    constructor(parent) {
+        super();
+        _PrintAnnotationStorage_serializable.set(this, void 0);
+        const { map, hash, transfer } = parent.serializable;
+        // Create a *copy* of the data, since Objects are passed by reference in JS.
+        const clone = structuredClone(map, transfer ? { transfer } : null);
+        __classPrivateFieldSet(this, _PrintAnnotationStorage_serializable, { map: clone, hash, transfer }, "f");
+    }
+    /**
+     * @returns {PrintAnnotationStorage}
+     */
+    // eslint-disable-next-line getter-return
+    get print() {
+        // unreachable("Should not call PrintAnnotationStorage.print");
+        return null;
+    }
+    /**
+     * PLEASE NOTE: Only intended for usage within the API itself.
+     * @ignore
+     */
+    get serializable() {
+        return __classPrivateFieldGet(this, _PrintAnnotationStorage_serializable, "f");
+    }
+    get modifiedIds() {
+        return shadow(this, "modifiedIds", {
+            ids: new Set(),
+            hash: "",
+        });
+    }
+}
+_PrintAnnotationStorage_serializable = new WeakMap();
+export { AnnotationStorage, PrintAnnotationStorage, SerializableEmpty };

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

@@ -0,0 +1,72 @@
+/* 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.
+ */
+import { shadow, Util } from "../shared/utils";
+// import {} from "pdfjs-dist/legacy/build/pdf.mjs";
+import { getColorValues, getRGB } from "../shared/display_utils";
+export class ColorManager {
+    get _colors() {
+        if (
+        // typeof PDFJSDev !== "undefined" &&
+        // PDFJSDev.test("LIB") &&
+        typeof document === "undefined") {
+            return shadow(this, "_colors", ColorManager._colorsMapping);
+        }
+        const colors = new Map([
+            ["CanvasText", null],
+            ["Canvas", null]
+        ]);
+        getColorValues(colors);
+        return shadow(this, "_colors", colors);
+    }
+    /*
+     * In High Contrast Mode, the color on the screen is not always the
+     * real color used in the pdf.
+     * For example in some cases white can appear to be black but when saving
+     * we want to have white.
+     * @param {string} color
+     * @returns {Array<number>}
+     */
+    convert(color) {
+        const rgb = getRGB(color);
+        if (!window.matchMedia("(forced-colors: active)").matches) {
+            return rgb;
+        }
+        for (const [name, RGB] of this._colors) {
+            if (RGB.every((x, i) => x === rgb[i])) {
+                return ColorManager._colorsMapping.get(name);
+            }
+        }
+        return rgb;
+    }
+    /*
+     * An input element must have its color value as a hex string
+     * and not as color name.
+     * So this function converts a name into an hex string.
+     * @param {string} name
+     * @returns {string}
+     */
+    getHexCode(name) {
+        const rgb = this._colors.get(name);
+        if (!rgb) {
+            return name;
+        }
+        // @ts-expect-error TS(2556):
+        return Util.makeHexColor(...rgb);
+    }
+}
+ColorManager._colorsMapping = new Map([
+    ["CanvasText", [0, 0, 0]],
+    ["Canvas", [255, 255, 255]]
+]);

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

@@ -0,0 +1,133 @@
+/* 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 _CommandManager_commands, _CommandManager_locked, _CommandManager_maxSize, _CommandManager_position;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+/*
+ * Class to handle undo/redo.
+ * Commands are just saved in a buffer.
+ * If we hit some memory issues we could likely use a circular buffer.
+ * It has to be used as a singleton.
+ */
+export class CommandManager {
+    constructor(maxSize = 128) {
+        _CommandManager_commands.set(this, []);
+        _CommandManager_locked.set(this, false);
+        _CommandManager_maxSize.set(this, void 0);
+        _CommandManager_position.set(this, -1);
+        __classPrivateFieldSet(this, _CommandManager_maxSize, maxSize, "f");
+    }
+    /**
+     * @typedef {Object} addOptions
+     * @property {function} cmd
+     * @property {function} undo
+     * @property {function} [post]
+     * @property {boolean} mustExec
+     * @property {number} type
+     * @property {boolean} overwriteIfSameType
+     * @property {boolean} keepUndo
+     */
+    /*
+     * Add a new couple of commands to be used in case of redo/undo.
+     * @param {addOptions} options
+     */
+    add({ cmd, undo, post, mustExec, type = NaN, overwriteIfSameType = false, keepUndo = false, }) {
+        if (mustExec) {
+            cmd();
+        }
+        if (__classPrivateFieldGet(this, _CommandManager_locked, "f")) {
+            return;
+        }
+        const save = { cmd, undo, post, type };
+        if (__classPrivateFieldGet(this, _CommandManager_position, "f") === -1) {
+            if (__classPrivateFieldGet(this, _CommandManager_commands, "f").length > 0) {
+                // All the commands have been undone and then a new one is added
+                // hence we clear the queue.
+                __classPrivateFieldGet(this, _CommandManager_commands, "f").length = 0;
+            }
+            __classPrivateFieldSet(this, _CommandManager_position, 0, "f");
+            __classPrivateFieldGet(this, _CommandManager_commands, "f").push(save);
+            return;
+        }
+        if (overwriteIfSameType && __classPrivateFieldGet(this, _CommandManager_commands, "f")[__classPrivateFieldGet(this, _CommandManager_position, "f")].type === type) {
+            // For example when we change a color we don't want to
+            // be able to undo all the steps, hence we only want to
+            // keep the last undoable action in this sequence of actions.
+            if (keepUndo) {
+                save.undo = __classPrivateFieldGet(this, _CommandManager_commands, "f")[__classPrivateFieldGet(this, _CommandManager_position, "f")].undo;
+            }
+            __classPrivateFieldGet(this, _CommandManager_commands, "f")[__classPrivateFieldGet(this, _CommandManager_position, "f")] = save;
+            return;
+        }
+        const next = __classPrivateFieldGet(this, _CommandManager_position, "f") + 1;
+        if (next === __classPrivateFieldGet(this, _CommandManager_maxSize, "f")) {
+            __classPrivateFieldGet(this, _CommandManager_commands, "f").splice(0, 1);
+        }
+        else {
+            __classPrivateFieldSet(this, _CommandManager_position, next, "f");
+            if (next < __classPrivateFieldGet(this, _CommandManager_commands, "f").length) {
+                __classPrivateFieldGet(this, _CommandManager_commands, "f").splice(next);
+            }
+        }
+        __classPrivateFieldGet(this, _CommandManager_commands, "f").push(save);
+    }
+    /**
+     * Undo the last command.
+     */
+    undo() {
+        if (__classPrivateFieldGet(this, _CommandManager_position, "f") === -1) {
+            // Nothing to undo.
+            return;
+        }
+        // Avoid to insert something during the undo execution.
+        __classPrivateFieldSet(this, _CommandManager_locked, true, "f");
+        const { undo, post } = __classPrivateFieldGet(this, _CommandManager_commands, "f")[__classPrivateFieldGet(this, _CommandManager_position, "f")];
+        undo();
+        post === null || post === void 0 ? void 0 : post();
+        __classPrivateFieldSet(this, _CommandManager_locked, false, "f");
+        __classPrivateFieldSet(this, _CommandManager_position, __classPrivateFieldGet(this, _CommandManager_position, "f") - 1, "f");
+    }
+    /**
+     * Redo the last command.
+     */
+    redo() {
+        if (__classPrivateFieldGet(this, _CommandManager_position, "f") < __classPrivateFieldGet(this, _CommandManager_commands, "f").length - 1) {
+            __classPrivateFieldSet(this, _CommandManager_position, __classPrivateFieldGet(this, _CommandManager_position, "f") + 1, "f");
+            // Avoid to insert something during the redo execution.
+            __classPrivateFieldSet(this, _CommandManager_locked, true, "f");
+            const { cmd, post } = __classPrivateFieldGet(this, _CommandManager_commands, "f")[__classPrivateFieldGet(this, _CommandManager_position, "f")];
+            cmd();
+            post === null || post === void 0 ? void 0 : post();
+            __classPrivateFieldSet(this, _CommandManager_locked, false, "f");
+        }
+    }
+    /**
+     * Check if there is something to undo.
+     * @returns {boolean}
+     */
+    hasSomethingToUndo() {
+        return __classPrivateFieldGet(this, _CommandManager_position, "f") !== -1;
+    }
+    /**
+     * Check if there is something to redo.
+     * @returns {boolean}
+     */
+    hasSomethingToRedo() {
+        return __classPrivateFieldGet(this, _CommandManager_position, "f") < __classPrivateFieldGet(this, _CommandManager_commands, "f").length - 1;
+    }
+    destroy() {
+        __classPrivateFieldSet(this, _CommandManager_commands, null, "f");
+    }
+}
+_CommandManager_commands = new WeakMap(), _CommandManager_locked = new WeakMap(), _CommandManager_maxSize = new WeakMap(), _CommandManager_position = new WeakMap();

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

@@ -0,0 +1,34 @@
+/* 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 _IdManager_id;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { AnnotationEditorPrefix } from "../shared/utils";
+export class IdManager {
+    constructor(idPrefix = AnnotationEditorPrefix) {
+        _IdManager_id.set(this, 0);
+        this.idPrefix = AnnotationEditorPrefix;
+        // if (typeof PDFJSDev !== "undefined" && PDFJSDev.test("TESTING")) {
+        Object.defineProperty(this, "reset", {
+            value: () => (__classPrivateFieldSet(this, _IdManager_id, 0, "f"))
+        });
+        // }
+        this.idPrefix = idPrefix;
+    }
+    get id() {
+        var _a, _b;
+        return `${this.idPrefix}${__classPrivateFieldSet(this, _IdManager_id, (_b = __classPrivateFieldGet(this, _IdManager_id, "f"), _a = _b++, _b), "f"), _a}`;
+    }
+}
+_IdManager_id = new WeakMap();