@vaadin-component-factory/vcf-pdf-viewer 0.9.0 → 1.0.0

package/{src/display → pdfjs/dist}/fetch_stream.js

@@ -1,3 +1,7 @@
+import { c as assert, l as createPromiseCapability, A as AbortException } from './util.js';
+import { a as validateResponseStatus, c as createResponseStatusError, v as validateRangeRequestCapabilities, e as extractFilenameFromHeader } from './network_utils.js';
+import './display_utils.js';
+
 /* Copyright 2012 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,67 +17,56 @@
  * limitations under the License.
  */
 
-import {
-  AbortException,
-  assert,
-  createPromiseCapability,
-} from "../shared/util.js";
-import {
-  createResponseStatusError,
-  extractFilenameFromHeader,
-  validateRangeRequestCapabilities,
-  validateResponseStatus,
-} from "./network_utils.js";
-
 if (typeof PDFJSDev !== "undefined" && PDFJSDev.test("MOZCENTRAL")) {
-  throw new Error(
-    'Module "./fetch_stream.js" shall not be used with MOZCENTRAL builds.'
-  );
+  throw new Error('Module "./fetch_stream.js" shall not be used with MOZCENTRAL builds.');
 }
 
 function createFetchOptions(headers, withCredentials, abortController) {
   return {
     method: "GET",
     headers,
-    signal: abortController?.signal,
+    signal: abortController === null || abortController === void 0 ? void 0 : abortController.signal,
     mode: "cors",
     credentials: withCredentials ? "include" : "same-origin",
-    redirect: "follow",
+    redirect: "follow"
   };
 }
 
 function createHeaders(httpHeaders) {
   const headers = new Headers();
+
   for (const property in httpHeaders) {
     const value = httpHeaders[property];
+
     if (typeof value === "undefined") {
       continue;
     }
+
     headers.append(property, value);
   }
+
   return headers;
 }
-
 /** @implements {IPDFStream} */
+
+
 class PDFFetchStream {
   constructor(source) {
     this.source = source;
     this.isHttp = /^https?:/i.test(source.url);
-    this.httpHeaders = (this.isHttp && source.httpHeaders) || {};
-
+    this.httpHeaders = this.isHttp && source.httpHeaders || {};
     this._fullRequestReader = null;
     this._rangeRequestReaders = [];
   }
 
   get _progressiveDataLength() {
-    return this._fullRequestReader?._loaded ?? 0;
+    var _this$_fullRequestRea, _this$_fullRequestRea2;
+
+    return (_this$_fullRequestRea = (_this$_fullRequestRea2 = this._fullRequestReader) === null || _this$_fullRequestRea2 === void 0 ? void 0 : _this$_fullRequestRea2._loaded) !== null && _this$_fullRequestRea !== void 0 ? _this$_fullRequestRea : 0;
   }
 
   getFullReader() {
-    assert(
-      !this._fullRequestReader,
-      "PDFFetchStream.getFullReader can only be called once."
-    );
+    assert(!this._fullRequestReader, "PDFFetchStream.getFullReader can only be called once.");
     this._fullRequestReader = new PDFFetchStreamReader(this);
     return this._fullRequestReader;
   }
@@ -82,8 +75,11 @@ class PDFFetchStream {
     if (end <= this._progressiveDataLength) {
       return null;
     }
+
     const reader = new PDFFetchStreamRangeReader(this, begin, end);
+
     this._rangeRequestReaders.push(reader);
+
     return reader;
   }
 
@@ -91,13 +87,16 @@ class PDFFetchStream {
     if (this._fullRequestReader) {
       this._fullRequestReader.cancel(reason);
     }
+
     for (const reader of this._rangeRequestReaders.slice(0)) {
       reader.cancel(reason);
     }
   }
-}
 
+}
 /** @implements {IPDFStreamReader} */
