@kitware/vtk.js 28.10.2 → 28.11.1

package/IO/Core/DataAccessHelper/JSZipDataAccessHelper.js

@@ -1,30 +1,28 @@
 import { strToU8, unzipSync, strFromU8, decompressSync } from 'fflate';
-import macro from '../../../macros.js';
+import { m as macro } from '../../../macros2.js';
 import Endian from '../../../Common/Core/Endian.js';
 import { DataTypeByteSize } from '../../../Common/Core/DataArray/Constants.js';
 import { registerType } from '../DataAccessHelper.js';
 import { fromArrayBuffer } from '../../../Common/Core/Base64.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro,
-    vtkDebugMacro = macro.vtkDebugMacro;
-
+const {
+  vtkErrorMacro,
+  vtkDebugMacro
+} = macro;
 function toMimeType(url) {
-  var ext = url.split('.').pop().toLowerCase();
-
+  const ext = url.split('.').pop().toLowerCase();
   if (ext === 'jpg') {
     return 'jpeg';
   }
-
   return ext;
 }
-
 function handleUint8Array(array, compression, done) {
-  return function (uint8array) {
-    array.buffer = new ArrayBuffer(uint8array.length); // copy uint8array to buffer
+  return uint8array => {
+    array.buffer = new ArrayBuffer(uint8array.length);
 
-    var view = new Uint8Array(array.buffer);
+    // copy uint8array to buffer
+    const view = new Uint8Array(array.buffer);
     view.set(uint8array);
-
     if (compression) {
       if (array.dataType === 'string' || array.dataType === 'JSON') {
         array.buffer = strFromU8(decompressSync(new Uint8Array(array.buffer)));
@@ -32,226 +30,178 @@ function handleUint8Array(array, compression, done) {
         array.buffer = decompressSync(new Uint8Array(array.buffer)).buffer;
       }
     }
-
     if (array.ref.encode === 'JSON') {
       array.values = JSON.parse(array.buffer);
     } else {
       if (Endian.ENDIANNESS !== array.ref.encode && Endian.ENDIANNESS) {
         // Need to swap bytes
-        vtkDebugMacro("Swap bytes of ".concat(array.name));
+        vtkDebugMacro(`Swap bytes of ${array.name}`);
         Endian.swapBytes(array.buffer, DataTypeByteSize[array.dataType]);
       }
-
       array.values = macro.newTypedArray(array.dataType, array.buffer);
     }
-
     if (array.values.length !== array.size) {
-      vtkErrorMacro("Error in FetchArray: ".concat(array.name, " does not have the proper array size. Got ").concat(array.values.length, ", instead of ").concat(array.size));
+      vtkErrorMacro(`Error in FetchArray: ${array.name} does not have the proper array size. Got ${array.values.length}, instead of ${array.size}`);
     }
-
     done();
   };
 }
-
 function handleString(array, compression, done) {
-  return function (string) {
+  return string => {
     if (compression) {
       array.values = JSON.parse(strFromU8(decompressSync(string)));
     } else {
       array.values = JSON.parse(string);
     }
-
     done();
   };
 }
-
 function removeLeadingSlash(str) {
   return str[0] === '/' ? str.substr(1) : str;
 }
-
 function normalizePath(str) {
   return new URL(str, 'http://any').pathname;
 }
-
 function cleanUpPath(str) {
   return removeLeadingSlash(normalizePath(str));
 }
-
 function unpack(zipContent) {
-  return new Promise(function (resolve, reject) {
+  return new Promise((resolve, reject) => {
     if (typeof zipContent === 'string') {
       resolve(strToU8(zipContent));
     } else if (zipContent instanceof Blob) {
-      resolve(zipContent.arrayBuffer().then(function (ab) {
-        return new Uint8Array(ab);
-      }));
+      resolve(zipContent.arrayBuffer().then(ab => new Uint8Array(ab)));
     } else if (zipContent instanceof ArrayBuffer) {
       resolve(new Uint8Array(zipContent));
-    } else if ((zipContent === null || zipContent === void 0 ? void 0 : zipContent.buffer) instanceof ArrayBuffer) {
+    } else if (zipContent?.buffer instanceof ArrayBuffer) {
       resolve(new Uint8Array(zipContent.buffer));
     } else {
       reject(new Error('Invalid datatype to unpack.'));
     }
   });
 }
-
 function create(createOptions) {
-  var ready = false;
-  var requestCount = 0;
-  var decompressedFiles = null;
-  var fullRootPath = '';
-  unpack(createOptions.zipContent).then(function (zipFileData) {
+  let ready = false;
+  let requestCount = 0;
+  let decompressedFiles = null;
+  let fullRootPath = '';
+  unpack(createOptions.zipContent).then(zipFileData => {
     decompressedFiles = unzipSync(zipFileData);
-    ready = true; // Find root index.json
+    ready = true;
 
-    var metaFiles = [];
-    Object.keys(decompressedFiles).forEach(function (relativePath) {
+    // Find root index.json
+    const metaFiles = [];
+    Object.keys(decompressedFiles).forEach(relativePath => {
       if (relativePath.endsWith('index.json')) {
         metaFiles.push(relativePath);
       }
     });
-    metaFiles.sort(function (a, b) {
-      return a.length - b.length;
-    }); // if not empty, then fullRootPath will have a forward slash suffix
-
+    metaFiles.sort((a, b) => a.length - b.length);
+    // if not empty, then fullRootPath will have a forward slash suffix
     fullRootPath = metaFiles[0].replace(/index\.json$/, '');
-
     if (createOptions.callback) {
       createOptions.callback(decompressedFiles);
     }
   });
   return {
-    fetchArray: function fetchArray(instance, baseURL, array) {
-      var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-      return new Promise(function (resolve, reject) {
+    fetchArray(instance, baseURL, array) {
+      let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+      return new Promise((resolve, reject) => {
         if (!ready) {
           vtkErrorMacro('ERROR!!! zip not ready...');
         }
-
-        var url = cleanUpPath([baseURL, array.ref.basepath, options.compression ? "".concat(array.ref.id, ".gz") : array.ref.id].join('/'));
-
-        if (++requestCount === 1 && instance !== null && instance !== void 0 && instance.invokeBusy) {
+        const url = cleanUpPath([baseURL, array.ref.basepath, options.compression ? `${array.ref.id}.gz` : array.ref.id].join('/'));
+        if (++requestCount === 1 && instance?.invokeBusy) {
           instance.invokeBusy(true);
         }
-
         function doneCleanUp() {
           // Done with the ref and work
           delete array.ref;
-
-          if (--requestCount === 0 && instance !== null && instance !== void 0 && instance.invokeBusy) {
+          if (--requestCount === 0 && instance?.invokeBusy) {
             instance.invokeBusy(false);
           }
-
-          if (instance !== null && instance !== void 0 && instance.modified) {
+          if (instance?.modified) {
             instance.modified();
           }
-
           resolve(array);
         }
-
-        var fileData = decompressedFiles["".concat(fullRootPath).concat(url)];
-
+        const fileData = decompressedFiles[`${fullRootPath}${url}`];
         if (array.dataType === 'string' && !options.compression) {
           // string
-          var handler = handleString(array, options.compression, doneCleanUp);
+          const handler = handleString(array, options.compression, doneCleanUp);
           handler(strFromU8(fileData));
         } else {
           // uint8array
-          var _handler = handleUint8Array(array, options.compression, doneCleanUp);
-
-          _handler(fileData);
+          const handler = handleUint8Array(array, options.compression, doneCleanUp);
+          handler(fileData);
         }
       });
     },
-    fetchJSON: function fetchJSON(instance, url) {
-      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-      var path = cleanUpPath(url);
-
+    fetchJSON(instance, url) {
+      let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      const path = cleanUpPath(url);
       if (!ready) {
         vtkErrorMacro('ERROR!!! zip not ready...');
       }
-
-      var fileData = decompressedFiles["".concat(fullRootPath).concat(path)];
-
+      const fileData = decompressedFiles[`${fullRootPath}${path}`];
       if (options.compression) {
         if (options.compression === 'gz') {
-          var str = strFromU8(decompressSync(fileData));
+          const str = strFromU8(decompressSync(fileData));
           return Promise.resolve(JSON.parse(str));
         }
-
         return Promise.reject(new Error('Invalid compression'));
       }
-
       return Promise.resolve(JSON.parse(strFromU8(fileData)));
     },
-    fetchText: function fetchText(instance, url) {
-      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-      var path = cleanUpPath(url);
-
+    fetchText(instance, url) {
+      let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      const path = cleanUpPath(url);
       if (!ready) {
         vtkErrorMacro('ERROR!!! zip not ready...');
       }
-
-      var fileData = decompressedFiles["".concat(fullRootPath).concat(path)];
-
+      const fileData = decompressedFiles[`${fullRootPath}${path}`];
       if (options.compression) {
         if (options.compression === 'gz') {
           return Promise.resolve(strFromU8(unzipSync(fileData)));
         }
-
         return Promise.reject(new Error('Invalid compression'));
       }
-
       return Promise.resolve(strFromU8(fileData));
     },
-    fetchImage: function fetchImage(instance, url) {
-      var path = cleanUpPath(url);
-
+    fetchImage(instance, url) {
+      const path = cleanUpPath(url);
       if (!ready) {
         vtkErrorMacro('ERROR!!! zip not ready...');
       }
-
-      var fileData = decompressedFiles["".concat(fullRootPath).concat(path)];
-      return new Promise(function (resolve, reject) {
-        var img = new Image();
-
-        img.onload = function () {
-          return resolve(img);
-        };
-
+      const fileData = decompressedFiles[`${fullRootPath}${path}`];
+      return new Promise((resolve, reject) => {
+        const img = new Image();
+        img.onload = () => resolve(img);
         img.onerror = reject;
-        var str = fromArrayBuffer(fileData.buffer);
-        img.src = "data:image/".concat(toMimeType(path), ";base64,").concat(str);
+        const str = fromArrayBuffer(fileData.buffer);
+        img.src = `data:image/${toMimeType(path)};base64,${str}`;
       });
     },
-    fetchBinary: function fetchBinary(instance, url) {
-      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-      var path = cleanUpPath(url);
-
+    fetchBinary(instance, url) {
+      let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      const path = cleanUpPath(url);
       if (!ready) {
         vtkErrorMacro('ERROR!!! zip not ready...');
       }
-
-      var fileData = decompressedFiles["".concat(fullRootPath).concat(path)];
-
+      const fileData = decompressedFiles[`${fullRootPath}${path}`];
       if (options.compression) {
         if (options.compression === 'gz') {
           return Promise.resolve(decompressSync(fileData).buffer);
         }
-
         return Promise.reject(new Error('Invalid compression'));
       }
-
       return Promise.resolve(fileData.buffer);
     }
   };
 }
-
-var JSZipDataAccessHelper = {
-  create: create
+const JSZipDataAccessHelper = {
+  create
 };
-registerType('zip', function (options) {
-  return JSZipDataAccessHelper.create(options);
-});
+registerType('zip', options => JSZipDataAccessHelper.create(options));
 
 export { JSZipDataAccessHelper as default };

package/IO/Core/DataAccessHelper/LiteHttpDataAccessHelper.js

@@ -1,255 +1,218 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import macro from '../../../macros.js';
+import { m as macro } from '../../../macros2.js';
 import Endian from '../../../Common/Core/Endian.js';
 import { DataTypeByteSize } from '../../../Common/Core/DataArray/Constants.js';
 import { has, registerType } from '../DataAccessHelper.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro,
-    vtkDebugMacro = macro.vtkDebugMacro;
-
-var REJECT_COMPRESSION = function REJECT_COMPRESSION() {
+const {
+  vtkErrorMacro,
+  vtkDebugMacro
+} = macro;
+const REJECT_COMPRESSION = () => {
   vtkErrorMacro('LiteHttpDataAccessHelper does not support compression. Need to register HttpDataAccessHelper instead.');
   return Promise.reject(new Error('LiteHttpDataAccessHelper does not support compression. Need to register HttpDataAccessHelper instead.'));
 };
-/* eslint-disable prefer-promise-reject-errors */
-
-
-var requestCount = 0;
 
+/* eslint-disable prefer-promise-reject-errors */
+let requestCount = 0;
 function openAsyncXHR(method, url) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var xhr = new XMLHttpRequest();
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const xhr = new XMLHttpRequest();
   xhr.open(method, url, true);
-
   if (options.headers) {
-    Object.entries(options.headers).forEach(function (_ref) {
-      var _ref2 = _slicedToArray(_ref, 2),
-          key = _ref2[0],
-          value = _ref2[1];
-
+    Object.entries(options.headers).forEach(_ref => {
+      let [key, value] = _ref;
       return xhr.setRequestHeader(key, value);
     });
   }
-
   if (options.progressCallback) {
     xhr.addEventListener('progress', options.progressCallback);
   }
-
   return xhr;
 }
-
 function fetchBinary(url) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  return new Promise(function (resolve, reject) {
-    var xhr = openAsyncXHR('GET', url, options);
-
-    xhr.onreadystatechange = function (e) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return new Promise((resolve, reject) => {
+    const xhr = openAsyncXHR('GET', url, options);
+    xhr.onreadystatechange = e => {
       if (xhr.readyState === 4) {
         if (xhr.status === 200 || xhr.status === 0) {
           resolve(xhr.response);
         } else {
           reject({
-            xhr: xhr,
-            e: e
+            xhr,
+            e
           });
         }
       }
-    }; // Make request
-
+    };
 
+    // Make request
     xhr.responseType = 'arraybuffer';
     xhr.send();
   });
 }
-
 function fetchArray(instance, baseURL, array) {
-  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-
+  let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
   if (options && options.compression) {
     return REJECT_COMPRESSION();
   }
-
   if (array.ref && !array.ref.pending) {
-    return new Promise(function (resolve, reject) {
-      var url = [baseURL, array.ref.basepath, array.ref.id].join('/');
-      var xhr = openAsyncXHR('GET', url, options);
-
-      xhr.onreadystatechange = function (e) {
+    return new Promise((resolve, reject) => {
+      const url = [baseURL, array.ref.basepath, array.ref.id].join('/');
+      const xhr = openAsyncXHR('GET', url, options);
+      xhr.onreadystatechange = e => {
         if (xhr.readyState === 1) {
           array.ref.pending = true;
-
-          if (++requestCount === 1 && instance !== null && instance !== void 0 && instance.invokeBusy) {
+          if (++requestCount === 1 && instance?.invokeBusy) {
             instance.invokeBusy(true);
           }
         }
-
         if (xhr.readyState === 4) {
           array.ref.pending = false;
-
           if (xhr.status === 200 || xhr.status === 0) {
             array.buffer = xhr.response;
-
             if (array.ref.encode === 'JSON') {
               array.values = JSON.parse(array.buffer);
             } else {
               if (Endian.ENDIANNESS !== array.ref.encode && Endian.ENDIANNESS) {
                 // Need to swap bytes
-                vtkDebugMacro("Swap bytes of ".concat(array.name));
+                vtkDebugMacro(`Swap bytes of ${array.name}`);
                 Endian.swapBytes(array.buffer, DataTypeByteSize[array.dataType]);
               }
-
               array.values = macro.newTypedArray(array.dataType, array.buffer);
             }
-
             if (array.values.length !== array.size) {
-              vtkErrorMacro("Error in FetchArray: ".concat(array.name, ", does not have the proper array size. Got ").concat(array.values.length, ", instead of ").concat(array.size));
-            } // Done with the ref and work
-
+              vtkErrorMacro(`Error in FetchArray: ${array.name}, does not have the proper array size. Got ${array.values.length}, instead of ${array.size}`);
+            }
 
+            // Done with the ref and work
             delete array.ref;
-
-            if (--requestCount === 0 && instance !== null && instance !== void 0 && instance.invokeBusy) {
+            if (--requestCount === 0 && instance?.invokeBusy) {
               instance.invokeBusy(false);
             }
-
-            if (instance !== null && instance !== void 0 && instance.modified) {
+            if (instance?.modified) {
               instance.modified();
             }
-
             resolve(array);
           } else {
             reject({
-              xhr: xhr,
-              e: e
+              xhr,
+              e
             });
           }
         }
-      }; // Make request
-
+      };
 
+      // Make request
       xhr.responseType = array.dataType !== 'string' ? 'arraybuffer' : 'text';
       xhr.send();
     });
   }
-
   return Promise.resolve(array);
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function fetchJSON(instance, url) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   if (options && options.compression) {
     return REJECT_COMPRESSION();
   }
-
-  return new Promise(function (resolve, reject) {
-    var xhr = openAsyncXHR('GET', url, options);
-
-    xhr.onreadystatechange = function (e) {
+  return new Promise((resolve, reject) => {
+    const xhr = openAsyncXHR('GET', url, options);
+    xhr.onreadystatechange = e => {
       if (xhr.readyState === 1) {
-        if (++requestCount === 1 && instance !== null && instance !== void 0 && instance.invokeBusy) {
+        if (++requestCount === 1 && instance?.invokeBusy) {
           instance.invokeBusy(true);
         }
       }
-
       if (xhr.readyState === 4) {
-        if (--requestCount === 0 && instance !== null && instance !== void 0 && instance.invokeBusy) {
+        if (--requestCount === 0 && instance?.invokeBusy) {
           instance.invokeBusy(false);
         }
-
         if (xhr.status === 200 || xhr.status === 0) {
           resolve(JSON.parse(xhr.responseText));
         } else {
           reject({
-            xhr: xhr,
-            e: e
+            xhr,
+            e
           });
         }
       }
-    }; // Make request
-
+    };
 
+    // Make request
     xhr.responseType = 'text';
     xhr.send();
   });
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function fetchText(instance, url) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   if (options && options.compression) {
     return REJECT_COMPRESSION();
   }
-
-  return new Promise(function (resolve, reject) {
-    var xhr = openAsyncXHR('GET', url, options);
-
-    xhr.onreadystatechange = function (e) {
+  return new Promise((resolve, reject) => {
+    const xhr = openAsyncXHR('GET', url, options);
+    xhr.onreadystatechange = e => {
       if (xhr.readyState === 1) {
-        if (++requestCount === 1 && instance !== null && instance !== void 0 && instance.invokeBusy) {
+        if (++requestCount === 1 && instance?.invokeBusy) {
           instance.invokeBusy(true);
         }
       }
-
       if (xhr.readyState === 4) {
-        if (--requestCount === 0 && instance !== null && instance !== void 0 && instance.invokeBusy) {
+        if (--requestCount === 0 && instance?.invokeBusy) {
           instance.invokeBusy(false);
         }
-
         if (xhr.status === 200 || xhr.status === 0) {
           resolve(xhr.responseText);
         } else {
           reject({
-            xhr: xhr,
-            e: e
+            xhr,
+            e
           });
         }
       }
-    }; // Make request
-
+    };
 
+    // Make request
     xhr.responseType = 'text';
     xhr.send();
   });
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function fetchImage(instance, url) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  return new Promise(function (resolve, reject) {
-    var img = new Image();
-
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return new Promise((resolve, reject) => {
+    const img = new Image();
     if (options.crossOrigin) {
       img.crossOrigin = options.crossOrigin;
     }
-
-    img.onload = function () {
-      return resolve(img);
-    };
-
+    img.onload = () => resolve(img);
     img.onerror = reject;
     img.src = url;
   });
 }
 /* eslint-enable prefer-promise-reject-errors */
-// ----------------------------------------------------------------------------
 
+// ----------------------------------------------------------------------------
 
-var LiteHttpDataAccessHelper = {
-  fetchArray: fetchArray,
-  fetchJSON: fetchJSON,
-  fetchText: fetchText,
-  fetchBinary: fetchBinary,
+const LiteHttpDataAccessHelper = {
+  fetchArray,
+  fetchJSON,
+  fetchText,
+  fetchBinary,
   // Only for HTTP
-  fetchImage: fetchImage
-}; // The lite version should never override a full feature one...
+  fetchImage
+};
 
+// The lite version should never override a full feature one...
 if (!has('http')) {
-  registerType('http', function (options) {
-    return LiteHttpDataAccessHelper;
-  });
+  registerType('http', options => LiteHttpDataAccessHelper);
 }
 
 export { LiteHttpDataAccessHelper as default };

package/IO/Core/DataAccessHelper.js

@@ -1,19 +1,19 @@
-var TYPE_MAPPING = {};
+const TYPE_MAPPING = {};
 function has(type) {
   return !!TYPE_MAPPING[type];
 }
 function get() {
-  var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'http';
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'http';
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   return TYPE_MAPPING[type](options);
 }
 function registerType(type, fn) {
   TYPE_MAPPING[type] = fn;
 }
 var DataAccessHelper = {
-  get: get,
-  has: has,
-  registerType: registerType
+  get,
+  has,
+  registerType
 };
 
 export { DataAccessHelper as default, get, has, registerType };