@foxycape/core 1.1.3

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

@@ -0,0 +1,229 @@
+export type AnnotationEditorUIManager = import("./tools.js").AnnotationEditorUIManager;
+export type PageViewport = import("../display_utils.js").PageViewport;
+export type TextAccessibilityManager = import("../../../web/text_accessibility.js").TextAccessibilityManager;
+export type IL10n = import("../../../web/interfaces").IL10n;
+export type AnnotationLayer = import("../annotation_layer.js").AnnotationLayer;
+export type DrawLayer = import("../draw_layer.js").DrawLayer;
+export type StructTreeLayerBuilder = any;
+export type AnnotationEditorLayerOptions = {
+    mode: Object;
+    div: HTMLDivElement;
+    structTreeLayer: StructTreeLayerBuilder;
+    uiManager: AnnotationEditorUIManager;
+    enabled: boolean;
+    accessibilityManager?: import("../../../web/text_accessibility.js").TextAccessibilityManager | undefined;
+    pageIndex: number;
+    l10n: IL10n;
+    annotationLayer?: import("../annotation_layer.js").AnnotationLayer | undefined;
+    textLayer?: HTMLDivElement | undefined;
+    drawLayer: DrawLayer;
+    viewport: PageViewport;
+};
+export type RenderEditorLayerOptions = {
+    viewport: PageViewport;
+};
+/**
+ * @typedef {Object} AnnotationEditorLayerOptions
+ * @property {Object} mode
+ * @property {HTMLDivElement} div
+ * @property {StructTreeLayerBuilder} structTreeLayer
+ * @property {AnnotationEditorUIManager} uiManager
+ * @property {boolean} enabled
+ * @property {TextAccessibilityManager} [accessibilityManager]
+ * @property {number} pageIndex
+ * @property {IL10n} l10n
+ * @property {AnnotationLayer} [annotationLayer]
+ * @property {HTMLDivElement} [textLayer]
+ * @property {DrawLayer} drawLayer
+ * @property {PageViewport} viewport
+ */
+/**
+ * @typedef {Object} RenderEditorLayerOptions
+ * @property {PageViewport} viewport
+ */
+/**
+ * Manage all the different editors on a page.
+ */
+export class AnnotationEditorLayer {
+    static _initialized: boolean;
+    static "__#29@#editorTypes": Map<number, typeof FreeTextEditor | typeof HighlightEditor | typeof InkEditor | typeof StampEditor>;
+    /**
+     * @param {AnnotationEditorLayerOptions} options
+     */
+    constructor({ uiManager, pageIndex, div, structTreeLayer, accessibilityManager, annotationLayer, drawLayer, textLayer, viewport, l10n, }: AnnotationEditorLayerOptions);
+    pageIndex: number;
+    div: HTMLDivElement;
+    viewport: import("../display_utils.js").PageViewport;
+    drawLayer: import("../draw_layer.js").DrawLayer;
+    _structTree: any;
+    get isEmpty(): boolean;
+    get isInvisible(): 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;
+    hasTextLayer(textLayer: any): boolean;
+    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;
+    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(): Promise<void>;
+    /**
+     * Disable editor creation.
+     */
+    disable(): void;
+    getEditableAnnotation(id: any): any;
+    /**
+     * Set the current editor.
+     * @param {AnnotationEditor} editor
+     */
+    setActiveEditor(editor: AnnotationEditor): 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: 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;
+    combinedSignal(ac: any): AbortSignal;
+    canCreateNewEmptyEditor(): boolean | undefined;
+    /**
+     * 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 | null}
+     */
+    deserialize(data: Object): AnnotationEditor | null;
+    /**
+     * Create and add a new editor.
+     * @param {PointerEvent} event
+     * @param {boolean} isCentered
+     * @param [Object] data
+     * @returns {AnnotationEditor}
+     */
+    createAndAddNewEditor(event: PointerEvent, isCentered: boolean, data?: {}): 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;
+    get scale(): number;
+    #private;
+}
+import { AnnotationEditor } from "./editor.js";
+import { FreeTextEditor } from "./freetext.js";
+import { HighlightEditor } from "./highlight.js";
+import { InkEditor } from "./ink.js";
+import { StampEditor } from "./stamp.js";

package/dist/pdfjs/types/src/display/editor/color_picker.d.ts

@@ -0,0 +1,20 @@
+export class ColorPicker {
+    static "__#24@#l10nColor": null;
+    static get _keyboardManager(): any;
+    constructor({ editor, uiManager }: {
+        editor?: null | undefined;
+        uiManager?: null | undefined;
+    });
+    renderButton(): HTMLButtonElement;
+    renderMainDropdown(): HTMLDivElement;
+    _colorSelectFromKeyboard(event: any): void;
+    _moveToNext(event: any): void;
+    _moveToPrevious(event: any): void;
+    _moveToBeginning(event: any): void;
+    _moveToEnd(event: any): void;
+    hideDropdown(): void;
+    _hideDropdownFromKeyboard(): void;
+    updateColor(color: any): void;
+    destroy(): void;
+    #private;
+}

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

