@nocobase/plugin-file-manager 2.1.0-beta.35 → 2.1.0-beta.37

package/dist/node_modules/pdfjs-dist/types/web/struct_tree_layer_builder.d.ts

@@ -0,0 +1,25 @@
+export type PDFPageProxy = import("../src/display/api").PDFPageProxy;
+export type StructTreeLayerBuilderOptions = {
+    pdfPage: PDFPageProxy;
+    rawDims: Object;
+};
+/**
+ * @typedef {Object} StructTreeLayerBuilderOptions
+ * @property {PDFPageProxy} pdfPage
+ * @property {Object} rawDims
+ */
+export class StructTreeLayerBuilder {
+    /**
+     * @param {StructTreeLayerBuilderOptions} options
+     */
+    constructor(pdfPage: any, rawDims: any);
+    /**
+     * @returns {Promise<void>}
+     */
+    render(): Promise<void>;
+    getAriaAttributes(annotationId: any): Promise<any>;
+    hide(): void;
+    show(): void;
+    updateTextLayer(): void;
+    #private;
+}

package/dist/node_modules/pdfjs-dist/types/web/text_accessibility.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+export class TextAccessibilityManager {
+    /**
+     * Compare the positions of two elements, it must correspond to
+     * the visual ordering.
+     *
+     * @param {HTMLElement} e1
+     * @param {HTMLElement} e2
+     * @returns {number}
+     */
+    static "__#private@#compareElementPositions"(e1: HTMLElement, e2: HTMLElement): number;
+    setTextMapping(textDivs: any): void;
+    /**
+     * Function called when the text layer has finished rendering.
+     */
+    enable(): void;
+    disable(): void;
+    /**
+     * Remove an aria-owns id from a node in the text layer.
+     * @param {HTMLElement} element
+     */
+    removePointerInTextLayer(element: HTMLElement): void;
+    /**
+     * 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: HTMLElement, isRemovable: boolean): string | 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: any, element: HTMLDivElement, contentElement: any, isRemovable: any): string | null;
+    #private;
+}

package/dist/node_modules/pdfjs-dist/types/web/text_highlighter.d.ts

@@ -0,0 +1,63 @@
+export type EventBus = import("./event_utils").EventBus;
+export type PDFFindController = import("./pdf_find_controller").PDFFindController;
+export type TextHighlighterOptions = {
+    findController: PDFFindController;
+    /**
+     * - The application event bus.
+     */
+    eventBus: EventBus;
+    /**
+     * - The page index.
+     */
+    pageIndex: number;
+};
+/** @typedef {import("./event_utils").EventBus} EventBus */
+/** @typedef {import("./pdf_find_controller").PDFFindController} PDFFindController */
+/**
+ * @typedef {Object} TextHighlighterOptions
+ * @property {PDFFindController} findController
+ * @property {EventBus} eventBus - The application event bus.
+ * @property {number} pageIndex - The page index.
+ */
+/**
+ * TextHighlighter handles highlighting matches from the FindController in
+ * either the text layer or XFA layer depending on the type of document.
+ */
+export class TextHighlighter {
+    /**
+     * @param {TextHighlighterOptions} options
+     */
+    constructor({ findController, eventBus, pageIndex }: TextHighlighterOptions);
+    findController: import("./pdf_find_controller").PDFFindController;
+    matches: any[];
+    eventBus: import("./event_utils").EventBus;
+    pageIdx: number;
+    textDivs: Node[] | null;
+    textContentItemsStr: string[] | null;
+    enabled: boolean;
+    /**
+     * Store two arrays that will map DOM nodes to text they should contain.
+     * The arrays should be of equal length and the array element at each index
+     * should correspond to the other. e.g.
+     * `items[0] = "<span>Item 0</span>" and texts[0] = "Item 0";
+     *
+     * @param {Array<Node>} divs
+     * @param {Array<string>} texts
+     */
+    setTextMapping(divs: Array<Node>, texts: Array<string>): void;
+    /**
+     * Start listening for events to update the highlighter and check if there are
+     * any current matches that need be highlighted.
+     */
+    enable(): void;
+    disable(): void;
+    _convertMatches(matches: any, matchesLength: any): {
+        begin: {
+            divIdx: number;
+            offset: number;
+        };
+    }[];
+    _renderMatches(matches: any): void;
+    _updateMatches(reset?: boolean): void;
+    #private;
+}

