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

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

@@ -0,0 +1,13 @@
+export type IDownloadManager = import("./interfaces").IDownloadManager;
+/**
+ * @implements {IDownloadManager}
+ */
+export class DownloadManager implements IDownloadManager {
+    downloadData(data: any, filename: any, contentType: any): void;
+    /**
+     * @returns {boolean} Indicating if the data was opened.
+     */
+    openOrDownloadData(data: any, filename: any, dest?: null): boolean;
+    download(data: any, url: any, filename: any): void;
+    #private;
+}

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

@@ -0,0 +1,22 @@
+export type DrawLayerBuilderRenderOptions = {
+    /**
+     * - The default value is "display".
+     */
+    intent?: string | undefined;
+};
+/**
+ * @typedef {Object} DrawLayerBuilderRenderOptions
+ * @property {string} [intent] - The default value is "display".
+ */
+export class DrawLayerBuilder {
+    /**
+     * @param {DrawLayerBuilderRenderOptions} options
+     * @returns {Promise<void>}
+     */
+    render({ intent }: DrawLayerBuilderRenderOptions): Promise<void>;
+    cancel(): void;
+    _cancelled: boolean | undefined;
+    setParent(parent: any): void;
+    getDrawLayer(): null;
+    #private;
+}

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

@@ -0,0 +1,77 @@
+export type WaitOnEventOrTimeoutParameters = {
+    /**
+     * - The event target, can for example be:
+     * `window`, `document`, a DOM element, or an {EventBus} instance.
+     */
+    target: Object;
+    /**
+     * - The name of the event.
+     */
+    name: string;
+    /**
+     * - The delay, in milliseconds, after which the
+     * timeout occurs (if the event wasn't already dispatched).
+     */
+    delay: number;
+};
+/**
+ * Simple event bus for an application. Listeners are attached using the `on`
+ * and `off` methods. To raise an event, the `dispatch` method shall be used.
+ */
+export class EventBus {
+    /**
+     * @param {string} eventName
+     * @param {function} listener
+     * @param {Object} [options]
+     */
+    on(eventName: string, listener: Function, options?: Object): void;
+    /**
+     * @param {string} eventName
+     * @param {function} listener
+     * @param {Object} [options]
+     */
+    off(eventName: string, listener: Function, options?: Object): void;
+    /**
+     * @param {string} eventName
+     * @param {Object} data
+     */
+    dispatch(eventName: string, data: Object): void;
+    /**
+     * @ignore
+     */
+    _on(eventName: any, listener: any, options?: null): void;
+    /**
+     * @ignore
+     */
+    _off(eventName: any, listener: any, options?: null): void;
+    #private;
+}
+/**
+ * NOTE: Only used in the Firefox built-in pdf viewer.
+ */
+export class FirefoxEventBus extends EventBus {
+    constructor(globalEventNames: any, externalServices: any, isInAutomation: any);
+    dispatch(eventName: any, data: any): void;
+    #private;
+}
+/**
+ * @typedef {Object} WaitOnEventOrTimeoutParameters
+ * @property {Object} target - The event target, can for example be:
+ *   `window`, `document`, a DOM element, or an {EventBus} instance.
+ * @property {string} name - The name of the event.
+ * @property {number} delay - The delay, in milliseconds, after which the
+ *   timeout occurs (if the event wasn't already dispatched).
+ */
+/**
+ * Allows waiting for an event or a timeout, whichever occurs first.
+ * Can be used to ensure that an action always occurs, even when an event
+ * arrives late or not at all.
+ *
+ * @param {WaitOnEventOrTimeoutParameters}
+ * @returns {Promise} A promise that is resolved with a {WaitOnType} value.
+ */
+export function waitOnEventOrTimeout({ target, name, delay }: WaitOnEventOrTimeoutParameters): Promise<any>;
+export namespace WaitOnType {
+    let EVENT: string;
+    let TIMEOUT: string;
+}

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

@@ -0,0 +1,8 @@
+export function docProperties(pdfDocument: any): Promise<any>;
+export class GenericScripting {
+    constructor(sandboxBundleSrc: any);
+    _ready: Promise<any>;
+    createSandbox(data: any): Promise<void>;
+    dispatchEventInSandbox(event: any): Promise<void>;
+    destroySandbox(): Promise<void>;
+}

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

