@divriots/pdfjs-dist 3.10.111-divriots2.0

package/types/src/display/editor/annotation_editor_layer.d.ts

@@ -0,0 +1,196 @@
+export type AnnotationEditorUIManager = import("./tools.js").AnnotationEditorUIManager;
+export type PageViewport = import("../display_utils.js").PageViewport;
+export type TextAccessibilityManager = any;
+export type IL10n = any;
+export type AnnotationLayer = any;
+export type AnnotationEditorLayerOptions = {
+    mode: Object;
+    div: HTMLDivElement;
+    uiManager: AnnotationEditorUIManager;
+    enabled: boolean;
+    accessibilityManager?: any;
+    pageIndex: number;
+    l10n: any;
+    annotationLayer?: any;
+    viewport: PageViewport;
+};
+export type RenderEditorLayerOptions = {
+    viewport: PageViewport;
+};
+/**
+ * @typedef {Object} AnnotationEditorLayerOptions
+ * @property {Object} mode
+ * @property {HTMLDivElement} div
+ * @property {AnnotationEditorUIManager} uiManager
+ * @property {boolean} enabled
+ * @property {TextAccessibilityManager} [accessibilityManager]
+ * @property {number} pageIndex
+ * @property {IL10n} l10n
+ * @property {AnnotationLayer} [annotationLayer]
+ * @property {PageViewport} viewport
+ */
+/**
+ * @typedef {Object} RenderEditorLayerOptions
+ * @property {PageViewport} viewport
+ */
+/**
+ * Manage all the different editors on a page.
+ */
+export class AnnotationEditorLayer {
+    static _initialized: boolean;
+    /**
+     * @param {AnnotationEditorLayerOptions} options
+     */
+    constructor({ uiManager, pageIndex, div, accessibilityManager, annotationLayer, viewport, l10n, }: AnnotationEditorLayerOptions);
+    pageIndex: number;
+    div: HTMLDivElement;
+    viewport: import("../display_utils.js").PageViewport;
+    get isEmpty(): boolean;
+    /**
+     * Update the toolbar if it's required to reflect the tool currently used.
+     * @param {number} mode
+     */
+    updateToolbar(mode: number): void;
+    /**
+     * The mode has changed: it must be updated.
+     * @param {number} mode
+     */
+    updateMode(mode?: number): void;
+    addInkEditorIfNeeded(isCommitting: any): void;
+    /**
+     * Set the editing state.
+     * @param {boolean} isEditing
+     */
+    setEditingState(isEditing: boolean): void;
+    /**
+     * Add some commands into the CommandManager (undo/redo stuff).
+     * @param {Object} params
+     */
+    addCommands(params: Object): 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: AnnotationEditor): void;
+    enableClick(): void;
+    disableClick(): void;
+    attach(editor: any): void;
+    detach(editor: any): void;
+    /**
+     * Remove an editor.
+     * @param {AnnotationEditor} editor
+     */
+    remove(editor: AnnotationEditor): 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: AnnotationEditor): void;
+    /**
+     * Add a new editor in the current view.
+     * @param {AnnotationEditor} editor
+     */
+    add(editor: AnnotationEditor): void;
+    moveEditorInDOM(editor: any): void;
+    /**
+     * Add or rebuild depending if it has been removed or not.
+     * @param {AnnotationEditor} editor
+     */
+    addOrRebuild(editor: AnnotationEditor): void;
+    /**
+     * Add a new editor and make this addition undoable.
+     * @param {AnnotationEditor} editor
+     */
+    addUndoableEditor(editor: AnnotationEditor): void;
+    /**
+     * Get an id for an editor.
+     * @returns {string}
+     */
+    getNextId(): string;
+    /**
+     * Paste some content into a new editor.
+     * @param {number} mode
+     * @param {Object} params
+     */
+    pasteEditor(mode: number, params: Object): void;
+    /**
+     * Create a new editor
+     * @param {Object} data
+     * @returns {AnnotationEditor}
+     */
+    deserialize(data: Object): AnnotationEditor;
+    /**
+     * Create and add a new editor.
+     */
+    addNewEditor(): void;
+    /**
+     * Set the last selected editor.
+     * @param {AnnotationEditor} editor
+     */
+    setSelected(editor: AnnotationEditor): void;
+    /**
+     * Add or remove an editor the current selection.
+     * @param {AnnotationEditor} editor
+     */
+    toggleSelected(editor: AnnotationEditor): void;
+    /**
+     * Check if the editor is selected.
+     * @param {AnnotationEditor} editor
+     */
+    isSelected(editor: AnnotationEditor): boolean;
+    /**
+     * Unselect an editor.
+     * @param {AnnotationEditor} editor
+     */
+    unselect(editor: AnnotationEditor): void;
+    /**
+     * Pointerup callback.
+     * @param {PointerEvent} event
+     */
+    pointerup(event: PointerEvent): void;
+    /**
+     * Pointerdown callback.
+     * @param {PointerEvent} event
+     */
+    pointerdown(event: PointerEvent): void;
+    /**
+     *
+     * @param {AnnotationEditor} editor
+     * @param {number} x
+     * @param {number} y
+     * @returns
+     */
+    findNewParent(editor: AnnotationEditor, x: number, y: number): boolean;
+    /**
+     * Destroy the main editor.
+     */
+    destroy(): void;
+    /**
+     * Render the main editor.
+     * @param {RenderEditorLayerOptions} parameters
+     */
+    render({ viewport }: RenderEditorLayerOptions): void;
+    /**
+     * Update the main editor.
+     * @param {RenderEditorLayerOptions} parameters
+     */
+    update({ viewport }: RenderEditorLayerOptions): void;
+    /**
+     * Get page dimensions.
+     * @returns {Object} dimensions.
+     */
+    get pageDimensions(): Object;
+    #private;
+}
+import { AnnotationEditor } from "./editor.js";