package/dist/node_modules/pdfjs-dist/types/web/text_layer_builder.d.ts

@@ -0,0 +1,65 @@
+export type PDFPageProxy = import("../src/display/api").PDFPageProxy;
+export type PageViewport = import("../src/display/display_utils").PageViewport;
+export type TextHighlighter = import("./text_highlighter").TextHighlighter;
+export type TextAccessibilityManager = import("./text_accessibility.js").TextAccessibilityManager;
+export type TextLayerBuilderOptions = {
+    pdfPage: PDFPageProxy;
+    /**
+     * - Optional object that will handle
+     * highlighting text from the find controller.
+     */
+    highlighter?: import("./text_highlighter").TextHighlighter | undefined;
+    accessibilityManager?: import("./text_accessibility.js").TextAccessibilityManager | undefined;
+    enablePermissions?: boolean | undefined;
+    onAppend?: Function | undefined;
+};
+export type TextLayerBuilderRenderOptions = {
+    viewport: PageViewport;
+    textContentParams?: Object | undefined;
+};
+/**
+ * @typedef {Object} TextLayerBuilderOptions
+ * @property {PDFPageProxy} pdfPage
+ * @property {TextHighlighter} [highlighter] - Optional object that will handle
+ *   highlighting text from the find controller.
+ * @property {TextAccessibilityManager} [accessibilityManager]
+ * @property {boolean} [enablePermissions]
+ * @property {function} [onAppend]
+ */
+/**
+ * @typedef {Object} TextLayerBuilderRenderOptions
+ * @property {PageViewport} viewport
+ * @property {Object} [textContentParams]
+ */
+/**
+ * The text layer builder provides text selection functionality for the PDF.
+ * It does this by creating overlay divs over the PDF's text. These divs
+ * contain text that matches the PDF text they are overlaying.
+ */
+export class TextLayerBuilder {
+    static "__#private@#textLayers": Map<any, any>;
+    static "__#private@#selectionChangeAbortController": null;
+    static "__#private@#removeGlobalSelectionListener"(textLayerDiv: any): void;
+    static "__#private@#enableGlobalSelectionListener"(): void;
+    /**
+     * @param {TextLayerBuilderOptions} options
+     */
+    constructor({ pdfPage, highlighter, accessibilityManager, enablePermissions, onAppend, }: TextLayerBuilderOptions);
+    pdfPage: import("../src/display/api").PDFPageProxy;
+    highlighter: import("./text_highlighter").TextHighlighter;
+    accessibilityManager: import("./text_accessibility.js").TextAccessibilityManager;
+    div: HTMLDivElement;
+    /**
+     * Renders the text layer.
+     * @param {TextLayerBuilderRenderOptions} options
+     * @returns {Promise<void>}
+     */
+    render({ viewport, textContentParams }: TextLayerBuilderRenderOptions): Promise<void>;
+    hide(): void;
+    show(): void;
+    /**
+     * Cancel rendering of the text layer.
+     */
+    cancel(): void;
+    #private;
+}

package/dist/node_modules/pdfjs-dist/types/web/ui_utils.d.ts