@@ -0,0 +1,22 @@
+export type IL10n = import("./interfaces").IL10n;
+/**
+ * @implements {IL10n}
+ */
+export class GenericL10n extends L10n implements IL10n {
+    /**
+     * Generate the bundles for Fluent.
+     * @param {String} defaultLang - The fallback language to use for
+     *   translations.
+     * @param {String} baseLang - The base language to use for translations.
+     */
+    static "__#private@#generateBundles"(defaultLang: string, baseLang: string): AsyncGenerator<any, void, unknown>;
+    static "__#private@#createBundle"(lang: any, baseURL: any, paths: any): Promise<any>;
+    static "__#private@#getPaths"(): Promise<{
+        baseURL: any;
+        paths: any;
+    }>;
+    static "__#private@#generateBundlesFallback"(lang: any): AsyncGenerator<any, void, unknown>;
+    static "__#private@#createBundleFallback"(lang: any): Promise<any>;
+    constructor(lang: any);
+}
+import { L10n } from "./l10n.js";

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

@@ -0,0 +1,174 @@
+export type PDFPageProxy = import("../src/display/api").PDFPageProxy;
+export type PageViewport = import("../src/display/display_utils").PageViewport;
+export type RenderingStates = any;
+/**
+ * @interface
+ */
+export class IDownloadManager {
+    /**
+     * @param {Uint8Array} data
+     * @param {string} filename
+     * @param {string} [contentType]
+     */
+    downloadData(data: Uint8Array, filename: string, contentType?: string): void;
+    /**
+     * @param {Uint8Array} data
+     * @param {string} filename
+     * @param {string | null} [dest]
+     * @returns {boolean} Indicating if the data was opened.
+     */
+    openOrDownloadData(data: Uint8Array, filename: string, dest?: string | null): boolean;
+    /**
+     * @param {Uint8Array} data
+     * @param {string} url
+     * @param {string} filename
+     */
+    download(data: Uint8Array, url: string, filename: string): void;
+}
+/**
+ * @interface
+ */
+export class IL10n {
+    /**
+     * @returns {string} - The current locale.
+     */
+    getLanguage(): string;
+    /**
+     * @returns {string} - 'rtl' or 'ltr'.
+     */
+    getDirection(): string;
+    /**
+     * Translates text identified by the key and adds/formats data using the args
+     * property bag. If the key was not found, translation falls back to the
+     * fallback text.
+     * @param {Array | string} ids
+     * @param {Object | null} [args]
+     * @param {string} [fallback]
+     * @returns {Promise<string>}
+     */
+    get(ids: any[] | string, args?: Object | null, fallback?: string): Promise<string>;
+    /**
+     * Translates HTML element.
+     * @param {HTMLElement} element
+     * @returns {Promise<void>}
+     */
+    translate(element: HTMLElement): Promise<void>;
+    /**
+     * Pause the localization.
+     */
+    pause(): void;
+    /**
+     * Resume the localization.
+     */
+    resume(): void;
+}
+/** @typedef {import("../src/display/api").PDFPageProxy} PDFPageProxy */
+/** @typedef {import("../src/display/display_utils").PageViewport} PageViewport */
+/** @typedef {import("./ui_utils").RenderingStates} RenderingStates */
+/**
+ * @interface
+ */
+export class IPDFLinkService {
+    /**
+     * @type {number}
+     */
+    get pagesCount(): number;
+    /**
+     * @param {number} value
+     */
+    set page(value: number);
+    /**
+     * @type {number}
+     */
+    get page(): number;
+    /**
+     * @param {number} value
+     */
+    set rotation(value: number);
+    /**
+     * @type {number}
+     */
+    get rotation(): number;
+    /**
+     * @type {boolean}
+     */
+    get isInPresentationMode(): boolean;
+    /**
+     * @param {boolean} value
+     */
+    set externalLinkEnabled(value: boolean);
+    /**
+     * @type {boolean}
+     */
+    get externalLinkEnabled(): boolean;
+    /**
+     * @param {string|Array} dest - The named, or explicit, PDF destination.
+     */
+    goToDestination(dest: string | any[]): Promise<void>;
+    /**
+     * @param {number|string} val - The page number, or page label.
+     */
+    goToPage(val: number | string): void;
+    /**
+     * Scrolls to a specific location in the PDF document.
+     * @param {number} pageNumber - The page number to scroll to.
+     * @param {number} x - The x-coordinate to scroll to in page coordinates.
+     * @param {number} y - The y-coordinate to scroll to in page coordinates.
+     */
+    goToXY(pageNumber: number, x: number, y: number): void;
+    /**
+     * @param {HTMLAnchorElement} link
+     * @param {string} url
+     * @param {boolean} [newWindow]
+     */
+    addLinkAttributes(link: HTMLAnchorElement, url: string, newWindow?: boolean): void;
+    /**
+     * @param dest - The PDF destination object.
+     * @returns {string} The hyperlink to the PDF object.
+     */
+    getDestinationHash(dest: any): string;
+    /**
+     * @param hash - The PDF parameters/hash.
+     * @returns {string} The hyperlink to the PDF object.
+     */
+    getAnchorUrl(hash: any): string;
+    /**
+     * @param {string} hash
+     */
+    setHash(hash: string): void;
+    /**
+     * @param {string} action
+     */
+    executeNamedAction(action: string): void;
+    /**
+     * @param {Object} action
+     */
+    executeSetOCGState(action: Object): void;
+}
+/**
+ * @interface
+ */
+export class IPDFPrintServiceFactory {
+    static initGlobals(): void;
+    static get supportsPrinting(): boolean;
+    static createPrintService(): void;
+}
+/**
+ * @interface
+ */
+export class IRenderableView {
+    /** @type {function | null} */
+    resume: Function | null;
+    /**
+     * @type {string} - Unique ID for rendering queue.
+     */
+    get renderingId(): string;
+    /**
+     * @type {RenderingStates}
+     */
+    get renderingState(): RenderingStates;
+    /**
+     * @returns {Promise} Resolved on draw completion.
+     */
+    draw(): Promise<any>;
+}

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

