@kitware/vtk.js 25.3.0 → 25.6.0

package/IO/Core/DataAccessHelper/HtmlDataAccessHelper.js

@@ -1,4 +1,4 @@
-import pako from 'pako';
+import { strFromU8, decompressSync } from 'fflate';
 import macro from '../../../macros.js';
 import Base64 from '../../../Common/Core/Base64.js';
 import Endian from '../../../Common/Core/Endian.js';
@@ -59,9 +59,7 @@ function fetchArray(instance, baseURL, array) {
         var bText = atob(txt);
 
         if (options.compression) {
-          bText = pako.inflate(bText, {
-            to: 'string'
-          });
+          bText = strFromU8(decompressSync(bText));
         }
 
         array.values = JSON.parse(bText);
@@ -74,11 +72,9 @@ function fetchArray(instance, baseURL, array) {
 
         if (options.compression) {
           if (array.dataType === 'string' || array.dataType === 'JSON') {
-            array.buffer = pako.inflate(new Uint8Array(array.buffer), {
-              to: 'string'
-            });
+            array.buffer = strFromU8(decompressSync(new Uint8Array(array.buffer)));
           } else {
-            array.buffer = pako.inflate(new Uint8Array(array.buffer)).buffer;
+            array.buffer = decompressSync(new Uint8Array(array.buffer)).buffer;
           }
         }
 

package/IO/Core/DataAccessHelper/HttpDataAccessHelper.js

@@ -1,5 +1,5 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import pako from 'pako';
+import { decompressSync, strFromU8 } from 'fflate';
 import macro from '../../../macros.js';
 import Endian from '../../../Common/Core/Endian.js';
 import { DataTypeByteSize } from '../../../Common/Core/DataArray/Constants.js';
@@ -48,9 +48,7 @@ function fetchBinary(url) {
       if (xhr.readyState === 4) {
         if (xhr.status === 200 || xhr.status === 0) {
           if (options.compression) {
-            resolve(pako.inflate(new Uint8Array(xhr.response), {
-              to: 'arraybuffer'
-            }).buffer);
+            resolve(decompressSync(new Uint8Array(xhr.response)).buffer);
           } else {
             resolve(xhr.response);
           }
@@ -101,11 +99,9 @@ function fetchArray(instance, baseURL, array) {
 
             if (options.compression) {
               if (array.dataType === 'string' || array.dataType === 'JSON') {
-                array.buffer = pako.inflate(new Uint8Array(array.buffer), {
-                  to: 'string'
-                });
+                array.buffer = strFromU8(decompressSync(new Uint8Array(array.buffer)));
               } else {
-                array.buffer = pako.inflate(new Uint8Array(array.buffer)).buffer;
+                array.buffer = decompressSync(new Uint8Array(array.buffer)).buffer;
               }
             }
 
@@ -175,9 +171,7 @@ function fetchJSON(instance, url) {
 
         if (xhr.status === 200 || xhr.status === 0) {
           if (options.compression) {
-            resolve(JSON.parse(pako.inflate(new Uint8Array(xhr.response), {
-              to: 'string'
-            })));
+            resolve(JSON.parse(strFromU8(decompressSync(new Uint8Array(xhr.response)))));
           } else {
             resolve(JSON.parse(xhr.responseText));
           }
@@ -222,9 +216,7 @@ function fetchText(instance, url) {
 
         if (xhr.status === 200 || xhr.status === 0) {
           if (options.compression) {
-            resolve(pako.inflate(new Uint8Array(xhr.response), {
-              to: 'string'
-            }));
+            resolve(strFromU8(decompressSync(new Uint8Array(xhr.response))));
           } else {
             resolve(xhr.responseText);
           }

package/IO/Core/DataAccessHelper/JSZipDataAccessHelper.js

@@ -1,9 +1,9 @@
-import JSZip from 'jszip';
-import pako from 'pako';
+import { strToU8, unzipSync, strFromU8, decompressSync } from 'fflate';
 import macro from '../../../macros.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;
@@ -27,11 +27,9 @@ function handleUint8Array(array, compression, done) {
 
     if (compression) {
       if (array.dataType === 'string' || array.dataType === 'JSON') {
-        array.buffer = pako.inflate(new Uint8Array(array.buffer), {
-          to: 'string'
-        });
+        array.buffer = strFromU8(decompressSync(new Uint8Array(array.buffer)));
       } else {
-        array.buffer = pako.inflate(new Uint8Array(array.buffer)).buffer;
+        array.buffer = decompressSync(new Uint8Array(array.buffer)).buffer;
       }
     }
 
@@ -58,9 +56,7 @@ function handleUint8Array(array, compression, done) {
 function handleString(array, compression, done) {
   return function (string) {
     if (compression) {
-      array.values = JSON.parse(pako.inflate(string, {
-        to: 'string'
-      }));
+      array.values = JSON.parse(strFromU8(decompressSync(string)));
     } else {
       array.values = JSON.parse(string);
     }
@@ -69,11 +65,6 @@ function handleString(array, compression, done) {
   };
 }
 
-var handlers = {
-  uint8array: handleUint8Array,
-  string: handleString
-};
-
 function removeLeadingSlash(str) {
   return str[0] === '/' ? str.substr(1) : str;
 }
@@ -86,32 +77,47 @@ function cleanUpPath(str) {
   return removeLeadingSlash(normalizePath(str));
 }
 
+function unpack(zipContent) {
+  return new Promise(function (resolve, reject) {
+    if (typeof zipContent === 'string') {
+      resolve(strToU8(zipContent));
+    } else if (zipContent instanceof Blob) {
+      resolve(zipContent.arrayBuffer().then(function (ab) {
+        return 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) {
+      resolve(new Uint8Array(zipContent.buffer));
+    } else {
+      reject(new Error('Invalid datatype to unpack.'));
+    }
+  });
+}
+
 function create(createOptions) {
   var ready = false;
   var requestCount = 0;
-  var zip = new JSZip();
-  var zipRoot = zip;
-  zip.loadAsync(createOptions.zipContent).then(function () {
+  var decompressedFiles = null;
+  var fullRootPath = '';
+  unpack(createOptions.zipContent).then(function (zipFileData) {
+    decompressedFiles = unzipSync(zipFileData);
     ready = true; // Find root index.json
 
     var metaFiles = [];
-    zip.forEach(function (relativePath, zipEntry) {
-      if (relativePath.indexOf('index.json') !== -1) {
+    Object.keys(decompressedFiles).forEach(function (relativePath) {
+      if (relativePath.endsWith('index.json')) {
         metaFiles.push(relativePath);
       }
     });
     metaFiles.sort(function (a, b) {
       return a.length - b.length;
-    });
-    var fullRootPath = metaFiles[0].split('/');
+    }); // if not empty, then fullRootPath will have a forward slash suffix
 
-    while (fullRootPath.length > 1) {
-      var dirName = fullRootPath.shift();
-      zipRoot = zipRoot.folder(dirName);
-    }
+    fullRootPath = metaFiles[0].replace(/index\.json$/, '');
 
     if (createOptions.callback) {
-      createOptions.callback(zip);
+      createOptions.callback(decompressedFiles);
     }
   });
   return {
@@ -143,9 +149,18 @@ function create(createOptions) {
           resolve(array);
         }
 
-        var asyncType = array.dataType === 'string' && !options.compression ? 'string' : 'uint8array';
-        var asyncCallback = handlers[asyncType](array, options.compression, doneCleanUp);
-        zipRoot.file(url).async(asyncType).then(asyncCallback);
+        var fileData = decompressedFiles["".concat(fullRootPath).concat(url)];
+
+        if (array.dataType === 'string' && !options.compression) {
+          // string
+          var handler = handleString(array, options.compression, doneCleanUp);
+          handler(strFromU8(fileData));
+        } else {
+          // uint8array
+          var _handler = handleUint8Array(array, options.compression, doneCleanUp);
+
+          _handler(fileData);
+        }
       });
     },
     fetchJSON: function fetchJSON(instance, url) {
@@ -156,22 +171,18 @@ function create(createOptions) {
         vtkErrorMacro('ERROR!!! zip not ready...');
       }
 
+      var fileData = decompressedFiles["".concat(fullRootPath).concat(path)];
+
       if (options.compression) {
         if (options.compression === 'gz') {
-          return zipRoot.file(path).async('uint8array').then(function (uint8array) {
-            var str = pako.inflate(uint8array, {
-              to: 'string'
-            });
-            return Promise.resolve(JSON.parse(str));
-          });
+          var str = strFromU8(decompressSync(fileData));
+          return Promise.resolve(JSON.parse(str));
         }
 
         return Promise.reject(new Error('Invalid compression'));
       }
 
-      return zipRoot.file(path).async('string').then(function (str) {
-        return Promise.resolve(JSON.parse(str));
-      });
+      return Promise.resolve(JSON.parse(strFromU8(fileData)));
     },
     fetchText: function fetchText(instance, url) {
       var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
@@ -181,22 +192,17 @@ function create(createOptions) {
         vtkErrorMacro('ERROR!!! zip not ready...');
       }
 
+      var fileData = decompressedFiles["".concat(fullRootPath).concat(path)];
+
       if (options.compression) {
         if (options.compression === 'gz') {
-          return zipRoot.file(path).async('uint8array').then(function (uint8array) {
-            var str = pako.inflate(uint8array, {
-              to: 'string'
-            });
-            return Promise.resolve(str);
-          });
+          return Promise.resolve(strFromU8(unzipSync(fileData)));
         }
 
         return Promise.reject(new Error('Invalid compression'));
       }
 
-      return zipRoot.file(path).async('string').then(function (str) {
-        return Promise.resolve(str);
-      });
+      return Promise.resolve(strFromU8(fileData));
     },
     fetchImage: function fetchImage(instance, url) {
       var path = cleanUpPath(url);
@@ -205,6 +211,7 @@ function create(createOptions) {
         vtkErrorMacro('ERROR!!! zip not ready...');
       }
 
+      var fileData = decompressedFiles["".concat(fullRootPath).concat(path)];
       return new Promise(function (resolve, reject) {
         var img = new Image();
 
@@ -213,9 +220,8 @@ function create(createOptions) {
         };
 
         img.onerror = reject;
-        zipRoot.file(path).async('base64').then(function (str) {
-          img.src = "data:image/".concat(toMimeType(path), ";base64,").concat(str);
-        });
+        var str = fromArrayBuffer(fileData.buffer);
+        img.src = "data:image/".concat(toMimeType(path), ";base64,").concat(str);
       });
     },
     fetchBinary: function fetchBinary(instance, url) {
@@ -226,20 +232,17 @@ function create(createOptions) {
         vtkErrorMacro('ERROR!!! zip not ready...');
       }
 
+      var fileData = decompressedFiles["".concat(fullRootPath).concat(path)];
+
       if (options.compression) {
         if (options.compression === 'gz') {
-          return zipRoot.file(path).then(function (data) {
-            var array = pako.inflate(data).buffer;
-            return Promise.resolve(array);
-          });
+          return Promise.resolve(decompressSync(fileData).buffer);
         }
 
         return Promise.reject(new Error('Invalid compression'));
       }
 
-      return zipRoot.file(path).async('arraybuffer').then(function (data) {
-        return Promise.resolve(data);
-      });
+      return Promise.resolve(fileData.buffer);
     }
   };
 }

package/IO/Core/ZipMultiDataSetReader.js

@@ -1,5 +1,5 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import JSZip from 'jszip';
+import { unzipSync, strFromU8 } from 'fflate';
 import DataAccessHelper from './DataAccessHelper.js';
 import macro from '../../macros.js';
 import './DataAccessHelper/HttpDataAccessHelper.js';
@@ -49,41 +49,31 @@ function vtkZipMultiDataSetReader(publicAPI, model) {
 
     return new Promise(function (resolve, reject) {
       model.arrays = [];
-      var zip = new JSZip();
-      zip.loadAsync(arrayBuffer).then(function () {
-        var processing = 0;
-        zip.forEach(function (relativePath, zipEntry) {
+      var decompressedFiles = unzipSync(new Uint8Array(arrayBuffer));
+
+      try {
+        Object.entries(decompressedFiles).forEach(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+              relativePath = _ref2[0],
+              fileData = _ref2[1];
+
           if (relativePath.match(/datasets\.json$/i)) {
-            processing++;
-            zipEntry.async('string').then(function (txt) {
-              model.datasets = JSON.parse(txt);
-              processing--;
-
-              if (!processing) {
-                resolve();
-              }
-            }).catch(reject);
+            model.datasets = JSON.parse(strFromU8(fileData));
           }
 
           if (relativePath.match(/array_[a-zA-Z]+_[0-9]+/)) {
-            processing++;
-            zipEntry.async('arraybuffer').then(function (arraybuffer) {
-              processing--;
-
-              var _relativePath$split$s = relativePath.split('_').slice(-2),
-                  _relativePath$split$s2 = _slicedToArray(_relativePath$split$s, 2),
-                  type = _relativePath$split$s2[0],
-                  id = _relativePath$split$s2[1];
-
-              model.arrays[id] = macro.newTypedArray(type, arraybuffer);
+            var _relativePath$split$s = relativePath.split('_').slice(-2),
+                _relativePath$split$s2 = _slicedToArray(_relativePath$split$s, 2),
+                type = _relativePath$split$s2[0],
+                id = _relativePath$split$s2[1];
 
-              if (!processing) {
-                resolve();
-              }
-            });
+            model.arrays[id] = macro.newTypedArray(type, fileData.buffer);
           }
         });
-      }).catch(reject);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
     });
   };
 

package/IO/Core/ZipMultiDataSetWriter.js

@@ -1,4 +1,4 @@
-import JSZip from 'jszip';
+import { zipSync } from 'fflate';
 import macro from '../../macros.js';
 import vtkSerializer from './Serializer.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
@@ -39,31 +39,16 @@ function vtkZipMultiDataSetWriter(publicAPI, model) {
   };
 
   publicAPI.write = function () {
-    publicAPI.update(); // Write to zip
+    publicAPI.update();
+    var zipInfo = Object.create(null); // Write metadata
 
-    if (model.zipFile) {
-      model.zipFile = new JSZip();
-    } // Write metadata
-
-
-    model.zipFile.file('datasets.json', JSON.stringify(model.datasets)); // Write Arrays
+    zipInfo['datasets.json'] = JSON.stringify(model.datasets); // Write Arrays
 
     for (var i = 0; i < model.arrays.length; i++) {
-      model.zipFile.file("array_".concat(vtkDataArray.getDataType(model.arrays[i]), "_").concat(i), model.arrays[i], {
-        binary: true
-      });
+      zipInfo["array_".concat(vtkDataArray.getDataType(model.arrays[i]), "_").concat(i)] = model.arrays[i];
     }
 
-    model.zipFile.generateAsync({
-      type: 'blob',
-      compression: 'DEFLATE',
-      compressionOptions: {
-        level: model.compressionLevel
-      }
-    }).then(function (blob) {
-      model.blob = blob;
-      return blob;
-    });
+    model.blob = new Blob([zipSync(zipInfo)]);
   };
 } // ----------------------------------------------------------------------------
 // Object factory
@@ -71,7 +56,6 @@ function vtkZipMultiDataSetWriter(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
-  zipFile: null,
   compressionLevel: 6,
   blob: null
 }; // ----------------------------------------------------------------------------
@@ -83,7 +67,7 @@ function extend(publicAPI, model) {
   macro.obj(publicAPI, model); // Also make it an algorithm with one input and one output
 
   macro.algo(publicAPI, model, 1, 0);
-  macro.setGet(publicAPI, model, ['zipFile', 'compressionLevel']);
+  macro.setGet(publicAPI, model, ['compressionLevel']);
   macro.get(publicAPI, model, ['blob']); // Object specific methods
 
   vtkZipMultiDataSetWriter(publicAPI, model);

package/IO/Misc/SkyboxReader.js

@@ -1,7 +1,8 @@
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import macro from '../../macros.js';
 import ImageHelper from '../../Common/Core/ImageHelper.js';
 import vtkTexture from '../../Rendering/Core/Texture.js';
-import JSZip from 'jszip';
+import { unzipSync, strFromU8 } from 'fflate';
 
 // vtkSkyboxReader methods
 // ----------------------------------------------------------------------------
@@ -41,101 +42,92 @@ function vtkSkyboxReader(publicAPI, model) {
     model.busy = true;
     publicAPI.invokeBusy(model.busy);
     model.dataMapping = {};
-    var workCount = 0;
-    var canStartProcessing = false;
-    var imageReady = [];
+    var imageReady = []; // Finish data processing
 
     function workDone() {
-      workCount--; // Finish data processing
+      for (var i = 0; i < model.positions.length; i++) {
+        var key = model.positions[i];
+        var images = model.dataMapping[key];
 
-      if (workCount === 0 || canStartProcessing) {
-        for (var i = 0; i < model.positions.length; i++) {
-          var key = model.positions[i];
-          var images = model.dataMapping[key];
-
-          if (!model.textures[key]) {
-            model.textures[key] = vtkTexture.newInstance({
-              interpolate: true
-            });
-          }
+        if (!model.textures[key]) {
+          model.textures[key] = vtkTexture.newInstance({
+            interpolate: true
+          });
+        }
 
-          if (images) {
-            var texture = model.textures[key];
+        if (images) {
+          var texture = model.textures[key];
 
-            for (var idx = 0; idx < 6; idx++) {
-              var _model$faceMapping$id = model.faceMapping[idx],
-                  fileName = _model$faceMapping$id.fileName,
-                  transform = _model$faceMapping$id.transform;
-              var readyIndex = imageReady.indexOf("".concat(key, "/").concat(fileName));
+          for (var idx = 0; idx < 6; idx++) {
+            var _model$faceMapping$id = model.faceMapping[idx],
+                fileName = _model$faceMapping$id.fileName,
+                transform = _model$faceMapping$id.transform;
+            var readyIndex = imageReady.indexOf("".concat(key, "/").concat(fileName));
 
-              if (readyIndex !== -1) {
-                texture.setInputData(ImageHelper.imageToImageData(images[fileName], transform), idx); // Free image
+            if (readyIndex !== -1) {
+              texture.setInputData(ImageHelper.imageToImageData(images[fileName], transform), idx); // Free image
 
-                URL.revokeObjectURL(images[fileName].src);
-                delete images[fileName]; // Don't process again
+              URL.revokeObjectURL(images[fileName].src);
+              delete images[fileName]; // Don't process again
 
-                imageReady.splice(readyIndex, 1);
-              }
+              imageReady.splice(readyIndex, 1);
             }
           }
         }
-
-        if (workCount === 0) {
-          model.busy = false;
-          publicAPI.modified();
-          publicAPI.invokeBusy(model.busy);
-        }
       }
-    }
 
-    var zip = new JSZip();
-    zip.loadAsync(content).then(function () {
-      // Find root index.json
-      zip.forEach(function (relativePath, zipEntry) {
-        if (relativePath.match(/index.json$/)) {
-          workCount++;
-          zipEntry.async('text').then(function (txt) {
-            var config = JSON.parse(txt);
-
-            if (config.skybox && config.skybox.faceMapping) {
-              model.faceMapping = config.skybox.faceMapping;
-            }
+      model.busy = false;
+      publicAPI.modified();
+      publicAPI.invokeBusy(model.busy);
+    }
 
-            if (config.metadata && config.metadata.skybox && config.metadata.skybox.faceMapping) {
-              model.faceMapping = config.metadata.skybox.faceMapping;
-            }
+    var decompressedFiles = unzipSync(new Uint8Array(content));
+    var pending = []; // Find root index.json
 
-            canStartProcessing = true;
-            workDone();
-          });
-        }
+    Object.entries(decompressedFiles).forEach(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+          relativePath = _ref2[0],
+          fileData = _ref2[1];
 
-        if (relativePath.match(/\.jpg$/)) {
-          workCount++;
-          var pathTokens = relativePath.split('/');
-          var fileName = pathTokens.pop();
-          var key = pathTokens.pop();
+      if (relativePath.match(/index.json$/)) {
+        var txt = strFromU8(fileData);
+        var config = JSON.parse(txt);
 
-          if (!model.dataMapping[key]) {
-            model.dataMapping[key] = {};
-          }
+        if (config.skybox && config.skybox.faceMapping) {
+          model.faceMapping = config.skybox.faceMapping;
+        }
 
-          zipEntry.async('blob').then(function (blob) {
-            var img = new Image();
-            var readyKey = "".concat(key, "/").concat(fileName);
-            model.dataMapping[key][fileName] = img;
+        if (config.metadata && config.metadata.skybox && config.metadata.skybox.faceMapping) {
+          model.faceMapping = config.metadata.skybox.faceMapping;
+        }
+      }
 
-            img.onload = function () {
-              imageReady.push(readyKey);
-              workDone();
-            };
+      if (relativePath.match(/\.jpg$/)) {
+        var pathTokens = relativePath.split('/');
+        var fileName = pathTokens.pop();
+        var key = pathTokens.pop();
 
-            img.src = URL.createObjectURL(blob);
-          });
+        if (!model.dataMapping[key]) {
+          model.dataMapping[key] = {};
         }
-      });
-      model.positions = Object.keys(model.dataMapping);
-      model.position = model.positions[0];
+
+        var blob = new Blob([fileData.buffer]);
+        var img = new Image();
+        var readyKey = "".concat(key, "/").concat(fileName);
+        model.dataMapping[key][fileName] = img;
+        pending.push(new Promise(function (resolve) {
+          img.onload = function () {
+            imageReady.push(readyKey);
+            resolve();
+          };
+        }));
+        img.src = URL.createObjectURL(blob);
+      }
+    });
+    model.positions = Object.keys(model.dataMapping);
+    model.position = model.positions[0];
+    Promise.all(pending).then(function () {
+      workDone();
     });
     return publicAPI.getReadyPromise();
   };

package/IO/XML/XMLReader.js

@@ -1,6 +1,6 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { create } from 'xmlbuilder2';
-import pako from 'pako';
+import { decompressSync } from 'fflate';
 import DataAccessHelper from '../Core/DataAccessHelper.js';
 import Base64 from '../../Common/Core/Base64.js';
 import macro from '../../macros.js';
@@ -112,7 +112,7 @@ function readerHeader(uint8, headerType) {
 
 
 function uncompressBlock(compressedUint8, output) {
-  var uncompressedBlock = pako.inflate(compressedUint8);
+  var uncompressedBlock = decompressSync(compressedUint8);
   output.uint8.set(uncompressedBlock, output.offset);
   output.offset += uncompressedBlock.length;
 } // ----------------------------------------------------------------------------

package/IO/XML/XMLWriter.js

@@ -1,5 +1,5 @@
 import { create } from 'xmlbuilder2';
-import pako from 'pako';
+import { zlibSync } from 'fflate';
 import macro from '../../macros.js';
 import { fromArrayBuffer } from '../../Common/Core/Base64.js';
 import { FormatTypes, TYPED_ARRAY } from './XMLWriter/Constants.js';
@@ -8,7 +8,7 @@ import { FormatTypes, TYPED_ARRAY } from './XMLWriter/Constants.js';
 // ----------------------------------------------------------------------------
 
 function compressBlock(uncompressed) {
-  return pako.deflate(uncompressed);
+  return zlibSync(uncompressed);
 }
 
 function processDataArray(dataArray, format, blockSize) {