@@ -0,0 +1,439 @@
+export type AnnotationEditorLayer = import("./annotation_editor_layer.js").AnnotationEditorLayer;
+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 _l10nPromise: null;
+    static _l10nResizer: null;
+    static _borderLineWidth: number;
+    static _colorManager: ColorManager;
+    static _zIndex: number;
+    static _telemetryTimeout: number;
+    static get _resizerKeyboardManager(): any;
+    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, _uiManager: any, options: any): 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: string): 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 "__#36@#rotatePoint"(x: any, y: any, angle: any): any[];
+    /**
+     * Deserialize the editor.
+     * The result of the deserialization is a new editor.
+     *
+     * @param {Object} data
+     * @param {AnnotationEditorLayer} parent
+     * @param {AnnotationEditorUIManager} uiManager
+     * @returns {Promise<AnnotationEditor | null>}
+     */
+    static deserialize(data: Object, parent: AnnotationEditorLayer, uiManager: AnnotationEditorUIManager): Promise<AnnotationEditor | null>;
+    static get MIN_SIZE(): number;
+    static canCreateNewEmptyEditor(): boolean;
+    /**
+     * @param {AnnotationEditorParameters} parameters
+     */
+    constructor(parameters: AnnotationEditorParameters);
+    _editToolbar: null;
+    _initialOptions: any;
+    _initialData: null;
+    _isVisible: boolean;
+    _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;
+    _structTreeParentId: any;
+    rotation: number;
+    pageRotation: number;
+    pageDimensions: any[];
+    pageTranslation: any[];
+    x: number;
+    y: number;
+    isAttachedToDOM: boolean;
+    deleted: boolean;
+    get editorType(): any;
+    /**
+     * Get the properties to update in the UI for this editor.
+     * @returns {Array}
+     */
+    get propertiesToUpdate(): any[];
+    set _isDraggable(value: boolean);
+    get _isDraggable(): boolean;
+    /**
+     * @returns {boolean} true if the editor handles the Enter key itself.
+     */
+    get isEnterHandled(): 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;
+    get _hasBeenMoved(): boolean;
+    /**
+     * Get the translation to take into account the editor border.
+     * The CSS engine positions the element by taking the border into account so
+     * we must apply the opposite translation to have the editor in the right
+     * position.
+     * @returns {Array<number>}
+     */
+    getBaseTranslation(): Array<number>;
+    /**
+     * @returns {boolean} true if position must be fixed (i.e. make the x and y
+     * living in the page).
+     */
+    get _mustFixPosition(): boolean;
+    /**
+     * Fix the position of the editor in order to keep it inside its parent page.
+     * @param {number} [rotation] - the rotation of the page.
+     */
+    fixAndSetPosition(rotation?: number | undefined): 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>;
+    /**
+     * Called when the alt text dialog is closed.
+     */
+    altTextFinish(): void;
+    /**
+     * Add a toolbar for this editor.
+     * @returns {Promise<EditorToolbar|null>}
+     */
+    addEditToolbar(): Promise<EditorToolbar | null>;
+    removeEditToolbar(): void;
+    addContainer(container: any): void;
+    getClientDimensions(): DOMRect;
+    addAltTextButton(): Promise<void>;
+    /**
+     * Set the alt text data.
+     */
+    set altTextData(data: any);
+    get altTextData(): any;
+    get guessedAltText(): any;
+    setGuessedAltText(text: any): Promise<void>;
+    serializeAltText(isForCopying: any): any;
+    hasAltText(): boolean;
+    hasAltTextData(): any;
+    /**
+     * Render this editor in a div.
+     * @returns {HTMLDivElement | null}
+     */
+    render(): HTMLDivElement | null;
+    /**
+     * 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.
+     * @param {number} tx - x-translation in screen coordinates.
+     * @param {number} ty - y-translation in screen coordinates.
+     * @param {number} [rotation] - the rotation of the page.
+     */
+    getRect(tx: number, ty: number, rotation?: number | undefined): 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 handles 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;
+    /**
+     * Rotate the editor.
+     * @param {number} angle
+     */
+    rotate(_angle: any): void;
+    /**
+     * Serialize the editor when it has been deleted.
+     * @returns {Object}
+     */
+    serializeDeleted(): Object;
+    /**
+     * 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 | null} [context]
+     * @returns {Object | null}
+     */
+    serialize(isForCopying?: boolean | undefined, context?: Object | null | undefined): Object | null;
+    /**
+     * Check if an existing annotation associated with this editor has been
+     * modified.
+     * @returns {boolean}
+     */
+    get hasBeenModified(): boolean;
+    /**
+     * 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;
+    get toolbarPosition(): null;
+    /**
+     * onkeydown callback.
+     * @param {KeyboardEvent} event
+     */
+    keydown(event: KeyboardEvent): void;
+    _resizeWithKeyboard(x: any, y: any): void;
+    _stopResizingWithKeyboard(): 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;
+    /**
+     * @returns {HTMLElement | null} the element requiring an alt text.
+     */
+    getImageForAltText(): HTMLElement | null;
+    /**
+     * Get the div which really contains the displayed content.
+     * @returns {HTMLDivElement | undefined}
+     */
+    get contentDiv(): HTMLDivElement | undefined;
+    /**
+     * When set to true, it means that this editor is currently edited.
+     * @param {boolean} value
+     */
+    set isEditing(value: 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;
+    /**
+     * Get the data to report to the telemetry when the editor is added.
+     * @returns {Object}
+     */
+    get telemetryInitialData(): Object;
+    /**
+     * The telemetry data to use when saving/printing.
+     * @returns {Object|null}
+     */
+    get telemetryFinalData(): Object | null;
+    _reportTelemetry(data: any, mustWait?: boolean): void;
+    /**
+     * Show or hide this editor.
+     * @param {boolean|undefined} visible
+     */
+    show(visible?: boolean | undefined): void;
+    enable(): void;
+    disable(): void;
+    /**
+     * Render an annotation in the annotation layer.
+     * @param {Object} annotation
+     * @returns {HTMLElement|null}
+     */
+    renderAnnotationElement(annotation: Object): HTMLElement | null;
+    resetAnnotationElement(annotation: any): void;
+    #private;
+}
+import { AnnotationEditorUIManager } from "./tools.js";
+import { EditorToolbar } from "./toolbar.js";
+import { ColorManager } from "./tools.js";