pdfjs-serverless 0.1.0 → 0.2.0

package/dist/types/web/annotation_layer_builder.d.ts

@@ -0,0 +1,83 @@
+export type PDFPageProxy = import("../src/display/api").PDFPageProxy;
+export type PageViewport = import("../src/display/display_utils").PageViewport;
+export type IDownloadManager = import("./interfaces").IDownloadManager;
+export type IL10n = import("./interfaces").IL10n;
+export type IPDFLinkService = import("./interfaces").IPDFLinkService;
+export type TextAccessibilityManager = any;
+export type AnnotationLayerBuilderOptions = {
+    pageDiv: HTMLDivElement;
+    pdfPage: PDFPageProxy;
+    annotationStorage?: any;
+    /**
+     * - Path for image resources, mainly
+     * for annotation icons. Include trailing slash.
+     */
+    imageResourcesPath?: string | undefined;
+    renderForms: boolean;
+    linkService: IPDFLinkService;
+    downloadManager: IDownloadManager;
+    /**
+     * - Localization service.
+     */
+    l10n: IL10n;
+    enableScripting?: boolean | undefined;
+    hasJSActionsPromise?: Promise<boolean> | undefined;
+    fieldObjectsPromise?: Promise<{
+        [x: string]: Object[];
+    } | null> | undefined;
+    annotationCanvasMap?: Map<string, HTMLCanvasElement> | undefined;
+    accessibilityManager?: any;
+};
+/**
+ * @typedef {Object} AnnotationLayerBuilderOptions
+ * @property {HTMLDivElement} pageDiv
+ * @property {PDFPageProxy} pdfPage
+ * @property {AnnotationStorage} [annotationStorage]
+ * @property {string} [imageResourcesPath] - Path for image resources, mainly
+ *   for annotation icons. Include trailing slash.
+ * @property {boolean} renderForms
+ * @property {IPDFLinkService} linkService
+ * @property {IDownloadManager} downloadManager
+ * @property {IL10n} l10n - Localization service.
+ * @property {boolean} [enableScripting]
+ * @property {Promise<boolean>} [hasJSActionsPromise]
+ * @property {Promise<Object<string, Array<Object>> | null>}
+ *   [fieldObjectsPromise]
+ * @property {Map<string, HTMLCanvasElement>} [annotationCanvasMap]
+ * @property {TextAccessibilityManager} [accessibilityManager]
+ */
+export class AnnotationLayerBuilder {
+    /**
+     * @param {AnnotationLayerBuilderOptions} options
+     */
+    constructor({ pageDiv, pdfPage, linkService, downloadManager, annotationStorage, imageResourcesPath, renderForms, l10n, enableScripting, hasJSActionsPromise, fieldObjectsPromise, annotationCanvasMap, accessibilityManager, }: AnnotationLayerBuilderOptions);
+    pageDiv: HTMLDivElement;
+    pdfPage: import("../src/display/api").PDFPageProxy;
+    linkService: import("./interfaces").IPDFLinkService;
+    downloadManager: import("./interfaces").IDownloadManager;
+    imageResourcesPath: string;
+    renderForms: boolean;
+    l10n: import("./interfaces").IL10n;
+    annotationStorage: any;
+    enableScripting: boolean;
+    _hasJSActionsPromise: Promise<boolean>;
+    _fieldObjectsPromise: Promise<{
+        [x: string]: Object[];
+    } | null>;
+    _annotationCanvasMap: Map<string, HTMLCanvasElement>;
+    _accessibilityManager: any;
+    annotationLayer: any;
+    div: HTMLDivElement | null;
+    _cancelled: boolean;
+    _eventBus: any;
+    /**
+     * @param {PageViewport} viewport
+     * @param {string} intent (default value is 'display')
+     * @returns {Promise<void>} A promise that is resolved when rendering of the
+     *   annotations is complete.
+     */
+    render(viewport: PageViewport, intent?: string): Promise<void>;
+    cancel(): void;
+    hide(): void;
+    #private;
+}

package/dist/types/web/app_options.d.ts

@@ -0,0 +1,14 @@
+export class AppOptions {
+    static get(name: any): any;
+    static getAll(kind?: null): any;
+    static set(name: any, value: any): void;
+    static setAll(options: any): void;
+    static remove(name: any): void;
+}
+export const compatibilityParams: any;
+export namespace OptionKind {
+    let VIEWER: number;
+    let API: number;
+    let WORKER: number;
+    let PREFERENCE: number;
+}

package/dist/types/web/download_manager.d.ts

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

package/dist/types/web/event_utils.d.ts

