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

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 };