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

package/dist/npm/annotations/annotation-editor-layer-builder.d.ts

@@ -0,0 +1,39 @@
+/** @typedef {import("../src/display/api").PDFPageProxy} PDFPageProxy */
+/** @typedef {import("../src/display/display_utils").PageViewport} PageViewport */
+/** @typedef {import("../src/display/editor/tools.js").AnnotationEditorUIManager} AnnotationEditorUIManager */
+/** @typedef {import("./text_accessibility.js").TextAccessibilityManager} TextAccessibilityManager */
+/** @typedef {import("./interfaces").IL10n} IL10n */
+/** @typedef {import("../src/display/annotation_layer.js").AnnotationLayer} AnnotationLayer */
+import { AnnotationEditorLayer } from "./annotation-editor-layer";
+/**
+ * @typedef {Object} AnnotationEditorLayerBuilderOptions
+ * @property {AnnotationEditorUIManager} [uiManager]
+ * @property {PDFPageProxy} pdfPage
+ * @property {IL10n} [l10n]
+ * @property {TextAccessibilityManager} [accessibilityManager]
+ * @property {AnnotationLayer} [annotationLayer]
+ * @property {TextLayer} [textLayer]
+ * @property {DrawLayer} [drawLayer]
+ * @property {function} [onAppend]
+ */
+declare class AnnotationEditorLayerBuilder {
+    #private;
+    pdfPage: any;
+    annotationEditorLayer: AnnotationEditorLayer;
+    _cancelled: any;
+    div: any;
+    accessibilityManager: any;
+    /**
+     * @param {AnnotationEditorLayerBuilderOptions} options
+     */
+    constructor(options: any);
+    /**
+     * @param {PageViewport} viewport
+     * @param {string} intent (default value is 'display')
+     */
+    render(viewport: any, intent?: string): Promise<void>;
+    cancel(): void;
+    hide(): void;
+    show(): void;
+}
+export { AnnotationEditorLayerBuilder };

package/dist/npm/annotations/annotation-editor-layer-builder.js

