@progress/kendo-pdfviewer-common 0.3.0-dev.202409251459 → 0.3.0-dev.202410100645

package/dist/es2015/common/component.js

@@ -0,0 +1,33 @@
+import { extend, deepExtend, isFunction } from "./core";
+export class Component {
+    constructor(element, options) {
+        this.options = {
+            events: {}
+        };
+        this.element = element;
+        this.options = options;
+    }
+    destroy() {
+        this.element = null;
+    }
+    extendOptions(options) {
+        this.options = deepExtend(this.options, options);
+    }
+    setOptions(options) {
+        this.options = options;
+    }
+    trigger(eventName, args = {}) {
+        const eventData = {
+            defaultPrevented: false,
+            preventDefault: () => {
+                eventData.defaultPrevented = true;
+            }
+        };
+        if (isFunction(this.options.events[eventName])) {
+            this.options.events[eventName](extend(eventData, args, {
+                sender: this
+            }));
+        }
+        return eventData.defaultPrevented;
+    }
+}

package/dist/es2015/common/core.js

@@ -0,0 +1,91 @@
+import { Component } from "./component";
+// @ts-expect-error TS(2556): A spread argument must either have a tuple type or... Remove this comment to see the full error message
+export const extend = (...args) => Object.assign(...args);
+export const isObject = (value) => value && typeof (value) === "object" && !Array.isArray(value);
+export const isHtmlElement = (element) => element instanceof HTMLElement;
+export const isDomElement = (element) => element instanceof Element;
+/* eslint-disable no-undef */
+// @ts-expect-error TS(2304): Cannot find name 'DotNet'.
+export const isDotNetObject = (value) => value && window && window.DotNet && window.DotNet.DotNetObject && value instanceof DotNet.DotNetObject;
+/* eslint-enable no-undef */
+export const deepExtend = (target, ...sources) => {
+    if (!sources.length) {
+        return target;
+    }
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (source[key] instanceof Component) {
+                target[key] = source[key];
+            }
+            else if (isHtmlElement(source[key])) {
+                target[key] = source[key];
+            }
+            else if (key === "dotNetInstance" || isDotNetObject(source[key])) {
+                // avoid cloning a DotNetObject as it might have circular properties
+                // see https://github.com/telerik/blazor/issues/7507
+                // the check for the name of our own option - "dotNetInstance"
+                // is an additional guard against the Blazor API being different in other .NET versions
+                target[key] = source[key];
+            }
+            else if (source[key] && source[key].buffer && source[key].buffer instanceof ArrayBuffer) {
+                target[key] = source[key];
+            }
+            else if (isObject(source[key]) && Object.getPrototypeOf(source[key]) !== Object.prototype) {
+                target[key] = source[key];
+            }
+            else if (isObject(source[key])) {
+                if (!target[key] || !isObject(target[key])) {
+                    extend(target, { [key]: {} });
+                }
+                deepExtend(target[key], source[key]);
+            }
+            else {
+                extend(target, { [key]: source[key] });
+            }
+        }
+    }
+    return deepExtend(target, ...sources);
+};
+export const isFunction = fn => typeof (fn) === "function";
+export const isString = value => typeof (value) === "string";
+export const toArray = value => Array.from(value);
+export const isDefined = value => typeof (value) !== "undefined";
+export const isNotNull = value => value !== null;
+export const hasValue = value => isDefined(value) && isNotNull(value);
+export const noop = function () { };
+export const convertToHtml = (htmlString, ownerDocument) => {
+    const template = (ownerDocument || document).createElement('template');
+    template.innerHTML = htmlString.trim();
+    const content = template.content;
+    if (content.childNodes.length > 1) {
+        return content.childNodes;
+    }
+    return content.firstChild;
+};
+export const toPixel = value => parseFloat(value) + "px";
+export const toClassSelector = (className) => (className === null || className === void 0 ? void 0 : className.startsWith(".")) ? className : `.${className}`;
+export const mousewheelDelta = (e) => {
+    let delta = 0;
+    if (e.wheelDelta) {
+        delta = -e.wheelDelta / 120;
+    }
+    else if (e.detail) {
+        delta = e.detail / 3;
+    }
+    delta = delta > 0 ? Math.ceil(delta) : Math.floor(delta);
+    return delta;
+};
+export const createPromise = () => {
+    let resolveFn;
+    let rejectFn;
+    const promise = new Promise(function (resolve, reject) {
+        resolveFn = resolve;
+        rejectFn = reject;
+    });
+    // @ts-expect-error TS(2339): Property 'resolve' does not exist on type 'Promise... Remove this comment to see the full error message
+    promise.resolve = resolveFn;
+    // @ts-expect-error TS(2339): Property 'reject' does not exist on type 'Promise<... Remove this comment to see the full error message
+    promise.reject = rejectFn;
+    return promise;
+};