@@ -0,0 +1,274 @@
+export type GetPageSizeInchesParameters = {
+    view: number[];
+    userUnit: number;
+    rotate: number;
+};
+export type PageSize = {
+    /**
+     * - In inches.
+     */
+    width: number;
+    /**
+     * - In inches.
+     */
+    height: number;
+};
+export type GetVisibleElementsParameters = {
+    /**
+     * - A container that can possibly scroll.
+     */
+    scrollEl: HTMLElement;
+    /**
+     * - Objects with a `div` property that contains an
+     * HTMLElement, which should all be descendants of `scrollEl` satisfying the
+     * relevant layout assumptions.
+     */
+    views: any[];
+    /**
+     * - If `true`, the returned elements are
+     * sorted in descending order of the percent of their padding box that is
+     * visible. The default value is `false`.
+     */
+    sortByVisibility: boolean;
+    /**
+     * - If `true`, the elements are assumed to be
+     * laid out horizontally instead of vertically. The default value is `false`.
+     */
+    horizontal: boolean;
+    /**
+     * - If `true`, the `scrollEl` container is assumed to
+     * be in right-to-left mode. The default value is `false`.
+     */
+    rtl: boolean;
+};
+/**
+ * Promise that is resolved when DOM window becomes visible.
+ */
+export const animationStarted: Promise<any>;
+/**
+ * Converts API PageLayout values to the format used by `BaseViewer`.
+ * @param {string} layout - The API PageLayout value.
+ * @returns {Object}
+ */
+export function apiPageLayoutToViewerModes(layout: string): Object;
+/**
+ * Converts API PageMode values to the format used by `PDFSidebar`.
+ * NOTE: There's also a "FullScreen" parameter which is not possible to support,
+ *       since the Fullscreen API used in browsers requires that entering
+ *       fullscreen mode only occurs as a result of a user-initiated event.
+ * @param {string} mode - The API PageMode value.
+ * @returns {number} A value from {SidebarView}.
+ */
+export function apiPageModeToSidebarView(mode: string): number;
+/**
+ *  Approximates float number as a fraction using Farey sequence (max order
+ *  of 8).
+ *  @param {number} x - Positive float number.
+ *  @returns {Array} Estimated fraction: the first array item is a numerator,
+ *                   the second one is a denominator.
+ *                   They are both natural numbers.
+ */
+export function approximateFraction(x: number): any[];
+export const AutoPrintRegExp: RegExp;
+/**
+ * Helper function for getVisibleElements.
+ *
+ * @param {number} index - initial guess at the first visible element
+ * @param {Array} views - array of pages, into which `index` is an index
+ * @param {number} top - the top of the scroll pane
+ * @returns {number} less than or equal to `index` that is definitely at or
+ *   before the first visible element in `views`, but not by too much. (Usually,
+ *   this will be the first element in the first partially visible row in
+ *   `views`, although sometimes it goes back one row further.)
+ */
+export function backtrackBeforeAllVisibleElements(index: number, views: any[], top: number): number;
+/**
+ * Use binary search to find the index of the first item in a given array which
+ * passes a given condition. The items are expected to be sorted in the sense
+ * that if the condition is true for one item in the array, then it is also true
+ * for all following items.
+ *
+ * @returns {number} Index of the first array element to pass the test,
+ *                   or |items.length| if no such element exists.
+ */
+export function binarySearchFirstItem(items: any, condition: any, start?: number): number;
+export const calcRound: ((x: number) => number) | ((x: any) => any);
+export namespace CursorTool {
+    let SELECT: number;
+    let HAND: number;
+    let ZOOM: number;
+}
+export const DEFAULT_SCALE: 1;
+export const DEFAULT_SCALE_DELTA: 1.1;
+export const DEFAULT_SCALE_VALUE: "auto";
+export const docStyle: CSSStyleDeclaration | null;
+/**
+ * @param {number} x - A positive number to round to a multiple of `div`.
+ * @param {number} div - A natural number.
+ */
+export function floorToDivide(x: number, div: number): number;
+/**
+ * Get the active or focused element in current DOM.
+ *
+ * Recursively search for the truly active or focused element in case there are
+ * shadow DOMs.
+ *
+ * @returns {Element} the truly active or focused element.
+ */
+export function getActiveOrFocusedElement(): Element;
+/**
+ * @typedef {Object} GetPageSizeInchesParameters
+ * @property {number[]} view
+ * @property {number} userUnit
+ * @property {number} rotate
+ */
+/**
+ * @typedef {Object} PageSize
+ * @property {number} width - In inches.
+ * @property {number} height - In inches.
+ */
+/**
+ * Gets the size of the specified page, converted from PDF units to inches.
+ * @param {GetPageSizeInchesParameters} params
+ * @returns {PageSize}
+ */
+export function getPageSizeInches({ view, userUnit, rotate }: GetPageSizeInchesParameters): PageSize;
+/**
+ * @typedef {Object} GetVisibleElementsParameters
+ * @property {HTMLElement} scrollEl - A container that can possibly scroll.
+ * @property {Array} views - Objects with a `div` property that contains an
+ *   HTMLElement, which should all be descendants of `scrollEl` satisfying the
+ *   relevant layout assumptions.
+ * @property {boolean} sortByVisibility - If `true`, the returned elements are
+ *   sorted in descending order of the percent of their padding box that is
+ *   visible. The default value is `false`.
+ * @property {boolean} horizontal - If `true`, the elements are assumed to be
+ *   laid out horizontally instead of vertically. The default value is `false`.
+ * @property {boolean} rtl - If `true`, the `scrollEl` container is assumed to
+ *   be in right-to-left mode. The default value is `false`.
+ */
+/**
+ * Generic helper to find out what elements are visible within a scroll pane.
+ *
+ * Well, pretty generic. There are some assumptions placed on the elements
+ * referenced by `views`:
+ *   - If `horizontal`, no left of any earlier element is to the right of the
+ *     left of any later element.
+ *   - Otherwise, `views` can be split into contiguous rows where, within a row,
+ *     no top of any element is below the bottom of any other element, and
+ *     between rows, no bottom of any element in an earlier row is below the
+ *     top of any element in a later row.
+ *
+ * (Here, top, left, etc. all refer to the padding edge of the element in
+ * question. For pages, that ends up being equivalent to the bounding box of the
+ * rendering canvas. Earlier and later refer to index in `views`, not page
+ * layout.)
+ *
+ * @param {GetVisibleElementsParameters} params
+ * @returns {Object} `{ first, last, views: [{ id, x, y, view, percent }] }`
+ */
+export function getVisibleElements({ scrollEl, views, sortByVisibility, horizontal, rtl, }: GetVisibleElementsParameters): Object;
+export function isPortraitOrientation(size: any): boolean;
+export function isValidRotation(angle: any): boolean;
+export function isValidScrollMode(mode: any): boolean;
+export function isValidSpreadMode(mode: any): boolean;
+export const MAX_AUTO_SCALE: 1.25;
+export const MAX_SCALE: 10;
+export const MIN_SCALE: 0.1;
+export function normalizeWheelEventDelta(evt: any): number;
+export function normalizeWheelEventDirection(evt: any): number;
+/**
+ * Helper function to parse query string (e.g. ?param1=value&param2=...).
+ * @param {string} query
+ * @returns {Map}
+ */
+export function parseQueryString(query: string): Map<any, any>;
+export namespace PresentationModeState {
+    let UNKNOWN: number;
+    let NORMAL: number;
+    let CHANGING: number;
+    let FULLSCREEN: number;
+}
+export class ProgressBar {
+    constructor(bar: any);
+    set percent(val: number);
+    get percent(): number;
+    setWidth(viewer: any): void;
+    setDisableAutoFetch(delay?: number): void;
+    hide(): void;
+    show(): void;
+    #private;
+}
+/**
+ * @param {string} str
+ * @param {boolean} [replaceInvisible]
+ */
+export function removeNullCharacters(str: string, replaceInvisible?: boolean): string;
+export namespace RenderingStates {
+    let INITIAL: number;
+    let RUNNING: number;
+    let PAUSED: number;
+    let FINISHED: number;
+}
+export const SCROLLBAR_PADDING: 40;
+/**
+ * Scrolls specified element into view of its parent.
+ * @param {HTMLElement} element - The element to be visible.
+ * @param {Object} [spot] - An object with optional top and left properties,
+ *   specifying the offset from the top left edge.
+ * @param {number} [spot.left]
+ * @param {number} [spot.top]
+ * @param {boolean} [scrollMatches] - When scrolling search results into view,
+ *   ignore elements that either: Contains marked content identifiers,
+ *   or have the CSS-rule `overflow: hidden;` set. The default value is `false`.
+ */
+export function scrollIntoView(element: HTMLElement, spot?: {
+    left?: number | undefined;
+    top?: number | undefined;
+}, scrollMatches?: boolean): void;
+export namespace ScrollMode {
+    let UNKNOWN_1: number;
+    export { UNKNOWN_1 as UNKNOWN };
+    export let VERTICAL: number;
+    export let HORIZONTAL: number;
+    export let WRAPPED: number;
+    export let PAGE: number;
+}
+export namespace SidebarView {
+    let UNKNOWN_2: number;
+    export { UNKNOWN_2 as UNKNOWN };
+    export let NONE: number;
+    export let THUMBS: number;
+    export let OUTLINE: number;
+    export let ATTACHMENTS: number;
+    export let LAYERS: number;
+}
+export namespace SpreadMode {
+    let UNKNOWN_3: number;
+    export { UNKNOWN_3 as UNKNOWN };
+    let NONE_1: number;
+    export { NONE_1 as NONE };
+    export let ODD: number;
+    export let EVEN: number;
+}
+export namespace TextLayerMode {
+    let DISABLE: number;
+    let ENABLE: number;
+    let ENABLE_PERMISSIONS: number;
+}
+export function toggleCheckedBtn(button: any, toggle: any, view?: null): void;
+export function toggleExpandedBtn(button: any, toggle: any, view?: null): void;
+export function toggleSelectedBtn(button: any, toggle: any, view?: null): void;
+export const UNKNOWN_SCALE: 0;
+export const VERTICAL_PADDING: 5;
+/**
+ * Helper function to start monitoring the scroll event and converting them into
+ * PDF.js friendly one: with scroll debounce and scroll direction.
+ */
+export function watchScroll(viewAreaElement: any, callback: any, abortSignal?: undefined): {
+    right: boolean;
+    down: boolean;
+    lastX: any;
+    lastY: any;
+    _eventHandler: (evt: any) => void;
+};