@@ -0,0 +1,142 @@
+"use strict";
+/* 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 _AnnotationEditorLayerBuilder_annotationLayer, _AnnotationEditorLayerBuilder_drawLayer, _AnnotationEditorLayerBuilder_onAppend, _AnnotationEditorLayerBuilder_textLayer, _AnnotationEditorLayerBuilder_uiManager;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnnotationEditorLayerBuilder = void 0;
+const tslib_1 = require("tslib");
+/** @typedef {import("../src/display/api").PDFPageProxy} PDFPageProxy */
+// eslint-disable-next-line max-len
+/** @typedef {import("../src/display/display_utils").PageViewport} PageViewport */
+// eslint-disable-next-line max-len
+/** @typedef {import("../src/display/editor/tools.js").AnnotationEditorUIManager} AnnotationEditorUIManager */
+// eslint-disable-next-line max-len
+/** @typedef {import("./text_accessibility.js").TextAccessibilityManager} TextAccessibilityManager */
+/** @typedef {import("./interfaces").IL10n} IL10n */
+// eslint-disable-next-line max-len
+/** @typedef {import("../src/display/annotation_layer.js").AnnotationLayer} AnnotationLayer */
+const annotation_editor_layer_1 = require("./annotation-editor-layer");
+// import { GenericL10n } from "web-null_l10n";
+/**
+ * @typedef {Object} AnnotationEditorLayerBuilderOptions
+ * @property {AnnotationEditorUIManager} [uiManager]
+ * @property {PDFPageProxy} pdfPage
+ * @property {IL10n} [l10n]
+ * @property {TextAccessibilityManager} [accessibilityManager]
+ * @property {AnnotationLayer} [annotationLayer]
+ * @property {TextLayer} [textLayer]
+ * @property {DrawLayer} [drawLayer]
+ * @property {function} [onAppend]
+ */
+class AnnotationEditorLayerBuilder {
+    /**
+     * @param {AnnotationEditorLayerBuilderOptions} options
+     */
+    constructor(options) {
+        // todo: props
+        this.pdfPage = null;
+        this.annotationEditorLayer = null;
+        this._cancelled = null;
+        this.div = null;
+        this.accessibilityManager = null;
+        // todo: props
+        _AnnotationEditorLayerBuilder_annotationLayer.set(this, null);
+        _AnnotationEditorLayerBuilder_drawLayer.set(this, null);
+        _AnnotationEditorLayerBuilder_onAppend.set(this, null);
+        _AnnotationEditorLayerBuilder_textLayer.set(this, null);
+        _AnnotationEditorLayerBuilder_uiManager.set(this, null);
+        this.pdfPage = options.pdfPage;
+        this.accessibilityManager = options.accessibilityManager;
+        // this.l10n = options.l10n;
+        // if (typeof PDFJSDev === "undefined" || PDFJSDev.test("GENERIC")) {
+        // this.l10n ||= new GenericL10n();
+        // }
+        this.annotationEditorLayer = null;
+        this.div = null;
+        this._cancelled = false;
+        tslib_1.__classPrivateFieldSet(this, _AnnotationEditorLayerBuilder_uiManager, options.uiManager, "f");
+        tslib_1.__classPrivateFieldSet(this, _AnnotationEditorLayerBuilder_annotationLayer, options.annotationLayer || null, "f");
+        tslib_1.__classPrivateFieldSet(this, _AnnotationEditorLayerBuilder_textLayer, options.textLayer || null, "f");
+        tslib_1.__classPrivateFieldSet(this, _AnnotationEditorLayerBuilder_drawLayer, options.drawLayer || null, "f");
+        tslib_1.__classPrivateFieldSet(this, _AnnotationEditorLayerBuilder_onAppend, options.onAppend || null, "f");
+    }
+    /**
+     * @param {PageViewport} viewport
+     * @param {string} intent (default value is 'display')
+     */
+    render(viewport_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (viewport, intent = "display") {
+            var _a;
+            if (intent !== "display") {
+                return;
+            }
+            if (this._cancelled) {
+                return;
+            }
+            const clonedViewport = viewport.clone({ dontFlip: true });
+            if (this.div) {
+                this.annotationEditorLayer.update({ viewport: clonedViewport });
+                this.show();
+                return;
+            }
+            // Create an AnnotationEditor layer div
+            const div = (this.div = document.createElement("div"));
+            div.className = "k-annotation-editor-layer annotationEditorLayer";
+            div.hidden = true;
+            div.dir = tslib_1.__classPrivateFieldGet(this, _AnnotationEditorLayerBuilder_uiManager, "f").direction;
+            (_a = tslib_1.__classPrivateFieldGet(this, _AnnotationEditorLayerBuilder_onAppend, "f")) === null || _a === void 0 ? void 0 : _a.call(this, div);
+            this.annotationEditorLayer = new annotation_editor_layer_1.AnnotationEditorLayer({
+                uiManager: tslib_1.__classPrivateFieldGet(this, _AnnotationEditorLayerBuilder_uiManager, "f"),
+                div,
+                accessibilityManager: this.accessibilityManager,
+                pageIndex: this.pdfPage.pageNumber - 1,
+                // l10n: this.l10n,
+                viewport: clonedViewport,
+                annotationLayer: tslib_1.__classPrivateFieldGet(this, _AnnotationEditorLayerBuilder_annotationLayer, "f"),
+                textLayer: tslib_1.__classPrivateFieldGet(this, _AnnotationEditorLayerBuilder_textLayer, "f"),
+                drawLayer: tslib_1.__classPrivateFieldGet(this, _AnnotationEditorLayerBuilder_drawLayer, "f"),
+            });
+            const parameters = {
+                viewport: clonedViewport,
+                div,
+                annotations: null,
+                intent,
+            };
+            this.annotationEditorLayer.render(parameters);
+            this.show();
+        });
+    }
+    cancel() {
+        this._cancelled = true;
+        if (!this.div) {
+            return;
+        }
+        this.annotationEditorLayer.destroy();
+    }
+    hide() {
+        if (!this.div) {
+            return;
+        }
+        this.div.hidden = true;
+    }
+    show() {
+        if (!this.div || this.annotationEditorLayer.isInvisible) {
+            return;
+        }
+        this.div.hidden = false;
+    }
+}
+exports.AnnotationEditorLayerBuilder = AnnotationEditorLayerBuilder;
+_AnnotationEditorLayerBuilder_annotationLayer = new WeakMap(), _AnnotationEditorLayerBuilder_drawLayer = new WeakMap(), _AnnotationEditorLayerBuilder_onAppend = new WeakMap(), _AnnotationEditorLayerBuilder_textLayer = new WeakMap(), _AnnotationEditorLayerBuilder_uiManager = new WeakMap();

package/dist/npm/annotations/annotation-editor-layer.d.ts