package/dist/es2015/common/dom.js

@@ -0,0 +1,11 @@
+export const addClass = (className, element) => {
+    element.classList.add(className);
+};
+export const removeClass = (className, element) => {
+    element.classList.remove(className);
+};
+export const hasClass = (className, element) => {
+    if (element instanceof HTMLElement) {
+        return element.classList.contains(className);
+    }
+};

package/dist/es2015/common/main.js

@@ -0,0 +1,4 @@
+export * from './component';
+export * from './core';
+export * from './dom';
+export * from './math';

package/dist/es2015/common/math.js

@@ -0,0 +1 @@
+export const clamp = (value, min, max) => Math.min(max, Math.max(min, value));

package/dist/es2015/enums/PdfViewerInteractionMode.js

@@ -0,0 +1,6 @@
+export var PdfViewerInteractionMode;
+(function (PdfViewerInteractionMode) {
+    PdfViewerInteractionMode[PdfViewerInteractionMode["TextSelection"] = 0] = "TextSelection";
+    PdfViewerInteractionMode[PdfViewerInteractionMode["Pan"] = 1] = "Pan";
+})(PdfViewerInteractionMode || (PdfViewerInteractionMode = {}));
+;

package/dist/es2015/links/link-service.js

@@ -0,0 +1,505 @@
+/* Copyright 2015 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var _a, _PDFLinkService_isValidExplicitDest;
+import { __awaiter, __classPrivateFieldGet } from "tslib";
+import { parseQueryString } from "../annotations/shared/ui_utils";
+const DEFAULT_LINK_REL = "noopener noreferrer nofollow";
+const LinkTarget = {
+    NONE: 0, // Default value.
+    SELF: 1,
+    BLANK: 2,
+    PARENT: 3,
+    TOP: 4,
+};
+/**
+ * @typedef {Object} PDFLinkServiceOptions
+ * @property {EventBus} eventBus - The application event bus.
+ * @property {number} [externalLinkTarget] - Specifies the `target` attribute
+ *   for external links. Must use one of the values from {LinkTarget}.
+ *   Defaults to using no target.
+ * @property {string} [externalLinkRel] - Specifies the `rel` attribute for
+ *   external links. Defaults to stripping the referrer.
+ * @property {boolean} [ignoreDestinationZoom] - Ignores the zoom argument,
+ *   thus preserving the current zoom level in the viewer, when navigating
+ *   to internal destinations. The default value is `false`.
+ */
+/**
+ * Performs navigation functions inside PDF, such as opening specified page,
+ * or destination.
+ * @implements {IPDFLinkService}
+ */
+class PDFLinkService {
+    /**
+     * @param {PDFLinkServiceOptions} options
+     */
+    constructor({ eventBus = null, externalLinkTarget = null, externalLinkRel = null, ignoreDestinationZoom = false, } = {}) {
+        // todo: props
+        this.eventBus = null;
+        this.externalLinkTarget = null;
+        this.externalLinkRel = null;
+        this._ignoreDestinationZoom = null;
+        this.baseUrl = null;
+        this.pdfDocument = null;
+        this.pdfViewer = null;
+        this.pdfHistory = null;
+        // todo: props
+        this.externalLinkEnabled = true;
+        this.eventBus = eventBus;
+        this.externalLinkTarget = externalLinkTarget;
+        this.externalLinkRel = externalLinkRel;
+        this._ignoreDestinationZoom = ignoreDestinationZoom;
+        this.baseUrl = null;
+        this.pdfDocument = null;
+        this.pdfViewer = null;
+        this.pdfHistory = null;
+    }
+    setDocument(pdfDocument, baseUrl = null) {
+        this.baseUrl = baseUrl;
+        this.pdfDocument = pdfDocument;
+    }
+    setViewer(pdfViewer) {
+        this.pdfViewer = pdfViewer;
+    }
+    setHistory(pdfHistory) {
+        this.pdfHistory = pdfHistory;
+    }
+    /**
+     * @type {number}
+     */
+    get pagesCount() {
+        return this.pdfDocument ? this.pdfDocument.numPages : 0;
+    }
+    /**
+     * @type {number}
+     */
+    get page() {
+        return this.pdfDocument ? this.pdfViewer.currentPageNumber : 1;
+    }
+    /**
+     * @param {number} value
+     */
+    set page(value) {
+        if (this.pdfDocument) {
+            this.pdfViewer.currentPageNumber = value;
+        }
+    }
+    /**
+     * @type {number}
+     */
+    get rotation() {
+        return this.pdfDocument ? this.pdfViewer.pagesRotation : 0;
+    }
+    /**
+     * @param {number} value
+     */
+    set rotation(value) {
+        if (this.pdfDocument) {
+            this.pdfViewer.pagesRotation = value;
+        }
+    }
+    /**
+     * @type {boolean}
+     */
+    get isInPresentationMode() {
+        return this.pdfDocument ? this.pdfViewer.isInPresentationMode : false;
+    }
+    /**
+     * This method will, when available, also update the browser history.
+     *
+     * @param {string|Array} dest - The named, or explicit, PDF destination.
+     */
+    goToDestination(dest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.pdfDocument) {
+                return;
+            }
+            let namedDest, explicitDest, pageNumber;
+            if (typeof dest === "string") {
+                namedDest = dest;
+                explicitDest = yield this.pdfDocument.getDestination(dest);
+            }
+            else {
+                namedDest = null;
+                explicitDest = yield dest;
+            }
+            if (!Array.isArray(explicitDest)) {
+                // console.error(
+                //     `goToDestination: "${explicitDest}" is not a valid destination array, for dest="${dest}".`
+                // );
+                return;
+            }
+            // Dest array looks like that: <page-ref> </XYZ|/FitXXX> <args..>
+            const [destRef] = explicitDest;
+            if (destRef && typeof destRef === "object") {
+                pageNumber = this.pdfDocument.cachedPageNumber(destRef);
+                if (!pageNumber) {
+                    // Fetch the page reference if it's not yet available. This could
+                    // only occur during loading, before all pages have been resolved.
+                    try {
+                        pageNumber = (yield this.pdfDocument.getPageIndex(destRef)) + 1;
+                    }
+                    catch (_b) {
+                        console.error(`goToDestination: "${destRef}" is not a valid page reference, for dest="${dest}".`);
+                        return;
+                    }
+                }
+            }
+            else if (Number.isInteger(destRef)) {
+                pageNumber = destRef + 1;
+            }
+            if (!pageNumber || pageNumber < 1 || pageNumber > this.pagesCount) {
+                console.error(`goToDestination: "${pageNumber}" is not a valid page number, for dest="${dest}".`);
+                return;
+            }
+            if (this.pdfHistory) {
+                // Update the browser history before scrolling the new destination into
+                // view, to be able to accurately capture the current document position.
+                this.pdfHistory.pushCurrentPosition();
+                this.pdfHistory.push({ namedDest, explicitDest, pageNumber });
+            }
+            this.pdfViewer.scrollPageIntoView({
+                pageNumber,
+                destArray: explicitDest,
+                ignoreDestinationZoom: this._ignoreDestinationZoom,
+            });
+        });
+    }
+    /**
+     * This method will, when available, also update the browser history.
+     *
+     * @param {number|string} val - The page number, or page label.
+     */
+    goToPage(val) {
+        if (!this.pdfDocument) {
+            return;
+        }
+        const pageNumber = (typeof val === "string" && this.pdfViewer.pageLabelToPageNumber(val)) ||
+            val | 0;
+        if (!(Number.isInteger(pageNumber) &&
+            pageNumber > 0 &&
+            pageNumber <= this.pagesCount)) {
+            console.error(`PDFLinkService.goToPage: "${val}" is not a valid page.`);
+            return;
+        }
+        if (this.pdfHistory) {
+            // Update the browser history before scrolling the new page into view,
+            // to be able to accurately capture the current document position.
+            this.pdfHistory.pushCurrentPosition();
+            this.pdfHistory.pushPage(pageNumber);
+        }
+        this.pdfViewer.scrollPageIntoView({ pageNumber });
+    }
+    /**
+     * Adds various attributes (href, title, target, rel) to hyperlinks.
+     * @param {HTMLAnchorElement} link
+     * @param {string} url
+     * @param {boolean} [newWindow]
+     */
+    addLinkAttributes(link, url, newWindow = false) {
+        if (!url || typeof url !== "string") {
+            throw new Error('A valid "url" parameter must provided.');
+        }
+        const target = newWindow ? LinkTarget.BLANK : this.externalLinkTarget, rel = this.externalLinkRel;
+        if (this.externalLinkEnabled) {
+            link.href = link.title = url;
+        }
+        else {
+            link.href = "";
+            link.title = `Disabled: ${url}`;
+            link.onclick = () => false;
+        }
+        let targetStr = ""; // LinkTarget.NONE
+        switch (target) {
+            case LinkTarget.NONE:
+                break;
+            case LinkTarget.SELF:
+                targetStr = "_self";
+                break;
+            case LinkTarget.BLANK:
+                targetStr = "_blank";
+                break;
+            case LinkTarget.PARENT:
+                targetStr = "_parent";
+                break;
+            case LinkTarget.TOP:
+                targetStr = "_top";
+                break;
+            default: break;
+        }
+        link.target = targetStr;
+        link.rel = typeof rel === "string" ? rel : DEFAULT_LINK_REL;
+    }
+    /**
+     * @param {string|Array} dest - The PDF destination object.
+     * @returns {string} The hyperlink to the PDF object.
+     */
+    getDestinationHash(dest) {
+        if (typeof dest === "string") {
+            if (dest.length > 0) {
+                return this.getAnchorUrl("#" + escape(dest));
+            }
+        }
+        else if (Array.isArray(dest)) {
+            const str = JSON.stringify(dest);
+            if (str.length > 0) {
+                return this.getAnchorUrl("#" + escape(str));
+            }
+        }
+        return this.getAnchorUrl("");
+    }
+    /**
+     * Prefix the full url on anchor links to make sure that links are resolved
+     * relative to the current URL instead of the one defined in <base href>.
+     * @param {string} anchor - The anchor hash, including the #.
+     * @returns {string} The hyperlink to the PDF object.
+     */
+    getAnchorUrl(anchor) {
+        return this.baseUrl ? this.baseUrl + anchor : anchor;
+    }
+    /**
+     * @param {string} hash
+     */
+    setHash(hash) {
+        if (!this.pdfDocument) {
+            return;
+        }
+        let pageNumber, dest;
+        if (hash.includes("=")) {
+            const params = parseQueryString(hash);
+            if (params.has("search")) {
+                const query = params.get("search").replaceAll('"', ""), phrase = params.get("phrase") === "true";
+                this.eventBus.dispatch("findfromurlhash", {
+                    source: this,
+                    query: phrase ? query : query.match(/\S+/g),
+                });
+            }
+            // borrowing syntax from "Parameters for Opening PDF Files"
+            if (params.has("page")) {
+                pageNumber = params.get("page") | 0 || 1;
+            }
+            if (params.has("zoom")) {
+                // Build the destination array.
+                const zoomArgs = params.get("zoom").split(","); // scale,left,top
+                const zoomArg = zoomArgs[0];
+                const zoomArgNumber = parseFloat(zoomArg);
+                if (!zoomArg.includes("Fit")) {
+                    // If the zoomArg is a number, it has to get divided by 100. If it's
+                    // a string, it should stay as it is.
+                    dest = [
+                        null,
+                        { name: "XYZ" },
+                        zoomArgs.length > 1 ? zoomArgs[1] | 0 : null,
+                        zoomArgs.length > 2 ? zoomArgs[2] | 0 : null,
+                        zoomArgNumber ? zoomArgNumber / 100 : zoomArg,
+                    ];
+                }
+                else if (zoomArg === "Fit" || zoomArg === "FitB") {
+                    dest = [null, { name: zoomArg }];
+                }
+                else if (zoomArg === "FitH" ||
+                    zoomArg === "FitBH" ||
+                    zoomArg === "FitV" ||
+                    zoomArg === "FitBV") {
+                    dest = [
+                        null,
+                        { name: zoomArg },
+                        zoomArgs.length > 1 ? zoomArgs[1] | 0 : null,
+                    ];
+                }
+                else if (zoomArg === "FitR") {
+                    if (zoomArgs.length !== 5) {
+                        console.error('PDFLinkService.setHash: Not enough parameters for "FitR".');
+                    }
+                    else {
+                        dest = [
+                            null,
+                            { name: zoomArg },
+                            zoomArgs[1] | 0,
+                            zoomArgs[2] | 0,
+                            zoomArgs[3] | 0,
+                            zoomArgs[4] | 0,
+                        ];
+                    }
+                }
+                else {
+                    console.error(`PDFLinkService.setHash: "${zoomArg}" is not a valid zoom value.`);
+                }
+            }
+            if (dest) {
+                this.pdfViewer.scrollPageIntoView({
+                    pageNumber: pageNumber || this.page,
+                    destArray: dest,
+                    allowNegativeOffset: true,
+                });
+            }
+            else if (pageNumber) {
+                this.page = pageNumber; // simple page
+            }
+            if (params.has("pagemode")) {
+                this.eventBus.dispatch("pagemode", {
+                    source: this,
+                    mode: params.get("pagemode"),
+                });
+            }
+            // Ensure that this parameter is *always* handled last, in order to
+            // guarantee that it won't be overridden (e.g. by the "page" parameter).
+            if (params.has("nameddest")) {
+                this.goToDestination(params.get("nameddest"));
+            }
+            // if (typeof PDFJSDev === "undefined" || !PDFJSDev.test("MOZCENTRAL")) {
+            return;
+            // }
+            // // Support opening of PDF attachments in the Firefox PDF Viewer,
+            // // which uses a couple of non-standard hash parameters; refer to
+            // // `DownloadManager.openOrDownloadData` in the firefoxcom.js file.
+            // if (!params.has("filename") || !params.has("filedest")) {
+            //     return;
+            // }
+            // hash = params.get("filedest");
+        }
+        // Named (or explicit) destination.
+        dest = unescape(hash);
+        try {
+            dest = JSON.parse(dest);
+            if (!Array.isArray(dest)) {
+                // Avoid incorrectly rejecting a valid named destination, such as
+                // e.g. "4.3" or "true", because `JSON.parse` converted its type.
+                dest = dest.toString();
+            }
+        }
+        catch (e) {
+            if (!e) {
+                return;
+            }
+        }
+        if (typeof dest === "string" || __classPrivateFieldGet(_a, _a, "m", _PDFLinkService_isValidExplicitDest).call(_a, dest)) {
+            this.goToDestination(dest);
+            return;
+        }
+        // console.error(
+        //     `PDFLinkService.setHash: "${unescape(hash)}" is not a valid destination.`
+        // );
+    }
+    /**
+     * @param {string} action
+     */
+    executeNamedAction(action) {
+        var _b, _c;
+        if (!this.pdfDocument) {
+            return;
+        }
+        // See PDF reference, table 8.45 - Named action
+        switch (action) {
+            case "GoBack":
+                (_b = this.pdfHistory) === null || _b === void 0 ? void 0 : _b.back();
+                break;
+            case "GoForward":
+                (_c = this.pdfHistory) === null || _c === void 0 ? void 0 : _c.forward();
+                break;
+            case "NextPage":
+                this.pdfViewer.nextPage();
+                break;
+            case "PrevPage":
+                this.pdfViewer.previousPage();
+                break;
+            case "LastPage":
+                this.page = this.pagesCount;
+                break;
+            case "FirstPage":
+                this.page = 1;
+                break;
+            default:
+                break; // No action according to spec
+        }
+        this.eventBus.dispatch("namedaction", {
+            source: this,
+            action,
+        });
+    }
+    /**
+     * @param {Object} action
+     */
+    executeSetOCGState(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.pdfDocument) {
+                return;
+            }
+            const pdfDocument = this.pdfDocument, optionalContentConfig = yield this.pdfViewer.optionalContentConfigPromise;
+            if (pdfDocument !== this.pdfDocument) {
+                return; // The document was closed while the optional content resolved.
+            }
+            optionalContentConfig.setOCGState(action);
+            this.pdfViewer.optionalContentConfigPromise = Promise.resolve(optionalContentConfig);
+        });
+    }
+}
+_a = PDFLinkService, _PDFLinkService_isValidExplicitDest = function _PDFLinkService_isValidExplicitDest(dest) {
+    if (!Array.isArray(dest) || dest.length < 2) {
+        return false;
+    }
+    const [page, zoom, ...args] = dest;
+    if (!(typeof page === "object" &&
+        Number.isInteger(page === null || page === void 0 ? void 0 : page.num) &&
+        Number.isInteger(page === null || page === void 0 ? void 0 : page.gen)) &&
+        !Number.isInteger(page)) {
+        return false;
+    }
+    if (!(typeof zoom === "object" && typeof (zoom === null || zoom === void 0 ? void 0 : zoom.name) === "string")) {
+        return false;
+    }
+    const argsLen = args.length;
+    let allowNull = true;
+    switch (zoom.name) {
+        case "XYZ":
+            if (argsLen < 2 || argsLen > 3) {
+                return false;
+            }
+            break;
+        case "Fit":
+        case "FitB":
+            return argsLen === 0;
+        case "FitH":
+        case "FitBH":
+        case "FitV":
+        case "FitBV":
+            if (argsLen > 1) {
+                return false;
+            }
+            break;
+        case "FitR":
+            if (argsLen !== 4) {
+                return false;
+            }
+            allowNull = false;
+            break;
+        default:
+            return false;
+    }
+    for (const arg of args) {
+        if (!(typeof arg === "number" || (allowNull && arg === null))) {
+            return false;
+        }
+    }
+    return true;
+};
+// /**
+//  * @implements {IPDFLinkService}
+//  */
+// class SimpleLinkService extends PDFLinkService {
+//     setDocument(pdfDocument, baseUrl = null) { }
+// }
+export { LinkTarget, PDFLinkService,
+// SimpleLinkService
+ };

package/dist/es2015/main.js

@@ -1,3 +1,5 @@
 export * from './scroller';
 export * from './search';
 export * from './utils';
+export * from './widget/pdfviewer';
+export * from './enums/PdfViewerInteractionMode';