@@ -0,0 +1,34 @@
+export type IL10n = import("./interfaces").IL10n;
+export const GenericL10n: null;
+/** @typedef {import("./interfaces").IL10n} IL10n */
+/**
+ * NOTE: The L10n-implementations should use lowercase language-codes
+ *       internally.
+ * @implements {IL10n}
+ */
+export class L10n implements IL10n {
+    static "__#private@#fixupLangCode"(langCode: any): any;
+    static "__#private@#isRTL"(lang: any): boolean;
+    constructor({ lang, isRTL }: {
+        lang: any;
+        isRTL: any;
+    }, l10n?: null);
+    _setL10n(l10n: any): void;
+    /** @inheritdoc */
+    getLanguage(): any;
+    /** @inheritdoc */
+    getDirection(): string;
+    /** @inheritdoc */
+    get(ids: any, args: null | undefined, fallback: any): Promise<any>;
+    /** @inheritdoc */
+    translate(element: any): Promise<void>;
+    /** @inheritdoc */
+    translateOnce(element: any): Promise<void>;
+    /** @inheritdoc */
+    destroy(): Promise<void>;
+    /** @inheritdoc */
+    pause(): void;
+    /** @inheritdoc */
+    resume(): void;
+    #private;
+}

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

@@ -0,0 +1,11 @@
+export class Menu {
+    /**
+     * Create a menu for the given button.
+     * @param {HTMLElement} menuContainer
+     * @param {HTMLElement} triggeringButton
+     * @param {Array<HTMLElement>|null} menuItems
+     */
+    constructor(menuContainer: HTMLElement, triggeringButton: HTMLElement, menuItems: Array<HTMLElement> | null);
+    destroy(): void;
+    #private;
+}

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

