@vaadin-component-factory/vcf-pdf-viewer 4.0.1 → 4.1.0

package/README.md

@@ -19,6 +19,14 @@ This component is part of Vaadin Component Factory.
 
 1. Run `npm start` to open the demo.
 
+## Development & publishing
+
+DO NOT run `npm run build` before publishing a new release.
+
+The `pdfjs/dist` files committed in this repository are manually edited to ensure correct module resolution. Running the build script will overwrite these files, generating incompatible file paths that will cause the component to fail when trying to resolve dependencies.
+
+Only run `npm run build` if you are intentionally modifying the `pdfjs` dependency and are prepared to manually fix the resulting path references.
+
 ## Contributing
 
 To contribute to the component, please read [the guideline](https://github.com/vaadin/vaadin-core/blob/master/CONTRIBUTING.md) first.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vaadin-component-factory/vcf-pdf-viewer",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "Lit element providing pdf viewer",
   "author": "Vaadin Ltd",
   "license": "Apache-2.0",
@@ -24,6 +24,8 @@
     "pdfjs/dist"
   ],
   "dependencies": {
+    "@fluent/bundle": "^0.18.0",
+    "@fluent/dom": "^0.9.0",
     "@vaadin/button": "^25.0.0",
     "@vaadin/component-base": "^25.0.0",
     "@vaadin/icon": "^25.0.0",
@@ -49,9 +51,12 @@
     "@custom-elements-manifest/analyzer": "^0.11.0",
     "@eslint/compat": "^2.0.0",
     "@open-wc/testing": "^4.0.0",
+    "@rollup/plugin-alias": "^5.1.1",
     "@rollup/plugin-babel": "6.1.0",
     "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-replace": "^6.0.3",
+    "@rollup/plugin-typescript": "^12.1.2",
     "@vaadin/vaadin-lumo-styles": "^25.0.0",
     "@web/dev-server": "^0.4.6",
     "@web/test-runner": "^0.20.2",
@@ -66,6 +71,7 @@
     "rollup": "^4.53.2",
     "rollup-plugin-copy": "^3.5.0",
     "rollup-plugin-filesize": "^10.0.0",
+    "tslib": "^2.6.2",
     "webpack": "^5.103.0",
     "webpack-cli": "^6.0.1",
     "webpack-dev-server": "^5.2.2"
@@ -80,4 +86,4 @@
     "build": "rimraf dist && rollup -c pdfjs/rollup.config.js"
   },
   "customElements": "custom-elements.json"
-}
+}

package/pdfjs/dist/event_utils.js