package/dist/node_modules/pdfjs-dist/types/web/xfa_layer_builder.d.ts

@@ -0,0 +1,50 @@
+export type PDFPageProxy = import("../src/display/api").PDFPageProxy;
+export type AnnotationStorage = import("../src/display/annotation_storage").AnnotationStorage;
+export type PageViewport = import("../src/display/display_utils").PageViewport;
+export type IPDFLinkService = import("./interfaces").IPDFLinkService;
+export type XfaLayerBuilderOptions = {
+    pdfPage: PDFPageProxy;
+    annotationStorage?: import("../src/display/annotation_storage").AnnotationStorage | undefined;
+    linkService: IPDFLinkService;
+    xfaHtml?: Object | undefined;
+};
+export type XfaLayerBuilderRenderOptions = {
+    viewport: PageViewport;
+    /**
+     * - The default value is "display".
+     */
+    intent?: string | undefined;
+};
+/**
+ * @typedef {Object} XfaLayerBuilderOptions
+ * @property {PDFPageProxy} pdfPage
+ * @property {AnnotationStorage} [annotationStorage]
+ * @property {IPDFLinkService} linkService
+ * @property {Object} [xfaHtml]
+ */
+/**
+ * @typedef {Object} XfaLayerBuilderRenderOptions
+ * @property {PageViewport} viewport
+ * @property {string} [intent] - The default value is "display".
+ */
+export class XfaLayerBuilder {
+    /**
+     * @param {XfaLayerBuilderOptions} options
+     */
+    constructor({ pdfPage, annotationStorage, linkService, xfaHtml, }: XfaLayerBuilderOptions);
+    pdfPage: import("../src/display/api").PDFPageProxy;
+    annotationStorage: import("../src/display/annotation_storage").AnnotationStorage;
+    linkService: import("./interfaces").IPDFLinkService;
+    xfaHtml: Object;
+    div: HTMLDivElement | null;
+    _cancelled: boolean;
+    /**
+     * @param {XfaLayerBuilderRenderOptions} viewport
+     * @returns {Promise<Object | void>} A promise that is resolved when rendering
+     *   of the XFA layer is complete. The first rendering will return an object
+     *   with a `textDivs` property that can be used with the TextHighlighter.
+     */
+    render({ viewport, intent }: XfaLayerBuilderRenderOptions): Promise<Object | void>;
+    cancel(): void;
+    hide(): void;
+}