@@ -0,0 +1,134 @@
+export type PDFDocumentProxy = import("../src/display/api").PDFDocumentProxy;
+export type EventBus = import("./event_utils").EventBus;
+export type IPDFLinkService = import("./interfaces").IPDFLinkService;
+export type PDFFindControllerOptions = {
+    /**
+     * - The navigation/linking service.
+     */
+    linkService: IPDFLinkService;
+    /**
+     * - The application event bus.
+     */
+    eventBus: EventBus;
+    /**
+     * - True if the matches
+     * count must be updated on progress or only when the last page is reached.
+     * The default value is `true`.
+     */
+    updateMatchesCountOnProgress?: boolean | undefined;
+};
+export namespace FindState {
+    let FOUND: number;
+    let NOT_FOUND: number;
+    let WRAPPED: number;
+    let PENDING: number;
+}
+export function getOriginalIndex(diffs: any, pos: any, len: any): any[];
+export function normalize(text: any, options?: {}): any[];
+/**
+ * @typedef {Object} PDFFindControllerOptions
+ * @property {IPDFLinkService} linkService - The navigation/linking service.
+ * @property {EventBus} eventBus - The application event bus.
+ * @property {boolean} [updateMatchesCountOnProgress] - True if the matches
+ *   count must be updated on progress or only when the last page is reached.
+ *   The default value is `true`.
+ */
+/**
+ * Provides search functionality to find a given string in a PDF document.
+ */
+export class PDFFindController {
+    /**
+     * @param {PDFFindControllerOptions} options
+     */
+    constructor({ linkService, eventBus, updateMatchesCountOnProgress }: PDFFindControllerOptions);
+    _linkService: import("./interfaces").IPDFLinkService;
+    _eventBus: import("./event_utils").EventBus;
+    /**
+     * Callback used to check if a `pageNumber` is currently visible.
+     * @type {function}
+     */
+    onIsPageVisible: Function;
+    get highlightMatches(): boolean | undefined;
+    get pageMatches(): any[] | undefined;
+    get pageMatchesLength(): any[] | undefined;
+    get selected(): {
+        pageIdx: number;
+        matchIdx: number;
+    } | undefined;
+    get state(): null;
+    /**
+     * Set a reference to the PDF document in order to search it.
+     * Note that searching is not possible if this method is not called.
+     *
+     * @param {PDFDocumentProxy} pdfDocument - The PDF document to search.
+     */
+    setDocument(pdfDocument: PDFDocumentProxy): void;
+    _pdfDocument: import("../src/display/api").PDFDocumentProxy | null | undefined;
+    _dirtyMatch: boolean | undefined;
+    _findTimeout: any;
+    _highlightMatches: boolean | undefined;
+    /**
+     * @typedef {Object} PDFFindControllerScrollMatchIntoViewParams
+     * @property {HTMLElement} element
+     * @property {number} selectedLeft
+     * @property {number} pageIndex
+     * @property {number} matchIndex
+     */
+    /**
+     * Scroll the current match into view.
+     * @param {PDFFindControllerScrollMatchIntoViewParams}
+     */
+    scrollMatchIntoView({ element, selectedLeft, pageIndex, matchIndex, }: {
+        element: HTMLElement;
+        selectedLeft: number;
+        pageIndex: number;
+        matchIndex: number;
+    }): void;
+    _scrollMatches: boolean | undefined;
+    _pageMatches: any[] | undefined;
+    _pageMatchesLength: any[] | undefined;
+    _selected: {
+        pageIdx: number;
+        matchIdx: number;
+    } | undefined;
+    _offset: {
+        pageIdx: null;
+        matchIdx: null;
+        wrapped: boolean;
+    } | undefined;
+    _extractTextPromises: any[] | undefined;
+    _pageContents: any[] | undefined;
+    _pageDiffs: any[] | undefined;
+    _hasDiacritics: any[] | undefined;
+    _matchesCountTotal: number | undefined;
+    _pagesToSearch: number | null | undefined;
+    _pendingFindMatches: Set<any> | undefined;
+    _resumePageIdx: any;
+    _firstPageCapability: any;
+    _rawQuery: any;
+    /**
+     * @typedef {Object} FindMatch
+     * @property {number} index - The start of the matched text in the page's
+     *   string contents.
+     * @property {number} length - The length of the matched text.
+     */
+    /**
+     * @param {string | string[]} query - The search query.
+     * @param {string} pageContent - The text content of the page to search in.
+     * @param {number} pageIndex - The index of the page that is being processed.
+     * @returns {FindMatch[] | undefined} An array of matches in the provided
+     *   page.
+     */
+    match(query: string | string[], pageContent: string, pageIndex: number): {
+        /**
+         * - The start of the matched text in the page's
+         * string contents.
+         */
+        index: number;
+        /**
+         * - The length of the matched text.
+         */
+        length: number;
+    }[] | undefined;
+    #private;
+}

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