@@ -0,0 +1,196 @@
+/** @typedef {import("./tools.js").AnnotationEditorUIManager} AnnotationEditorUIManager */
+/** @typedef {import("../display_utils.js").PageViewport} PageViewport */
+/** @typedef {import("../../../web/text_accessibility.js").TextAccessibilityManager} TextAccessibilityManager */
+/** @typedef {import("../../../web/interfaces").IL10n} IL10n */
+/** @typedef {import("../annotation_layer.js").AnnotationLayer} AnnotationLayer */
+/** @typedef {import("../draw_layer.js").DrawLayer} DrawLayer */
+import { FreeTextEditor } from "./editors/free-text-editor";
+import { HighlightEditor } from "./editors/highlight-editor";
+declare class AnnotationEditorLayer {
+    #private;
+    drawLayer: any;
+    pageIndex: number;
+    div: any;
+    viewport: any;
+    static _initialized: boolean;
+    /**
+     * @param {AnnotationEditorLayerOptions} options
+     */
+    constructor({ uiManager, pageIndex, div, accessibilityManager, annotationLayer, drawLayer, textLayer, viewport }: {
+        uiManager: any;
+        pageIndex: any;
+        div: any;
+        accessibilityManager: any;
+        annotationLayer: any;
+        drawLayer: any;
+        textLayer: any;
+        viewport: any;
+    });
+    hide(): void;
+    show(): void;
+    get isEmpty(): boolean;
+    get isInvisible(): boolean;
+    /**
+     * Update the toolbar if it's required to reflect the tool currently used.
+     * @param {number} mode
+     */
+    updateToolbar(): void;
+    /**
+     * The mode has changed: it must be updated.
+     * @param {number} mode
+     */
+    updateMode(mode?: number): void;
+    hasTextLayer(textLayer: any): boolean;
+    addInkEditorIfNeeded(isCommitting: any): void;
+    /**
+     * Set the editing state.
+     * @param {boolean} isEditing
+     */
+    setEditingState(isEditing: any): void;
+    /**
+     * Add some commands into the CommandManager (undo/redo stuff).
+     * @param {Object} params
+     */
+    addCommands(params: any): void;
+    toggleDrawing(enabled?: boolean): void;
+    togglePointerEvents(enabled?: boolean): void;
+    toggleAnnotationLayerPointerEvents(enabled?: boolean): void;
+    /**
+     * Enable pointer events on the main div in order to enable
+     * editor creation.
+     */
+    enable(): void;
+    /**
+     * Disable editor creation.
+     */
+    disable(): void;
+    getEditableAnnotation(id: any): any;
+    /**
+     * Set the current editor.
+     * @param {AnnotationEditor} editor
+     */
+    setActiveEditor(editor: any): void;
+    enableTextSelection(): void;
+    disableTextSelection(): void;
+    enableClick(): void;
+    disableClick(): void;
+    attach(editor: any): void;
+    detach(editor: any): void;
+    /**
+     * Remove an editor.
+     * @param {AnnotationEditor} editor
+     */
+    remove(editor: any): void;
+    /**
+     * An editor can have a different parent, for example after having
+     * being dragged and droped from a page to another.
+     * @param {AnnotationEditor} editor
+     */
+    changeParent(editor: any): void;
+    /**
+     * Add a new editor in the current view.
+     * @param {AnnotationEditor} editor
+     */
+    add(editor: any): void;
+    moveEditorInDOM(editor: any): void;
+    /**
+     * Add or rebuild depending if it has been removed or not.
+     * @param {AnnotationEditor} editor
+     */
+    addOrRebuild(editor: any): void;
+    /**
+     * Add a new editor and make this addition undoable.
+     * @param {AnnotationEditor} editor
+     */
+    addUndoableEditor(editor: any): void;
+    /**
+     * Get an id for an editor.
+     * @returns {string}
+     */
+    getNextId(): string;
+    combinedSignal(abortController: any): any;
+    canCreateNewEmptyEditor(): boolean;
+    /**
+     * Paste some content into a new editor.
+     * @param {number} mode
+     * @param {Object} params
+     */
+    pasteEditor(mode: any, params: any): void;
+    /**
+     * Create a new editor
+     * @param {Object} data
+     * @returns {AnnotationEditor | null}
+     */
+    deserialize(data: any): any;
+    /**
+     * Create and add a new editor.
+     * @param {PointerEvent} event
+     * @param {boolean} isCentered
+     * @param [Object] data
+     * @returns {AnnotationEditor}
+     */
+    createAndAddNewEditor(event: any, isCentered: any, data?: {}): FreeTextEditor | HighlightEditor;
+    /**
+     * Create and add a new editor.
+     */
+    addNewEditor(): void;
+    /**
+     * Set the last selected editor.
+     * @param {AnnotationEditor} editor
+     */
+    setSelected(editor: any): void;
+    /**
+     * Add or remove an editor the current selection.
+     * @param {AnnotationEditor} editor
+     */
+    toggleSelected(editor: any): void;
+    /**
+     * Check if the editor is selected.
+     * @param {AnnotationEditor} editor
+     */
+    isSelected(editor: any): boolean;
+    /**
+     * Unselect an editor.
+     * @param {AnnotationEditor} editor
+     */
+    unselect(editor: any): void;
+    /**
+     * Pointerup callback.
+     * @param {PointerEvent} event
+     */
+    pointerup(event: any): void;
+    /**
+     * Pointerdown callback.
+     * @param {PointerEvent} event
+     */
+    pointerdown(event: any): void;
+    /**
+     *
+     * @param {AnnotationEditor} editor
+     * @param {number} x
+     * @param {number} y
+     * @returns
+     */
+    findNewParent(editor: any, x: any, y: any): boolean;
+    /**
+     * Destroy the main editor.
+     */
+    destroy(): void;
+    /**
+     * Render the main editor.
+     * @param {RenderEditorLayerOptions} parameters
+     */
+    render({ viewport }: {
+        viewport: any;
+    }): void;
+    update({ viewport }: {
+        viewport: any;
+    }): void;
+    /**
+     * Get page dimensions.
+     * @returns {Object} dimensions.
+     */
+    get pageDimensions(): any[];
+    get scale(): any;
+}
+export { AnnotationEditorLayer };