@kitware/vtk.js 28.10.2 → 28.11.0

package/IO/Core/WSLinkClient.js

@@ -1,42 +1,46 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkImageStream from './ImageStream.js';
 
+// ----------------------------------------------------------------------------
 // Dependency injection
 // ----------------------------------------------------------------------------
 
-var SMART_CONNECT_CLASS = null; // ----------------------------------------------------------------------------
+let SMART_CONNECT_CLASS = null;
+
+// ----------------------------------------------------------------------------
 
 function setSmartConnectClass(klass) {
   SMART_CONNECT_CLASS = klass;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Busy feedback handling
 // ----------------------------------------------------------------------------
 
-
 function busy(fn, update) {
   return function () {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-
-    return new Promise(function (resolve, reject) {
+    return new Promise((resolve, reject) => {
       update(1);
-      fn.apply(void 0, args).then(function (response) {
+      fn(...args).then(response => {
         update(-1);
         resolve(response);
-      }, function (error) {
+      }, error => {
         update(-1);
         reject(error);
       });
     });
   };
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function busyWrap(methodMap, update) {
-  var skipList = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-  var busyContainer = {};
-  Object.keys(methodMap).forEach(function (methodName) {
+  let skipList = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  const busyContainer = {};
+  Object.keys(methodMap).forEach(methodName => {
     if (skipList.indexOf(methodName) === -1) {
       busyContainer[methodName] = busy(methodMap[methodName], update);
     } else {
@@ -44,139 +48,141 @@ function busyWrap(methodMap, update) {
     }
   });
   return busyContainer;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkWSLinkClient
 // ----------------------------------------------------------------------------
 
-
 function vtkWSLinkClient(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkWSLinkClient'); // --------------------------------------------------------------------------
+  model.classHierarchy.push('vtkWSLinkClient');
+
+  // --------------------------------------------------------------------------
   // Internal methods
   // --------------------------------------------------------------------------
 
   function notifyBusy() {
     publicAPI.invokeBusyChange(model.busyCount);
-  } // --------------------------------------------------------------------------
+  }
 
+  // --------------------------------------------------------------------------
 
   function updateBusy() {
-    var delta = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    model.busyCount += delta; // Clear any pending timeout
+    let delta = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    model.busyCount += delta;
 
+    // Clear any pending timeout
     if (model.timeoutId) {
       clearTimeout(model.timeoutId);
       model.timeoutId = 0;
-    } // Delay notification when idle
-
+    }
 
+    // Delay notification when idle
     if (model.busyCount) {
       notifyBusy();
     } else {
       model.timeoutId = setTimeout(notifyBusy, model.notificationTimeout);
     }
-  } // --------------------------------------------------------------------------
+  }
+
+  // --------------------------------------------------------------------------
   // Public methods
   // --------------------------------------------------------------------------
 
+  publicAPI.beginBusy = () => updateBusy(+1);
+  publicAPI.endBusy = () => updateBusy(-1);
+  publicAPI.isBusy = () => !!model.busyCount;
+  publicAPI.isConnected = () => !!model.connection;
 
-  publicAPI.beginBusy = function () {
-    return updateBusy(+1);
-  };
-
-  publicAPI.endBusy = function () {
-    return updateBusy(-1);
-  };
-
-  publicAPI.isBusy = function () {
-    return !!model.busyCount;
-  };
-
-  publicAPI.isConnected = function () {
-    return !!model.connection;
-  }; // --------------------------------------------------------------------------
-
+  // --------------------------------------------------------------------------
 
   publicAPI.connect = function () {
-    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    var configDecorator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-
+    let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let configDecorator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     if (!SMART_CONNECT_CLASS) {
       return Promise.reject(new Error('Need to provide SmartConnect'));
     }
-
     if (model.connection) {
       return Promise.reject(new Error('Need to disconnect first'));
     }
-
     model.config = config;
     model.configDecorator = configDecorator || model.configDecorator;
-    return new Promise(function (resolve, reject) {
+    return new Promise((resolve, reject) => {
       model.smartConnect = SMART_CONNECT_CLASS.newInstance({
-        config: config,
+        config,
         configDecorator: model.configDecorator
-      }); // ready
+      });
 
-      model.smartConnect.onConnectionReady(function (connection) {
+      // ready
+      model.smartConnect.onConnectionReady(connection => {
         model.connection = connection;
         model.remote = {};
         model.config = model.smartConnect.getConfig();
-        var session = connection.getSession(); // Link remote API
+        const session = connection.getSession();
 
+        // Link remote API
         model.protocols = model.protocols || {};
-        Object.keys(model.protocols).forEach(function (name) {
+        Object.keys(model.protocols).forEach(name => {
           model.remote[name] = busyWrap(model.protocols[name](session), updateBusy, model.notBusyList);
-        }); // Handle image stream if needed
+        });
 
+        // Handle image stream if needed
         if (model.createImageStream) {
           model.imageStream = vtkImageStream.newInstance();
           model.imageStream.connect(session);
-        } // Forward ready info as well
-
+        }
 
+        // Forward ready info as well
         publicAPI.invokeConnectionReady(publicAPI);
         resolve(publicAPI);
-      }); // error
+      });
 
-      model.smartConnect.onConnectionError(function (error) {
+      // error
+      model.smartConnect.onConnectionError(error => {
         publicAPI.invokeConnectionError(error);
         reject(error);
-      }); // close
+      });
 
-      model.smartConnect.onConnectionClose(function (close) {
+      // close
+      model.smartConnect.onConnectionClose(close => {
         publicAPI.invokeConnectionClose(close);
         reject(close);
-      }); // Start connection
+      });
 
+      // Start connection
       model.smartConnect.connect();
     });
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
   publicAPI.disconnect = function () {
-    var timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 60;
-
+    let timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 60;
     if (model.connection) {
       model.connection.destroy(timeout);
       model.connection = null;
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.registerProtocol = function (name, protocol) {
+  publicAPI.registerProtocol = (name, protocol) => {
     model.remote[name] = busyWrap(protocol(model.connection.getSession()), updateBusy, model.notBusyList);
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.unregisterProtocol = function (name) {
+  publicAPI.unregisterProtocol = name => {
     delete model.remote[name];
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   // protocols: null,
   // connection: null,
   // config: null,
@@ -185,31 +191,39 @@ var DEFAULT_VALUES = {
   busyCount: 0,
   timeoutId: 0,
   notificationTimeout: 50,
-  createImageStream: true // configDecorator: null,
+  createImageStream: true
+  // configDecorator: null,
+};
 
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Object methods
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['protocols', 'notBusyList', 'createImageStream', 'configDecorator']);
   macro.get(publicAPI, model, ['connection', 'config', 'remote', 'imageStream']);
   macro.event(publicAPI, model, 'BusyChange');
   macro.event(publicAPI, model, 'ConnectionReady');
   macro.event(publicAPI, model, 'ConnectionError');
-  macro.event(publicAPI, model, 'ConnectionClose'); // Object specific methods
+  macro.event(publicAPI, model, 'ConnectionClose');
 
+  // Object specific methods
   vtkWSLinkClient(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkWSLinkClient');
 
-var newInstance = macro.newInstance(extend, 'vtkWSLinkClient'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkWSLinkClient$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  setSmartConnectClass: setSmartConnectClass
+  newInstance,
+  extend,
+  setSmartConnectClass
 };
 
 export { vtkWSLinkClient$1 as default, extend, newInstance };

package/IO/Core/ZipMultiDataSetReader.js

@@ -1,72 +1,64 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import { unzipSync, strFromU8 } from 'fflate';
 import DataAccessHelper from './DataAccessHelper.js';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import './DataAccessHelper/HttpDataAccessHelper.js';
 
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HtmlDataAccessHelper'; // html + base64 + zip
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/JSZipDataAccessHelper'; // zip
+
 // ----------------------------------------------------------------------------
 // vtkAppendPolyData methods
 // ----------------------------------------------------------------------------
 
 function vtkZipMultiDataSetReader(publicAPI, model) {
   // Set our classname
-  model.classHierarchy.push('vtkZipMultiDataSetReader'); // Create default dataAccessHelper if not available
+  model.classHierarchy.push('vtkZipMultiDataSetReader');
 
+  // Create default dataAccessHelper if not available
   if (!model.dataAccessHelper) {
     model.dataAccessHelper = DataAccessHelper.get('http');
-  } // Internal method to fetch Array
-
+  }
 
+  // Internal method to fetch Array
   function fetchData(url) {
-    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    let option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     return model.dataAccessHelper.fetchBinary(url, option);
-  } // Set DataSet url
-
+  }
 
+  // Set DataSet url
   publicAPI.setUrl = function (url) {
-    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    model.url = url; // Remove the file in the URL
+    let option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    model.url = url;
 
-    var path = url.split('/');
+    // Remove the file in the URL
+    const path = url.split('/');
     path.pop();
-    model.baseURL = path.join('/'); // Fetch metadata
+    model.baseURL = path.join('/');
 
+    // Fetch metadata
     return publicAPI.loadData(option);
-  }; // Fetch the actual data arrays
-
+  };
 
+  // Fetch the actual data arrays
   publicAPI.loadData = function () {
-    var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     return fetchData(model.url, option).then(publicAPI.parseAsArrayBuffer);
   };
-
-  publicAPI.parseAsArrayBuffer = function (arrayBuffer) {
+  publicAPI.parseAsArrayBuffer = arrayBuffer => {
     if (!arrayBuffer) {
       return Promise.reject(new Error('No ArrayBuffer to parse'));
     }
-
-    return new Promise(function (resolve, reject) {
+    return new Promise((resolve, reject) => {
       model.arrays = [];
-      var decompressedFiles = unzipSync(new Uint8Array(arrayBuffer));
-
+      const decompressedFiles = unzipSync(new Uint8Array(arrayBuffer));
       try {
-        Object.entries(decompressedFiles).forEach(function (_ref) {
-          var _ref2 = _slicedToArray(_ref, 2),
-              relativePath = _ref2[0],
-              fileData = _ref2[1];
-
+        Object.entries(decompressedFiles).forEach(_ref => {
+          let [relativePath, fileData] = _ref;
           if (relativePath.match(/datasets\.json$/i)) {
             model.datasets = JSON.parse(strFromU8(fileData));
           }
-
           if (relativePath.match(/array_[a-zA-Z]+_[0-9]+/)) {
-            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];
-
+            const [type, id] = relativePath.split('_').slice(-2);
             model.arrays[id] = macro.newTypedArray(type, fileData.buffer);
           }
         });
@@ -76,34 +68,44 @@ function vtkZipMultiDataSetReader(publicAPI, model) {
       }
     });
   };
-
-  publicAPI.requestData = function (inData, outData) {// perform deserialization
+  publicAPI.requestData = (inData, outData) => {
+    // perform deserialization
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Make this a VTK object
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  macro.obj(publicAPI, model); // Also make it an algorithm with one input and one output
+  // Make this a VTK object
+  macro.obj(publicAPI, model);
 
+  // Also make it an algorithm with one input and one output
   macro.algo(publicAPI, model, 0, 0);
   macro.get(publicAPI, model, ['url', 'baseURL']);
-  macro.setGet(publicAPI, model, ['dataAccessHelper']); // Object specific methods
+  macro.setGet(publicAPI, model, ['dataAccessHelper']);
 
+  // Object specific methods
   vtkZipMultiDataSetReader(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkZipMultiDataSetReader'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkZipMultiDataSetReader');
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { index as default, extend, newInstance };

package/IO/Core/ZipMultiDataSetWriter.js

@@ -1,83 +1,92 @@
 import { zipSync } from 'fflate';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkSerializer from './Serializer.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkAppendPolyData methods
 // ----------------------------------------------------------------------------
 
 function vtkZipMultiDataSetWriter(publicAPI, model) {
   // Set our classname
   model.classHierarchy.push('vtkZipMultiDataSetWriter');
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     // implement requestData
-    var numberOfInputs = publicAPI.getNumberOfInputPorts();
-
+    const numberOfInputs = publicAPI.getNumberOfInputPorts();
     if (!numberOfInputs) {
       vtkErrorMacro('No input specified.');
       return;
-    } // Default array handler
-
+    }
 
-    var arrayHandler = vtkSerializer.vtkArraySerializer.newInstance();
+    // Default array handler
+    const arrayHandler = vtkSerializer.vtkArraySerializer.newInstance();
     model.datasets = [];
-
-    for (var i = 0; i < numberOfInputs; i++) {
-      var ds = inData[i];
-      var serializer = vtkSerializer.getSerializer(ds);
-
+    for (let i = 0; i < numberOfInputs; i++) {
+      const ds = inData[i];
+      const serializer = vtkSerializer.getSerializer(ds);
       if (serializer) {
         model.datasets.push(serializer.serialize(ds, arrayHandler));
       } else {
         console.error('Could not find serializer for', ds.getClassName());
       }
     }
-
     model.arrays = arrayHandler.arrays;
   };
-
-  publicAPI.write = function () {
+  publicAPI.write = () => {
     publicAPI.update();
-    var zipInfo = Object.create(null); // Write metadata
+    const zipInfo = Object.create(null);
 
-    zipInfo['datasets.json'] = JSON.stringify(model.datasets); // Write Arrays
+    // Write metadata
+    zipInfo['datasets.json'] = JSON.stringify(model.datasets);
 
-    for (var i = 0; i < model.arrays.length; i++) {
-      zipInfo["array_".concat(vtkDataArray.getDataType(model.arrays[i]), "_").concat(i)] = model.arrays[i];
+    // Write Arrays
+    for (let i = 0; i < model.arrays.length; i++) {
+      zipInfo[`array_${vtkDataArray.getDataType(model.arrays[i])}_${i}`] = model.arrays[i];
     }
-
     model.blob = new Blob([zipSync(zipInfo)]);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   compressionLevel: 6,
   blob: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Make this a VTK object
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  macro.obj(publicAPI, model); // Also make it an algorithm with one input and one output
+  // Make this a VTK object
+  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, ['compressionLevel']);
-  macro.get(publicAPI, model, ['blob']); // Object specific methods
+  macro.get(publicAPI, model, ['blob']);
 
+  // Object specific methods
   vtkZipMultiDataSetWriter(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkZipMultiDataSetWriter'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkZipMultiDataSetWriter');
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { index as default, extend, newInstance };

package/IO/Core.js

@@ -11,13 +11,13 @@ import vtkWSLinkClient from './Core/WSLinkClient.js';
 
 // Bundle size management - start
 var Core = {
-  BinaryHelper: BinaryHelper,
-  DataAccessHelper: DataAccessHelper,
-  vtkHttpDataSetReader: vtkHttpDataSetReader,
-  vtkHttpSceneLoader: vtkHttpSceneLoader,
-  vtkImageStream: vtkImageStream,
-  vtkResourceLoader: vtkResourceLoader,
-  vtkWSLinkClient: vtkWSLinkClient
+  BinaryHelper,
+  DataAccessHelper,
+  vtkHttpDataSetReader,
+  vtkHttpSceneLoader,
+  vtkImageStream,
+  vtkResourceLoader,
+  vtkWSLinkClient
 };
 
 export { Core as default };