package/types/src/display/editor/editor.d.ts

@@ -0,0 +1,325 @@
+export type AnnotationEditorLayer = import("./annotation_editor_layer.js").AnnotationEditorLayer;
+export type AnnotationEditorUIManager = import("./tools.js").AnnotationEditorUIManager;
+export type AnnotationEditorParameters = {
+    /**
+     * - the global manager
+     */
+    uiManager: AnnotationEditorUIManager;
+    /**
+     * - the layer containing this editor
+     */
+    parent: AnnotationEditorLayer;
+    /**
+     * - editor id
+     */
+    id: string;
+    /**
+     * - x-coordinate
+     */
+    x: number;
+    /**
+     * - y-coordinate
+     */
+    y: number;
+};
+/**
+ * @typedef {Object} AnnotationEditorParameters
+ * @property {AnnotationEditorUIManager} uiManager - the global manager
+ * @property {AnnotationEditorLayer} parent - the layer containing this editor
+ * @property {string} id - editor id
+ * @property {number} x - x-coordinate
+ * @property {number} y - y-coordinate
+ */
+/**
+ * Base class for editors.
+ */
+export class AnnotationEditor {
+    static _colorManager: ColorManager;
+    static _zIndex: number;
+    static get _defaultLineColor(): any;
+    static deleteAnnotationElement(editor: any): void;
+    /**
+     * Initialize the l10n stuff for this type of editor.
+     * @param {Object} _l10n
+     */
+    static initialize(_l10n: Object): void;
+    /**
+     * Update the default parameters for this type of editor.
+     * @param {number} _type
+     * @param {*} _value
+     */
+    static updateDefaultParams(_type: number, _value: any): void;
+    /**
+     * Get the default properties to set in the UI for this type of editor.
+     * @returns {Array}
+     */
+    static get defaultPropertiesToUpdate(): any[];
+    /**
+     * Check if this kind of editor is able to handle the given mime type for
+     * pasting.
+     * @param {string} mime
+     * @returns {boolean}
+     */
+    static isHandlingMimeForPasting(_mime: any): boolean;
+    /**
+     * Extract the data from the clipboard item and delegate the creation of the
+     * editor to the parent.
+     * @param {DataTransferItem} item
+     * @param {AnnotationEditorLayer} parent
+     */
+    static paste(item: DataTransferItem, parent: AnnotationEditorLayer): void;
+    static "__#23@#rotatePoint"(x: any, y: any, angle: any): any[];
+    static "__#23@#noContextMenu"(e: any): void;
+    /**
+     * Deserialize the editor.
+     * The result of the deserialization is a new editor.
+     *
+     * @param {Object} data
+     * @param {AnnotationEditorLayer} parent
+     * @param {AnnotationEditorUIManager} uiManager
+     * @returns {AnnotationEditor}
+     */
+    static deserialize(data: Object, parent: AnnotationEditorLayer, uiManager: AnnotationEditorUIManager): AnnotationEditor;
+    static get MIN_SIZE(): number;
+    /**
+     * @param {AnnotationEditorParameters} parameters
+     */
+    constructor(parameters: AnnotationEditorParameters);
+    _initialOptions: any;
+    _uiManager: null;
+    _focusEventsAllowed: boolean;
+    parent: import("./annotation_editor_layer.js").AnnotationEditorLayer;
+    id: string;
+    width: any;
+    height: any;
+    pageIndex: number;
+    name: any;
+    div: HTMLDivElement | null;
+    annotationElementId: any;
+    _willKeepAspectRatio: boolean;
+    rotation: number;
+    pageRotation: number;
+    pageDimensions: any[];
+    pageTranslation: any[];
+    x: number;
+    y: number;
+    isAttachedToDOM: boolean;
+    deleted: boolean;
+    /**
+     * Get the properties to update in the UI for this editor.
+     * @returns {Array}
+     */
+    get propertiesToUpdate(): any[];
+    set _isDraggable(arg: boolean);
+    get _isDraggable(): boolean;
+    center(): void;
+    /**
+     * Add some commands into the CommandManager (undo/redo stuff).
+     * @param {Object} params
+     */
+    addCommands(params: Object): void;
+    get currentLayer(): any;
+    /**
+     * This editor will be behind the others.
+     */
+    setInBackground(): void;
+    /**
+     * This editor will be in the foreground.
+     */
+    setInForeground(): void;
+    setParent(parent: any): void;
+    /**
+     * onfocus callback.
+     */
+    focusin(event: any): void;
+    /**
+     * onblur callback.
+     * @param {FocusEvent} event
+     */
+    focusout(event: FocusEvent): void;
+    commitOrRemove(): void;
+    /**
+     * Commit the data contained in this editor.
+     */
+    commit(): void;
+    addToAnnotationStorage(): void;
+    /**
+     * Set the editor position within its parent.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} tx - x-translation in screen coordinates.
+     * @param {number} ty - y-translation in screen coordinates.
+     */
+    setAt(x: number, y: number, tx: number, ty: number): void;
+    /**
+     * Translate the editor position within its parent.
+     * @param {number} x - x-translation in screen coordinates.
+     * @param {number} y - y-translation in screen coordinates.
+     */
+    translate(x: number, y: number): void;
+    /**
+     * Translate the editor position within its page and adjust the scroll
+     * in order to have the editor in the view.
+     * @param {number} x - x-translation in page coordinates.
+     * @param {number} y - y-translation in page coordinates.
+     */
+    translateInPage(x: number, y: number): void;
+    drag(tx: any, ty: any): void;
+    fixAndSetPosition(): void;
+    /**
+     * Convert a screen translation into a page one.
+     * @param {number} x
+     * @param {number} y
+     */
+    screenToPageTranslation(x: number, y: number): any[];
+    /**
+     * Convert a page translation into a screen one.
+     * @param {number} x
+     * @param {number} y
+     */
+    pageTranslationToScreen(x: number, y: number): any[];
+    get parentScale(): any;
+    get parentRotation(): number;
+    get parentDimensions(): number[];
+    /**
+     * Set the dimensions of this editor.
+     * @param {number} width
+     * @param {number} height
+     */
+    setDims(width: number, height: number): void;
+    fixDims(): void;
+    /**
+     * Get the translation used to position this editor when it's created.
+     * @returns {Array<number>}
+     */
+    getInitialTranslation(): Array<number>;
+    /**
+     * Render this editor in a div.
+     * @returns {HTMLDivElement}
+     */
+    render(): HTMLDivElement;
+    /**
+     * Onpointerdown callback.
+     * @param {PointerEvent} event
+     */
+    pointerdown(event: PointerEvent): void;
+    moveInDOM(): void;
+    _setParentAndPosition(parent: any, x: any, y: any): void;
+    /**
+     * Convert the current rect into a page one.
+     */
+    getRect(tx: any, ty: any): any[];
+    getRectInCurrentCoords(rect: any, pageHeight: any): any[];
+    /**
+     * Executed once this editor has been rendered.
+     */
+    onceAdded(): void;
+    /**
+     * Check if the editor contains something.
+     * @returns {boolean}
+     */
+    isEmpty(): boolean;
+    /**
+     * Enable edit mode.
+     */
+    enableEditMode(): void;
+    /**
+     * Disable edit mode.
+     */
+    disableEditMode(): void;
+    /**
+     * Check if the editor is edited.
+     * @returns {boolean}
+     */
+    isInEditMode(): boolean;
+    /**
+     * If it returns true, then this editor handle the keyboard
+     * events itself.
+     * @returns {boolean}
+     */
+    shouldGetKeyboardEvents(): boolean;
+    /**
+     * Check if this editor needs to be rebuilt or not.
+     * @returns {boolean}
+     */
+    needsToBeRebuilt(): boolean;
+    /**
+     * Rebuild the editor in case it has been removed on undo.
+     *
+     * To implement in subclasses.
+     */
+    rebuild(): void;
+    /**
+     * Serialize the editor.
+     * The result of the serialization will be used to construct a
+     * new annotation to add to the pdf document.
+     *
+     * To implement in subclasses.
+     * @param {boolean} isForCopying
+     * @param {Object} [context]
+     */
+    serialize(_isForCopying?: boolean, _context?: null): void;
+    /**
+     * Remove this editor.
+     * It's used on ctrl+backspace action.
+     */
+    remove(): void;
+    /**
+     * @returns {boolean} true if this editor can be resized.
+     */
+    get isResizable(): boolean;
+    /**
+     * Add the resizers to this editor.
+     */
+    makeResizable(): void;
+    /**
+     * Select this editor.
+     */
+    select(): void;
+    /**
+     * Unselect this editor.
+     */
+    unselect(): void;
+    /**
+     * Update some parameters which have been changed through the UI.
+     * @param {number} type
+     * @param {*} value
+     */
+    updateParams(type: number, value: any): void;
+    /**
+     * When the user disables the editing mode some editors can change some of
+     * their properties.
+     */
+    disableEditing(): void;
+    /**
+     * When the user enables the editing mode some editors can change some of
+     * their properties.
+     */
+    enableEditing(): void;
+    /**
+     * The editor is about to be edited.
+     */
+    enterInEditMode(): void;
+    /**
+     * Get the div which really contains the displayed content.
+     */
+    get contentDiv(): HTMLDivElement | null;
+    /**
+     * When set to true, it means that this editor is currently edited.
+     * @param {boolean} value
+     */
+    set isEditing(arg: boolean);
+    /**
+     * If true then the editor is currently edited.
+     * @type {boolean}
+     */
+    get isEditing(): boolean;
+    /**
+     * Set the aspect ratio to use when resizing.
+     * @param {number} width
+     * @param {number} height
+     */
+    setAspectRatio(width: number, height: number): void;
+    #private;
+}
+import { ColorManager } from "./tools.js";