@@ -0,0 +1,75 @@
+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;
+};
+/**
+ * NOTE: Only used to support various PDF viewer tests in `mozilla-central`.
+ */
+export class AutomationEventBus extends EventBus {
+    dispatch(eventName: any, data: any): void;
+}
+/**
+ * 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 | undefined): void;
+    /**
+     * @param {string} eventName
+     * @param {function} listener
+     * @param {Object} [options]
+     */
+    off(eventName: string, listener: Function, options?: Object | undefined): 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;
+}
+/**
+ * @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/types/web/generic_scripting.d.ts

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

package/dist/types/web/genericl10n.d.ts

@@ -0,0 +1,13 @@
+export type IL10n = import("./interfaces").IL10n;
+/**
+ * @implements {IL10n}
+ */
+export class GenericL10n implements IL10n {
+    constructor(lang: any);
+    _lang: any;
+    _ready: Promise<any>;
+    getLanguage(): Promise<any>;
+    getDirection(): Promise<any>;
+    get(key: any, args?: null, fallback?: any): Promise<any>;
+    translate(element: any): Promise<any>;
+}

package/dist/types/web/interfaces.d.ts

@@ -0,0 +1,163 @@
+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 {string} url
+     * @param {string} filename
+     * @param {Object} [options]
+     */
+    downloadUrl(url: string, filename: string, options?: Object | undefined): void;
+    /**
+     * @param {Uint8Array} data
+     * @param {string} filename
+     * @param {string} [contentType]
+     */
+    downloadData(data: Uint8Array, filename: string, contentType?: string | undefined): void;
+    /**
+     * @param {HTMLElement} element
+     * @param {Uint8Array} data
+     * @param {string} filename
+     * @returns {boolean} Indicating if the data was opened.
+     */
+    openOrDownloadData(element: HTMLElement, data: Uint8Array, filename: string): boolean;
+    /**
+     * @param {Blob} blob
+     * @param {string} url
+     * @param {string} filename
+     * @param {Object} [options]
+     */
+    download(blob: Blob, url: string, filename: string, options?: Object | undefined): void;
+}
+/**
+ * @interface
+ */
+export class IL10n {
+    /**
+     * @returns {Promise<string>} - Resolves to the current locale.
+     */
+    getLanguage(): Promise<string>;
+    /**
+     * @returns {Promise<string>} - Resolves to 'rtl' or 'ltr'.
+     */
+    getDirection(): Promise<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 {string} key
+     * @param {Object | null} [args]
+     * @param {string} [fallback]
+     * @returns {Promise<string>}
+     */
+    get(key: string, args?: Object | null | undefined, fallback?: string | undefined): Promise<string>;
+    /**
+     * Translates HTML element.
+     * @param {HTMLElement} element
+     * @returns {Promise<void>}
+     */
+    translate(element: HTMLElement): Promise<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(arg: number);
+    /**
+     * @type {number}
+     */
+    get page(): number;
+    /**
+     * @param {number} value
+     */
+    set rotation(arg: number);
+    /**
+     * @type {number}
+     */
+    get rotation(): number;
+    /**
+     * @type {boolean}
+     */
+    get isInPresentationMode(): boolean;
+    /**
+     * @param {boolean} value
+     */
+    set externalLinkEnabled(arg: 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;
+    /**
+     * @param {HTMLAnchorElement} link
+     * @param {string} url
+     * @param {boolean} [newWindow]
+     */
+    addLinkAttributes(link: HTMLAnchorElement, url: string, newWindow?: boolean | undefined): 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;
+    /**
+     * @param {number} pageNum - page number.
+     * @param {Object} pageRef - reference to the page.
+     */
+    cachePageRef(pageNum: number, pageRef: Object): 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(): any;
+    /**
+     * @returns {Promise} Resolved on draw completion.
+     */
+    draw(): Promise<any>;
+}

package/dist/types/web/l10n_utils.d.ts

@@ -0,0 +1,7 @@
+export function getL10nFallback(key: any, args: any): any;
+export namespace NullL10n {
+    function getLanguage(): Promise<string>;
+    function getDirection(): Promise<string>;
+    function get(key: any, args?: null, fallback?: any): Promise<any>;
+    function translate(element: any): Promise<void>;
+}

package/dist/types/web/pdf_find_controller.d.ts

@@ -0,0 +1,108 @@
+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;
+}
+/**
+ * @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;
+    #private;
+}

package/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/types/web/pdf_history.d.ts

@@ -0,0 +1,168 @@
+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;
+    _boundEvents: {
+        updateViewarea: ({ location }: {
+            location: any;
+        }) => void;
+        popState: ({ state }: {
+            state: any;
+        }) => void;
+        pageHide: () => void;
+    } | null;
+    _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
+     */
+    private _pushOrReplaceState;
+    /**
+     * @private
+     */
+    private _tryPushCurrentPosition;
+    /**
+     * @private
+     */
+    private _isValidPage;
+    /**
+     * @private
+     */
+    private _isValidState;
+    /**
+     * @private
+     */
+    private _updateInternalState;
+    /**
+     * @private
+     */
+    private _parseCurrentHash;
+    /**
+     * @private
+     */
+    private _updateViewarea;
+    /**
+     * @private
+     */
+    private _popState;
+    /**
+     * @private
+     */
+    private _pageHide;
+    /**
+     * @private
+     */
+    private _bindEvents;
+    /**
+     * @private
+     */
+    private _unbindEvents;
+}