@@ -0,0 +1,207 @@
+/* Copyright 2012 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.
+ */
+
+const WaitOnType = {
+  EVENT: "event",
+  TIMEOUT: "timeout"
+};
+
+/**
+ * @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.
+ */
+async function waitOnEventOrTimeout({
+  target,
+  name,
+  delay = 0
+}) {
+  if (typeof target !== "object" || !(name && typeof name === "string") || !(Number.isInteger(delay) && delay >= 0)) {
+    throw new Error("waitOnEventOrTimeout - invalid parameters.");
+  }
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  const ac = new AbortController();
+  function handler(type) {
+    ac.abort(); // Remove event listener.
+    clearTimeout(timeout);
+    resolve(type);
+  }
+  const evtMethod = target instanceof EventBus ? "_on" : "addEventListener";
+  target[evtMethod](name, handler.bind(null, WaitOnType.EVENT), {
+    signal: ac.signal
+  });
+  const timeout = setTimeout(handler.bind(null, WaitOnType.TIMEOUT), delay);
+  return promise;
+}
+
+/**
+ * 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.
+ */
+class EventBus {
+  #listeners = Object.create(null);
+
+  /**
+   * @param {string} eventName
+   * @param {function} listener
+   * @param {Object} [options]
+   */
+  on(eventName, listener, options = null) {
+    this._on(eventName, listener, {
+      external: true,
+      once: options === null || options === void 0 ? void 0 : options.once,
+      signal: options === null || options === void 0 ? void 0 : options.signal
+    });
+  }
+
+  /**
+   * @param {string} eventName
+   * @param {function} listener
+   * @param {Object} [options]
+   */
+  off(eventName, listener, options = null) {
+    this._off(eventName, listener);
+  }
+
+  /**
+   * @param {string} eventName
+   * @param {Object} data
+   */
+  dispatch(eventName, data) {
+    const eventListeners = this.#listeners[eventName];
+    if (!eventListeners || eventListeners.length === 0) {
+      return;
+    }
+    let externalListeners;
+    // Making copy of the listeners array in case if it will be modified
+    // during dispatch.
+    for (const {
+      listener,
+      external,
+      once
+    } of eventListeners.slice(0)) {
+      if (once) {
+        this._off(eventName, listener);
+      }
+      if (external) {
+        (externalListeners || (externalListeners = [])).push(listener);
+        continue;
+      }
+      listener(data);
+    }
+    // Dispatch any "external" listeners *after* the internal ones, to give the
+    // viewer components time to handle events and update their state first.
+    if (externalListeners) {
+      for (const listener of externalListeners) {
+        listener(data);
+      }
+      externalListeners = null;
+    }
+  }
+
+  /**
+   * @ignore
+   */
+  _on(eventName, listener, options = null) {
+    var _this$listeners;
+    let rmAbort = null;
+    if ((options === null || options === void 0 ? void 0 : options.signal) instanceof AbortSignal) {
+      const {
+        signal
+      } = options;
+      if (signal.aborted) {
+        console.error("Cannot use an `aborted` signal.");
+        return;
+      }
+      const onAbort = () => this._off(eventName, listener);
+      rmAbort = () => signal.removeEventListener("abort", onAbort);
+      signal.addEventListener("abort", onAbort);
+    }
+    const eventListeners = (_this$listeners = this.#listeners)[eventName] || (_this$listeners[eventName] = []);
+    eventListeners.push({
+      listener,
+      external: (options === null || options === void 0 ? void 0 : options.external) === true,
+      once: (options === null || options === void 0 ? void 0 : options.once) === true,
+      rmAbort
+    });
+  }
+
+  /**
+   * @ignore
+   */
+  _off(eventName, listener, options = null) {
+    const eventListeners = this.#listeners[eventName];
+    if (!eventListeners) {
+      return;
+    }
+    for (let i = 0, ii = eventListeners.length; i < ii; i++) {
+      const evt = eventListeners[i];
+      if (evt.listener === listener) {
+        var _evt$rmAbort;
+        (_evt$rmAbort = evt.rmAbort) === null || _evt$rmAbort === void 0 ? void 0 : _evt$rmAbort.call(evt); // Ensure that the `AbortSignal` listener is removed.
+        eventListeners.splice(i, 1);
+        return;
+      }
+    }
+  }
+}
+
+/**
+ * NOTE: Only used to support various PDF viewer tests in `mozilla-central`.
+ */
+class AutomationEventBus extends EventBus {
+  dispatch(eventName, data) {
+    if (typeof PDFJSDev !== "undefined" && !PDFJSDev.test("MOZCENTRAL")) {
+      throw new Error("Not implemented: AutomationEventBus.dispatch");
+    }
+    super.dispatch(eventName, data);
+    const detail = Object.create(null);
+    if (data) {
+      for (const key in data) {
+        const value = data[key];
+        if (key === "source") {
+          if (value === window || value === document) {
+            return; // No need to re-dispatch (already) global events.
+          }
+          continue; // Ignore the `source` property.
+        }
+        detail[key] = value;
+      }
+    }
+    const event = new CustomEvent(eventName, {
+      bubbles: true,
+      cancelable: true,
+      detail
+    });
+    document.dispatchEvent(event);
+  }
+}
+
+export { AutomationEventBus, EventBus, WaitOnType, waitOnEventOrTimeout };