package/types/src/display/editor/freetext.d.ts

@@ -0,0 +1,72 @@
+export type AnnotationEditorLayer = import("./annotation_editor_layer.js").AnnotationEditorLayer;
+/**
+ * Basic text editor in order to create a FreeTex annotation.
+ */
+export class FreeTextEditor extends AnnotationEditor {
+    static _freeTextDefaultContent: string;
+    static _l10nPromise: any;
+    static _internalPadding: number;
+    static _defaultColor: null;
+    static _defaultFontSize: number;
+    static get _keyboardManager(): any;
+    static _type: string;
+    /** @inheritdoc */
+    static initialize(l10n: any): void;
+    /** @inheritdoc */
+    static updateDefaultParams(type: any, value: any): void;
+    /** @inheritdoc */
+    static get defaultPropertiesToUpdate(): any[][];
+    /** @inheritdoc */
+    static deserialize(data: any, parent: any, uiManager: any): AnnotationEditor | null;
+    constructor(params: any);
+    /** @inheritdoc */
+    updateParams(type: any, value: any): void;
+    /** @inheritdoc */
+    get propertiesToUpdate(): any[][];
+    /**
+     * Helper to translate the editor with the keyboard when it's empty.
+     * @param {number} x in page units.
+     * @param {number} y in page units.
+     */
+    _translateEmpty(x: number, y: number): void;
+    /**
+     * Commit the content we have in this editor.
+     * @returns {undefined}
+     */
+    commit(): undefined;
+    /**
+     * ondblclick callback.
+     * @param {MouseEvent} event
+     */
+    dblclick(event: MouseEvent): void;
+    /**
+     * onkeydown callback.
+     * @param {KeyboardEvent} event
+     */
+    keydown(event: KeyboardEvent): void;
+    editorDivKeydown(event: any): void;
+    editorDivFocus(event: any): void;
+    editorDivBlur(event: any): void;
+    editorDivInput(event: any): void;
+    /** @inheritdoc */
+    render(): HTMLDivElement | null;
+    editorDiv: HTMLDivElement | undefined;
+    overlayDiv: HTMLDivElement | undefined;
+    get contentDiv(): HTMLDivElement | undefined;
+    /** @inheritdoc */
+    serialize(isForCopying?: boolean): {
+        annotationType: number;
+        color: number[];
+        fontSize: any;
+        value: string;
+        pageIndex: number;
+        rect: any[];
+        rotation: number;
+    } | {
+        pageIndex: number;
+        id: any;
+        deleted: boolean;
+    } | null;
+    #private;
+}
+import { AnnotationEditor } from "./editor.js";

