@kitware/vtk.js 28.10.2 → 28.11.0

package/IO/Core/ImageStream.js

@@ -1,144 +1,152 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import createMethods from './ImageStream/DefaultProtocol.js';
 import ViewStream from './ImageStream/ViewStream.js';
 
 function vtkImageStream(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkImageStream'); // --------------------------------------------------------------------------
+  model.classHierarchy.push('vtkImageStream');
+
+  // --------------------------------------------------------------------------
   // Internal private method
   // --------------------------------------------------------------------------
 
   function onImage(data) {
-    var message = data[0];
-
+    const message = data[0];
     if (!message || !message.image) {
       return;
     }
-
-    for (var i = 0; i < model.viewStreams.length; i++) {
+    for (let i = 0; i < model.viewStreams.length; i++) {
       model.viewStreams[i].processMessage(message);
     }
-  } // --------------------------------------------------------------------------
+  }
+
+  // --------------------------------------------------------------------------
   // PublicAPI
   // --------------------------------------------------------------------------
 
-
   publicAPI.setServerAnimationFPS = function () {
-    var maxFPS = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 30;
-    var changeDetected = false;
-
+    let maxFPS = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 30;
+    let changeDetected = false;
     if (model.serverAnimationFPS !== maxFPS) {
       model.serverAnimationFPS = maxFPS;
       changeDetected = true;
     }
-
     if (!model.protocol) {
       return Promise.resolve(true);
     }
-
     if (changeDetected) {
       publicAPI.modified();
     }
-
     return model.protocol.setServerAnimationFPS(maxFPS);
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
   publicAPI.connect = function (session) {
-    var protocol = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : createMethods;
-
+    let protocol = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : createMethods;
     if (model.connected || !session || !protocol) {
       return;
     }
-
     model.protocol = protocol(session);
     model.protocol.subscribeToImageStream(onImage).promise // new API in wslink 1.0.5+
-    .then(function (subscription) {
+    .then(subscription => {
       model.renderTopicSubscription = subscription;
       model.connected = true;
-    }).catch(function (e) {
+    }).catch(e => {
       model.connected = false;
       console.error(e);
     });
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.disconnect = function () {
+  publicAPI.disconnect = () => {
     if (model.protocol && model.connected && model.renderTopicSubscription) {
       model.protocol.unsubscribeToImageStream(model.renderTopicSubscription);
       model.renderTopicSubscription = null;
     }
-
     model.connected = false;
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.registerViewStream = function (view) {
+  publicAPI.registerViewStream = view => {
     model.viewStreams.push(view);
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.unregisterViewStream = function (view) {
-    model.viewStreams = model.viewStreams.filter(function (v) {
-      return v !== view;
-    });
-  }; // --------------------------------------------------------------------------
+  publicAPI.unregisterViewStream = view => {
+    model.viewStreams = model.viewStreams.filter(v => v !== view);
+  };
 
+  // --------------------------------------------------------------------------
 
   publicAPI.createViewStream = function () {
-    var viewId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '-1';
-    var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [400, 400];
-    var setServerAnimationFPS = publicAPI.setServerAnimationFPS,
-        getServerAnimationFPS = publicAPI.getServerAnimationFPS,
-        unregisterViewStream = publicAPI.unregisterViewStream;
-    var viewStream = ViewStream.newInstance({
+    let viewId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '-1';
+    let size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [400, 400];
+    const {
+      setServerAnimationFPS,
+      getServerAnimationFPS,
+      unregisterViewStream
+    } = publicAPI;
+    const viewStream = ViewStream.newInstance({
       protocol: model.protocol,
-      unregisterViewStream: unregisterViewStream,
+      unregisterViewStream,
       sharedAPI: {
-        setServerAnimationFPS: setServerAnimationFPS,
-        getServerAnimationFPS: getServerAnimationFPS
+        setServerAnimationFPS,
+        getServerAnimationFPS
       }
     });
     viewStream.setViewId(viewId);
     viewStream.setSize(size[0], size[1]);
     publicAPI.registerViewStream(viewStream);
     return viewStream;
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.delete = macro.chain(function () {
+  publicAPI.delete = macro.chain(() => {
     while (model.viewStreams.length) {
       model.viewStreams.pop().delete();
     }
-
     publicAPI.disconnect();
   }, publicAPI.delete);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   // protocol: null,
   viewStreams: [],
   serverAnimationFPS: -1
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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.get(publicAPI, model, ['serverAnimationFPS', 'protocol']); // Object specific methods
+  macro.get(publicAPI, model, ['serverAnimationFPS', 'protocol']);
 
+  // Object specific methods
   vtkImageStream(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkImageStream'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkImageStream');
+
+// ----------------------------------------------------------------------------
 
 var vtkImageStream$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImageStream$1 as default, extend, newInstance };

package/IO/Core/ResourceLoader.js

@@ -1,9 +1,9 @@
-var LOADED_URLS = [];
+const LOADED_URLS = [];
 function loadScript(url) {
-  return new Promise(function (resolve, reject) {
+  return new Promise((resolve, reject) => {
     if (LOADED_URLS.indexOf(url) === -1) {
       LOADED_URLS.push(url);
-      var newScriptTag = document.createElement('script');
+      const newScriptTag = document.createElement('script');
       newScriptTag.type = 'text/javascript';
       newScriptTag.src = url;
       newScriptTag.onload = resolve;
@@ -13,13 +13,14 @@ function loadScript(url) {
       resolve(false);
     }
   });
-} // <link href=/css/app.44f7bc81.css rel=preload as=style>
+}
 
+// <link href=/css/app.44f7bc81.css rel=preload as=style>
 function loadCSS(url) {
-  return new Promise(function (resolve, reject) {
+  return new Promise((resolve, reject) => {
     if (LOADED_URLS.indexOf(url) === -1) {
       LOADED_URLS.push(url);
-      var newScriptTag = document.createElement('link');
+      const newScriptTag = document.createElement('link');
       newScriptTag.rel = 'stylesheet';
       newScriptTag.href = url;
       newScriptTag.onload = resolve;
@@ -31,9 +32,9 @@ function loadCSS(url) {
   });
 }
 var vtkResourceLoader = {
-  loadScript: loadScript,
-  loadCSS: loadCSS,
-  LOADED_URLS: LOADED_URLS
+  loadScript,
+  loadCSS,
+  LOADED_URLS
 };
 
 export { vtkResourceLoader as default, loadCSS, loadScript };

package/IO/Core/Serializer/ArraySerializer.js

@@ -1,82 +1,82 @@
-import macro from '../../../macros.js';
+import { m as macro } from '../../../macros2.js';
 import vtkDataArray from '../../../Common/Core/DataArray.js';
 import vtkCellArray from '../../../Common/Core/CellArray.js';
 import vtkPoints from '../../../Common/Core/Points.js';
 
-var FACTORY = {
-  vtkDataArray: vtkDataArray,
-  vtkCellArray: vtkCellArray,
-  vtkPoints: vtkPoints
+const FACTORY = {
+  vtkDataArray,
+  vtkCellArray,
+  vtkPoints
 };
-
 function createDefaultTypedArrayHandler() {
-  var arrays = [];
-
+  const arrays = [];
   function write(array) {
-    var id = arrays.length;
+    const id = arrays.length;
     arrays.push(array);
     return id;
   }
-
   function read(arrayId) {
     return arrays[arrayId];
   }
-
   return {
-    write: write,
-    read: read,
-    arrays: arrays
+    write,
+    read,
+    arrays
   };
 }
-
 function vtkArraySerializer(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkArraySerializer');
-
   if (!model.typedArrayHandler) {
     model.typedArrayHandler = createDefaultTypedArrayHandler();
   }
-
-  publicAPI.serialize = function (obj) {
-    var name = obj.getName();
-    var numberOfTuples = obj.getNumberOfTuples();
-    var vtkClass = obj.getClassName();
-    var rawData = obj.getData();
+  publicAPI.serialize = obj => {
+    const name = obj.getName();
+    const numberOfTuples = obj.getNumberOfTuples();
+    const vtkClass = obj.getClassName();
+    const rawData = obj.getData();
     return {
       id: model.typedArrayHandler.write(rawData),
-      name: name,
-      numberOfTuples: numberOfTuples,
-      vtkClass: vtkClass
+      name,
+      numberOfTuples,
+      vtkClass
     };
   };
-
-  publicAPI.deserialize = function (obj) {
-    var values = model.typedArrayHandler.read(obj.id);
-    var name = obj.name,
-        numberOfTuples = obj.numberOfTuples;
+  publicAPI.deserialize = obj => {
+    const values = model.typedArrayHandler.read(obj.id);
+    const {
+      name,
+      numberOfTuples
+    } = obj;
     return FACTORY[obj.vtkClass].newInstance({
-      name: name,
-      numberOfTuples: numberOfTuples,
-      values: values
+      name,
+      numberOfTuples,
+      values
     });
   };
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, initialValues);
   macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['typedArrayHandler']); // Object specific methods
+  macro.setGet(publicAPI, model, ['typedArrayHandler']);
 
+  // Object specific methods
   vtkArraySerializer(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkArraySerializer');
 
-var newInstance = macro.newInstance(extend, 'vtkArraySerializer'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkArraySerializer$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkArraySerializer$1 as default, extend, newInstance };

package/IO/Core/Serializer/FieldDataSerializer.js

@@ -1,57 +1,47 @@
 import vtkDataSetAttributes from '../../../Common/DataModel/DataSetAttributes.js';
 
-var CLASS_NAME = 'vtkDataSetAttributes';
-var ARRAYS = ['Scalars', 'Vectors', 'Normals', 'TCoords', 'Tensors', 'GlobalIds', 'PedigreeIds'];
-
+const CLASS_NAME = 'vtkDataSetAttributes';
+const ARRAYS = ['Scalars', 'Vectors', 'Normals', 'TCoords', 'Tensors', 'GlobalIds', 'PedigreeIds'];
 function canSerialize(obj) {
   return obj && obj.isA && obj.isA(CLASS_NAME);
 }
-
 function canDeserialize(obj) {
   return obj && obj.vtkClass && obj.vtkClass === CLASS_NAME;
 }
-
 function serialize(obj, arrayHandler) {
-  var output = {
+  const output = {
     vtkClass: CLASS_NAME
   };
-  var indexMapping = [];
-  var arrays = obj.getArrays();
-
-  for (var i = 0; i < arrays.length; i++) {
+  const indexMapping = [];
+  const arrays = obj.getArrays();
+  for (let i = 0; i < arrays.length; i++) {
     indexMapping.push(arrayHandler.serialize(arrays[i]));
   }
-
-  ARRAYS.forEach(function (attrType) {
-    var arrayIdx = obj["getActive".concat(attrType)]();
-
+  ARRAYS.forEach(attrType => {
+    const arrayIdx = obj[`getActive${attrType}`]();
     if (arrayIdx !== -1) {
       output[attrType] = indexMapping[arrayIdx];
     }
-  }); // List all arrays
-
+  });
+  // List all arrays
   output.arrays = indexMapping;
   return output;
 }
-
 function deserialize(obj, arrayHandler) {
-  var ds = vtkDataSetAttributes.newInstance();
-
-  for (var i = 0; i < obj.arrays.length; i++) {
+  const ds = vtkDataSetAttributes.newInstance();
+  for (let i = 0; i < obj.arrays.length; i++) {
     ds.addArray(arrayHandler.deserialize(obj.arrays[i]));
   }
-
-  ARRAYS.forEach(function (attrType) {
-    ds["set".concat(attrType)](arrayHandler.deserialize(obj[attrType]));
+  ARRAYS.forEach(attrType => {
+    ds[`set${attrType}`](arrayHandler.deserialize(obj[attrType]));
   });
   return ds;
 }
-
 var vtkFieldDataSerializer = {
-  canSerialize: canSerialize,
-  serialize: serialize,
-  canDeserialize: canDeserialize,
-  deserialize: deserialize
+  canSerialize,
+  serialize,
+  canDeserialize,
+  deserialize
 };
 
 export { vtkFieldDataSerializer as default };

package/IO/Core/Serializer/ImageDataSerializer.js

@@ -1,50 +1,49 @@
 import vtkImageData from '../../../Common/DataModel/ImageData.js';
 import vtkFieldDataSerializer from './FieldDataSerializer.js';
 
-var CLASS_NAME = 'vtkImageData';
-
+const CLASS_NAME = 'vtkImageData';
 function canSerialize(obj) {
   return obj && obj.isA && obj.isA(CLASS_NAME);
 }
-
 function canDeserialize(obj) {
   return obj && obj.vtkClass && obj.vtkClass === CLASS_NAME;
 }
-
 function serialize(obj, arrayHandler) {
-  var output = Object.assign(obj.get('direction', 'spacing', 'origin', 'extent'), {
+  const output = Object.assign(obj.get('direction', 'spacing', 'origin', 'extent'), {
     vtkClass: CLASS_NAME
-  }); // Handle fields
+  });
 
+  // Handle fields
   output.pointData = vtkFieldDataSerializer.serialize(obj.getPointData(), arrayHandler);
   output.cellData = vtkFieldDataSerializer.serialize(obj.getCellData(), arrayHandler);
   output.fieldData = vtkFieldDataSerializer.serialize(obj.getFieldData(), arrayHandler);
   return output;
 }
-
 function deserialize(obj, arrayHandler) {
-  var direction = obj.direction,
-      spacing = obj.spacing,
-      origin = obj.origin,
-      extent = obj.extent;
-  var ds = vtkImageData.newInstance({
-    direction: direction,
-    spacing: spacing,
-    origin: origin,
-    extent: extent
-  }); // Handle fields
-
+  const {
+    direction,
+    spacing,
+    origin,
+    extent
+  } = obj;
+  const ds = vtkImageData.newInstance({
+    direction,
+    spacing,
+    origin,
+    extent
+  });
+
+  // Handle fields
   ds.setPointData(vtkFieldDataSerializer.deserialize(obj.pointData, arrayHandler));
   ds.setCellData(vtkFieldDataSerializer.deserialize(obj.cellData, arrayHandler));
   ds.setFieldData(vtkFieldDataSerializer.deserialize(obj.fieldData, arrayHandler));
   return ds;
 }
-
 var vtkImageDataSerializer = {
-  canSerialize: canSerialize,
-  serialize: serialize,
-  canDeserialize: canDeserialize,
-  deserialize: deserialize
+  canSerialize,
+  serialize,
+  canDeserialize,
+  deserialize
 };
 
 export { vtkImageDataSerializer as default };

package/IO/Core/Serializer/PolyDataSerializer.js

@@ -1,53 +1,49 @@
-import macro from '../../../macros.js';
+import { m as macro } from '../../../macros2.js';
 import vtkPolyData from '../../../Common/DataModel/PolyData.js';
 import vtkFieldDataSerializer from './FieldDataSerializer.js';
 
-var CLASS_NAME = 'vtkPolyData';
-var ARRAYS = ['points', 'verts', 'lines', 'polys', 'strips'];
-
+const CLASS_NAME = 'vtkPolyData';
+const ARRAYS = ['points', 'verts', 'lines', 'polys', 'strips'];
 function canSerialize(obj) {
   return obj && obj.isA && obj.isA(CLASS_NAME);
 }
-
 function canDeserialize(obj) {
   return obj && obj.vtkClass && obj.vtkClass === CLASS_NAME;
 }
-
 function serialize(obj, arrayHandler) {
-  var output = {
+  const output = {
     vtkClass: CLASS_NAME
   };
-  ARRAYS.forEach(function (arrayName) {
-    var array = obj["get".concat(macro.capitalize(arrayName))]();
-
+  ARRAYS.forEach(arrayName => {
+    const array = obj[`get${macro.capitalize(arrayName)}`]();
     if (array && array.getNumberOfValues() > 0) {
       output[arrayName] = arrayHandler.serialize(array);
     }
-  }); // Handle fields
+  });
 
+  // Handle fields
   output.pointData = vtkFieldDataSerializer.serialize(obj.getPointData(), arrayHandler);
   output.cellData = vtkFieldDataSerializer.serialize(obj.getCellData(), arrayHandler);
   output.fieldData = vtkFieldDataSerializer.serialize(obj.getFieldData(), arrayHandler);
   return output;
 }
-
 function deserialize(obj, arrayHandler) {
-  var ds = vtkPolyData.newInstance();
-  ARRAYS.forEach(function (arrayName) {
-    ds["set".concat(macro.capitalize(arrayName))](arrayHandler.deserialize(obj[arrayName]));
-  }); // Handle fields
+  const ds = vtkPolyData.newInstance();
+  ARRAYS.forEach(arrayName => {
+    ds[`set${macro.capitalize(arrayName)}`](arrayHandler.deserialize(obj[arrayName]));
+  });
 
+  // Handle fields
   ds.setPointData(vtkFieldDataSerializer.deserialize(obj.pointData, arrayHandler));
   ds.setCellData(vtkFieldDataSerializer.deserialize(obj.cellData, arrayHandler));
   ds.setFieldData(vtkFieldDataSerializer.deserialize(obj.fieldData, arrayHandler));
   return ds;
 }
-
 var vtkPolyDataSerializer = {
-  canSerialize: canSerialize,
-  serialize: serialize,
-  canDeserialize: canDeserialize,
-  deserialize: deserialize
+  canSerialize,
+  serialize,
+  canDeserialize,
+  deserialize
 };
 
 export { vtkPolyDataSerializer as default };

package/IO/Core/Serializer.js

@@ -3,24 +3,17 @@ import vtkFieldDataSerializer from './Serializer/FieldDataSerializer.js';
 import vtkImageDataSerializer from './Serializer/ImageDataSerializer.js';
 import vtkPolyDataSerializer from './Serializer/PolyDataSerializer.js';
 
-var LIST = [vtkFieldDataSerializer, vtkImageDataSerializer, vtkPolyDataSerializer];
-
+const LIST = [vtkFieldDataSerializer, vtkImageDataSerializer, vtkPolyDataSerializer];
 function getSerializer(obj) {
-  return LIST.find(function (s) {
-    return s.canSerialize(obj);
-  });
+  return LIST.find(s => s.canSerialize(obj));
 }
-
 function getDeserializer(obj) {
-  return LIST.find(function (s) {
-    return s.canDeserialize(obj);
-  });
+  return LIST.find(s => s.canDeserialize(obj));
 }
-
 var vtkSerializer = {
-  vtkArraySerializer: vtkArraySerializer,
-  getSerializer: getSerializer,
-  getDeserializer: getDeserializer
+  vtkArraySerializer,
+  getSerializer,
+  getDeserializer
 };
 
 export { vtkSerializer as default };