@@ -0,0 +1,16 @@
+export namespace CharacterType {
+    let SPACE: number;
+    let ALPHA_LETTER: number;
+    let PUNCT: number;
+    let HAN_LETTER: number;
+    let KATAKANA_LETTER: number;
+    let HIRAGANA_LETTER: number;
+    let HALFWIDTH_KATAKANA_LETTER: number;
+    let THAI_LETTER: number;
+}
+/**
+ * This function is based on the word-break detection implemented in:
+ * https://hg.mozilla.org/mozilla-central/file/tip/intl/lwbrk/WordBreaker.cpp
+ */
+export function getCharacterType(charCode: any): number;
+export function getNormalizeWithNFKC(): any;

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

@@ -0,0 +1,116 @@
+export type PDFHistoryOptions = {
+    /**
+     * - The navigation/linking service.
+     */
+    linkService: IPDFLinkService;
+    /**
+     * - The application event bus.
+     */
+    eventBus: EventBus;
+};
+export type InitializeParameters = {
+    /**
+     * - The PDF document's unique fingerprint.
+     */
+    fingerprint: string;
+    /**
+     * - Reset the browsing history.
+     */
+    resetHistory?: boolean | undefined;
+    /**
+     * - Attempt to update the document URL, with
+     * the current hash, when pushing/replacing browser history entries.
+     */
+    updateUrl?: boolean | undefined;
+};
+export type PushParameters = {
+    /**
+     * - The named destination. If absent, a
+     * stringified version of `explicitDest` is used.
+     */
+    namedDest?: string | undefined;
+    /**
+     * - The explicit destination array.
+     */
+    explicitDest: any[];
+    /**
+     * - The page to which the destination points.
+     */
+    pageNumber: number;
+};
+export type EventBus = import("./event_utils").EventBus;
+export type IPDFLinkService = import("./interfaces").IPDFLinkService;
+export function isDestArraysEqual(firstDest: any, secondDest: any): boolean;
+export function isDestHashesEqual(destHash: any, pushHash: any): boolean;
+export class PDFHistory {
+    /**
+     * @param {PDFHistoryOptions} options
+     */
+    constructor({ linkService, eventBus }: PDFHistoryOptions);
+    linkService: import("./interfaces").IPDFLinkService;
+    eventBus: import("./event_utils.js").EventBus;
+    _initialized: boolean;
+    _fingerprint: string;
+    _isPagesLoaded: boolean;
+    /**
+     * Initialize the history for the PDF document, using either the current
+     * browser history entry or the document hash, whichever is present.
+     * @param {InitializeParameters} params
+     */
+    initialize({ fingerprint, resetHistory, updateUrl }: InitializeParameters): void;
+    _updateUrl: boolean | undefined;
+    _popStateInProgress: boolean | undefined;
+    _blockHashChange: number | undefined;
+    _currentHash: string | undefined;
+    _numPositionUpdates: number | undefined;
+    _uid: any;
+    _maxUid: any;
+    _destination: any;
+    _position: {
+        hash: any;
+        page: number;
+        first: any;
+        rotation: any;
+    } | null | undefined;
+    _initialRotation: any;
+    _initialBookmark: any;
+    /**
+     * Reset the current `PDFHistory` instance, and consequently prevent any
+     * further updates and/or navigation of the browser history.
+     */
+    reset(): void;
+    _updateViewareaTimeout: any;
+    /**
+     * Push an internal destination to the browser history.
+     * @param {PushParameters}
+     */
+    push({ namedDest, explicitDest, pageNumber }: PushParameters): void;
+    /**
+     * Push a page to the browser history; generally the `push` method should be
+     * used instead.
+     * @param {number} pageNumber
+     */
+    pushPage(pageNumber: number): void;
+    /**
+     * Push the current position to the browser history.
+     */
+    pushCurrentPosition(): void;
+    /**
+     * Go back one step in the browser history.
+     * NOTE: Avoids navigating away from the document, useful for "named actions".
+     */
+    back(): void;
+    /**
+     * Go forward one step in the browser history.
+     * NOTE: Avoids navigating away from the document, useful for "named actions".
+     */
+    forward(): void;
+    /**
+     * @type {boolean} Indicating if the user is currently moving through the
+     *   browser history, useful e.g. for skipping the next 'hashchange' event.
+     */
+    get popStateInProgress(): boolean;
+    get initialBookmark(): any;
+    get initialRotation(): any;
+    #private;
+}