package/types/src/display/editor/ink.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Basic draw editor in order to generate an Ink annotation.
+ */
+export class InkEditor extends AnnotationEditor {
+    static _defaultColor: null;
+    static _defaultOpacity: number;
+    static _defaultThickness: number;
+    static _l10nPromise: any;
+    static _type: string;
+    /** @inheritdoc */
+    static initialize(l10n: any): void;
+    /** @inheritdoc */
+    static updateDefaultParams(type: any, value: any): void;
+    /** @inheritdoc */
+    static get defaultPropertiesToUpdate(): any[][];
+    /**
+     * Convert into a Path2D.
+     * @param {Arra<Array<number>} bezier
+     * @returns {Path2D}
+     */
+    static "__#15@#buildPath2D"(bezier: Arra<number[]>): Path2D;
+    static "__#15@#toPDFCoordinates"(points: any, rect: any, rotation: any): any;
+    static "__#15@#fromPDFCoordinates"(points: any, rect: any, rotation: any): any;
+    /** @inheritdoc */
+    static deserialize(data: any, parent: any, uiManager: any): AnnotationEditor | null;
+    constructor(params: any);
+    color: any;
+    thickness: any;
+    opacity: any;
+    paths: any[];
+    bezierPath2D: any[];
+    allRawPaths: any[];
+    currentPath: any[];
+    scaleFactor: number;
+    translationX: number;
+    translationY: number;
+    /** @inheritdoc */
+    updateParams(type: any, value: any): void;
+    /** @inheritdoc */
+    get propertiesToUpdate(): any[][];
+    canvas: HTMLCanvasElement | null | undefined;
+    onScaleChanging(): void;
+    /**
+     * onpointerdown callback for the canvas we're drawing on.
+     * @param {PointerEvent} event
+     */
+    canvasPointerdown(event: PointerEvent): void;
+    /**
+     * oncontextmenu callback for the canvas we're drawing on.
+     * @param {PointerEvent} event
+     */
+    canvasContextMenu(event: PointerEvent): void;
+    /**
+     * onpointermove callback for the canvas we're drawing on.
+     * @param {PointerEvent} event
+     */
+    canvasPointermove(event: PointerEvent): void;
+    /**
+     * onpointerup callback for the canvas we're drawing on.
+     * @param {PointerEvent} event
+     */
+    canvasPointerup(event: PointerEvent): void;
+    /**
+     * onpointerleave callback for the canvas we're drawing on.
+     * @param {PointerEvent} event
+     */
+    canvasPointerleave(event: PointerEvent): void;
+    ctx: CanvasRenderingContext2D | null | undefined;
+    /** @inheritdoc */
+    render(): HTMLDivElement | null;
+    /**
+     * When the dimensions of the div change the inner canvas must
+     * renew its dimensions, hence it must redraw its own contents.
+     * @param {number} width - the new width of the div
+     * @param {number} height - the new height of the div
+     * @returns
+     */
+    setDimensions(width: number, height: number): void;
+    /** @inheritdoc */
+    serialize(): {
+        annotationType: number;
+        color: number[];
+        thickness: any;
+        opacity: any;
+        paths: {
+            bezier: any;
+            points: any;
+        }[];
+        pageIndex: number;
+        rect: any[];
+        rotation: number;
+    } | null;
+    #private;
+}
+import { AnnotationEditor } from "./editor.js";