+
+
 class PDFFetchStreamReader {
   constructor(stream) {
     this._stream = stream;
@@ -110,6 +109,7 @@ class PDFFetchStreamReader {
     this._headersCapability = createPromiseCapability();
     this._disableRange = source.disableRange || false;
     this._rangeChunkSize = source.rangeChunkSize;
+
     if (!this._rangeChunkSize && !this._disableRange) {
       this._disableRange = true;
     }
@@ -117,52 +117,43 @@ class PDFFetchStreamReader {
     if (typeof AbortController !== "undefined") {
       this._abortController = new AbortController();
     }
+
     this._isStreamingSupported = !source.disableStream;
     this._isRangeSupported = !source.disableRange;
-
     this._headers = createHeaders(this._stream.httpHeaders);
-
     const url = source.url;
-    fetch(
-      url,
-      createFetchOptions(
-        this._headers,
-        this._withCredentials,
-        this._abortController
-      )
-    )
-      .then(response => {
-        if (!validateResponseStatus(response.status)) {
-          throw createResponseStatusError(response.status, url);
-        }
-        this._reader = response.body.getReader();
-        this._headersCapability.resolve();
-
-        const getResponseHeader = name => {
-          return response.headers.get(name);
-        };
-        const { allowRangeRequests, suggestedLength } =
-          validateRangeRequestCapabilities({
-            getResponseHeader,
-            isHttp: this._stream.isHttp,
-            rangeChunkSize: this._rangeChunkSize,
-            disableRange: this._disableRange,
-          });
-
-        this._isRangeSupported = allowRangeRequests;
-        // Setting right content length.
-        this._contentLength = suggestedLength || this._contentLength;
-
-        this._filename = extractFilenameFromHeader(getResponseHeader);
-
-        // We need to stop reading when range is supported and streaming is
-        // disabled.
-        if (!this._isStreamingSupported && this._isRangeSupported) {
-          this.cancel(new AbortException("Streaming is disabled."));
-        }
-      })
-      .catch(this._headersCapability.reject);
+    fetch(url, createFetchOptions(this._headers, this._withCredentials, this._abortController)).then(response => {
+      if (!validateResponseStatus(response.status)) {
+        throw createResponseStatusError(response.status, url);
+      }
+
+      this._reader = response.body.getReader();
+
+      this._headersCapability.resolve();
+
+      const getResponseHeader = name => {
+        return response.headers.get(name);
+      };
+
+      const {
+        allowRangeRequests,
+        suggestedLength
+      } = validateRangeRequestCapabilities({
+        getResponseHeader,
+        isHttp: this._stream.isHttp,
+        rangeChunkSize: this._rangeChunkSize,
+        disableRange: this._disableRange
+      });
+      this._isRangeSupported = allowRangeRequests; // Setting right content length.
+
+      this._contentLength = suggestedLength || this._contentLength;
+      this._filename = extractFilenameFromHeader(getResponseHeader); // We need to stop reading when range is supported and streaming is
+      // disabled.
 
+      if (!this._isStreamingSupported && this._isRangeSupported) {
+        this.cancel(new AbortException("Streaming is disabled."));
+      }
+    }).catch(this._headersCapability.reject);
     this.onProgress = null;
   }
 
@@ -188,32 +179,48 @@ class PDFFetchStreamReader {
 
   async read() {
     await this._headersCapability.promise;
-    const { value, done } = await this._reader.read();
+    const {
+      value,
+      done
+    } = await this._reader.read();
+
     if (done) {
-      return { value, done };
+      return {
+        value,
+        done
+      };
     }
+
     this._loaded += value.byteLength;
+
     if (this.onProgress) {
       this.onProgress({
         loaded: this._loaded,
-        total: this._contentLength,
+        total: this._contentLength
       });
     }
+
     const buffer = new Uint8Array(value).buffer;
-    return { value: buffer, done: false };
+    return {
+      value: buffer,
+      done: false
+    };
   }
 
   cancel(reason) {
     if (this._reader) {
       this._reader.cancel(reason);
     }
+
     if (this._abortController) {
       this._abortController.abort();
     }
   }
-}
 
+}
 /** @implements {IPDFStreamRangeReader} */
+
+
 class PDFFetchStreamRangeReader {
   constructor(stream, begin, end) {
     this._stream = stream;
@@ -229,31 +236,25 @@ class PDFFetchStreamRangeReader {
     }
 
     this._headers = createHeaders(this._stream.httpHeaders);
+
     this._headers.append("Range", `bytes=${begin}-${end - 1}`);
 
     const url = source.url;
-    fetch(
-      url,
-      createFetchOptions(
-        this._headers,
-        this._withCredentials,
-        this._abortController
-      )
-    )
-      .then(response => {
-        if (!validateResponseStatus(response.status)) {
-          throw createResponseStatusError(response.status, url);
-        }
-        this._readCapability.resolve();
-        this._reader = response.body.getReader();
-      })
-      .catch(reason => {
-        if (reason?.name === "AbortError") {
-          return;
-        }
-        throw reason;
-      });
+    fetch(url, createFetchOptions(this._headers, this._withCredentials, this._abortController)).then(response => {
+      if (!validateResponseStatus(response.status)) {
+        throw createResponseStatusError(response.status, url);
+      }
+
+      this._readCapability.resolve();
+
+      this._reader = response.body.getReader();
+    }).catch(reason => {
+      if ((reason === null || reason === void 0 ? void 0 : reason.name) === "AbortError") {
+        return;
+      }
 
+      throw reason;
+    });
     this.onProgress = null;
   }
 
@@ -263,26 +264,43 @@ class PDFFetchStreamRangeReader {
 
   async read() {
     await this._readCapability.promise;
-    const { value, done } = await this._reader.read();
+    const {
+      value,
+      done
+    } = await this._reader.read();
+
     if (done) {
-      return { value, done };
+      return {
+        value,
+        done
+      };
     }
+
     this._loaded += value.byteLength;
+
     if (this.onProgress) {
-      this.onProgress({ loaded: this._loaded });
+      this.onProgress({
+        loaded: this._loaded
+      });
     }
+
     const buffer = new Uint8Array(value).buffer;
-    return { value: buffer, done: false };
+    return {
+      value: buffer,
+      done: false
+    };
   }
 
   cancel(reason) {
     if (this._reader) {
       this._reader.cancel(reason);
     }
+
     if (this._abortController) {
       this._abortController.abort();
     }
   }
+
 }
 
 export { PDFFetchStream };

package/pdfjs/dist/l10n_utils.js

@@ -0,0 +1,140 @@
+/* Copyright 2021 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.
+ */
+
+/**
+ * A subset of the l10n strings in the `l10n/en-US/viewer.properties` file.
+ */
+const DEFAULT_L10N_STRINGS = {
+  of_pages: "of {{pagesCount}}",
+  page_of_pages: "({{pageNumber}} of {{pagesCount}})",
+  document_properties_kb: "{{size_kb}} KB ({{size_b}} bytes)",
+  document_properties_mb: "{{size_mb}} MB ({{size_b}} bytes)",
+  document_properties_date_string: "{{date}}, {{time}}",
+  document_properties_page_size_unit_inches: "in",
+  document_properties_page_size_unit_millimeters: "mm",
+  document_properties_page_size_orientation_portrait: "portrait",
+  document_properties_page_size_orientation_landscape: "landscape",
+  document_properties_page_size_name_a3: "A3",
+  document_properties_page_size_name_a4: "A4",
+  document_properties_page_size_name_letter: "Letter",
+  document_properties_page_size_name_legal: "Legal",
+  document_properties_page_size_dimension_string: "{{width}} × {{height}} {{unit}} ({{orientation}})",
+  document_properties_page_size_dimension_name_string: "{{width}} × {{height}} {{unit}} ({{name}}, {{orientation}})",
+  document_properties_linearized_yes: "Yes",
+  document_properties_linearized_no: "No",
+  print_progress_percent: "{{progress}}%",
+  "toggle_sidebar.title": "Toggle Sidebar",
+  "toggle_sidebar_notification2.title": "Toggle Sidebar (document contains outline/attachments/layers)",
+  additional_layers: "Additional Layers",
+  page_landmark: "Page {{page}}",
+  thumb_page_title: "Page {{page}}",
+  thumb_page_canvas: "Thumbnail of Page {{page}}",
+  find_reached_top: "Reached top of document, continued from bottom",
+  find_reached_bottom: "Reached end of document, continued from top",
+  "find_match_count[one]": "{{current}} of {{total}} match",
+  "find_match_count[other]": "{{current}} of {{total}} matches",
+  "find_match_count_limit[one]": "More than {{limit}} match",
+  "find_match_count_limit[other]": "More than {{limit}} matches",
+  find_not_found: "Phrase not found",
+  error_version_info: "PDF.js v{{version}} (build: {{build}})",
+  error_message: "Message: {{message}}",
+  error_stack: "Stack: {{stack}}",
+  error_file: "File: {{file}}",
+  error_line: "Line: {{line}}",
+  rendering_error: "An error occurred while rendering the page.",
+  page_scale_width: "Page Width",
+  page_scale_fit: "Page Fit",
+  page_scale_auto: "Automatic Zoom",
+  page_scale_actual: "Actual Size",
+  page_scale_percent: "{{scale}}%",
+  loading: "Loading…",
+  loading_error: "An error occurred while loading the PDF.",
+  invalid_file_error: "Invalid or corrupted PDF file.",
+  missing_file_error: "Missing PDF file.",
+  unexpected_response_error: "Unexpected server response.",
+  printing_not_supported: "Warning: Printing is not fully supported by this browser.",
+  printing_not_ready: "Warning: The PDF is not fully loaded for printing.",
+  web_fonts_disabled: "Web fonts are disabled: unable to use embedded PDF fonts."
+};
+
+function getL10nFallback(key, args) {
+  switch (key) {
+    case "find_match_count":
+      key = `find_match_count[${args.total === 1 ? "one" : "other"}]`;
+      break;
+
+    case "find_match_count_limit":
+      key = `find_match_count_limit[${args.limit === 1 ? "one" : "other"}]`;
+      break;
+  }
+
+  return DEFAULT_L10N_STRINGS[key] || "";
+}
+
+const PARTIAL_LANG_CODES = {
+  en: "en-US",
+  es: "es-ES",
+  fy: "fy-NL",
+  ga: "ga-IE",
+  gu: "gu-IN",
+  hi: "hi-IN",
+  hy: "hy-AM",
+  nb: "nb-NO",
+  ne: "ne-NP",
+  nn: "nn-NO",
+  pa: "pa-IN",
+  pt: "pt-PT",
+  sv: "sv-SE",
+  zh: "zh-CN"
+}; // Try to support "incompletely" specified language codes (see issue 13689).
+
+function fixupLangCode(langCode) {
+  return PARTIAL_LANG_CODES[langCode === null || langCode === void 0 ? void 0 : langCode.toLowerCase()] || langCode;
+} // Replaces {{arguments}} with their values.
+
+
+function formatL10nValue(text, args) {
+  if (!args) {
+    return text;
+  }
+
+  return text.replace(/\{\{\s*(\w+)\s*\}\}/g, (all, name) => {
+    return name in args ? args[name] : "{{" + name + "}}";
+  });
+}
+/**
+ * No-op implementation of the localization service.
+ * @implements {IL10n}
+ */
+
+
+const NullL10n = {
+  async getLanguage() {
+    return "en-us";
+  },
+
+  async getDirection() {
+    return "ltr";
+  },
+
+  async get(key, args = null, fallback = getL10nFallback(key, args)) {
+    return formatL10nValue(fallback, args);
+  },
+
+  async translate(element) {}
+
+};
+
+export { NullL10n, fixupLangCode, getL10nFallback };