@kitware/vtk.js 28.10.2 → 28.11.0

package/Common/DataModel/CellTypes.js

@@ -1,10 +1,7 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { CellTypesStrings, CellType } from './CellTypes/Constants.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
@@ -12,153 +9,133 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
  * Given an int (as defined in vtkCellType.h) identifier for a class
  * return it's classname.
  */
-
 function getClassNameFromTypeId(typeId) {
   return typeId < CellTypesStrings.length ? CellTypesStrings[typeId] : 'UnknownClass';
 }
+
 /**
  * Given a data object classname, return it's int identified (as
  * defined in vtkCellType.h)
  */
-
-
 function getTypeIdFromClassName(cellTypeString) {
   return CellTypesStrings.findIndex(cellTypeString);
 }
+
 /**
  * This convenience method is a fast check to determine if a cell type
  * represents a linear or nonlinear cell.  This is generally much more
  * efficient than getting the appropriate vtkCell and checking its IsLinear
  * method.
  */
-
-
 function isLinear(type) {
   return type < CellType.VTK_QUADRATIC_EDGE || type === CellType.VTK_CONVEX_POINT_SET || type === CellType.VTK_POLYHEDRON;
 }
-
 function hasSubCells(cellType) {
   return cellType === CellType.VTK_TRIANGLE_STRIP || cellType === CellType.VTK_POLY_LINE || cellType === CellType.VTK_POLY_VERTEX;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
 
+const STATIC = {
+  getClassNameFromTypeId,
+  getTypeIdFromClassName,
+  isLinear,
+  hasSubCells
+};
 
-var STATIC = {
-  getClassNameFromTypeId: getClassNameFromTypeId,
-  getTypeIdFromClassName: getTypeIdFromClassName,
-  isLinear: isLinear,
-  hasSubCells: hasSubCells
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkCellTypes methods
 // ----------------------------------------------------------------------------
 
 function vtkCellTypes(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCellTypes');
+
   /**
    * Allocate memory for this array. Delete old storage only if necessary.
    */
-
   publicAPI.allocate = function () {
-    var sz = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 512;
-    var ext = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
+    let sz = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 512;
+    let ext = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
     model.size = sz > 0 ? sz : 1;
     model.extend = ext > 0 ? ext : 1;
     model.maxId = -1;
     model.typeArray = new Uint8Array(sz);
     model.locationArray = new Uint32Array(sz);
   };
+
   /**
    * Add a cell at specified id.
    */
-
-
-  publicAPI.insertCell = function (cellId, type, loc) {
+  publicAPI.insertCell = (cellId, type, loc) => {
     model.typeArray[cellId] = type;
     model.locationArray[cellId] = loc;
-
     if (cellId > model.maxId) {
       model.maxId = cellId;
     }
   };
+
   /**
    * Add a cell to the object in the next available slot.
    */
-
-
-  publicAPI.insertNextCell = function (type, loc) {
+  publicAPI.insertNextCell = (type, loc) => {
     publicAPI.insertCell(++model.maxId, type, loc);
     return model.maxId;
   };
+
   /**
    * Specify a group of cell types. This version is provided to maintain
    * backwards compatibility and does a copy of the cellLocations
    */
-
-
-  publicAPI.setCellTypes = function (ncells, cellTypes, cellLocations) {
+  publicAPI.setCellTypes = (ncells, cellTypes, cellLocations) => {
     model.size = ncells;
     model.typeArray = cellTypes;
     model.locationArray = cellLocations;
     model.maxId = ncells - 1;
   };
+
   /**
    * Return the location of the cell in the associated vtkCellArray.
    */
+  publicAPI.getCellLocation = cellId => model.locationArray[cellId];
 
-
-  publicAPI.getCellLocation = function (cellId) {
-    return model.locationArray[cellId];
-  };
   /**
    * Delete cell by setting to nullptr cell type.
    */
-
-
-  publicAPI.deleteCell = function (cellId) {
+  publicAPI.deleteCell = cellId => {
     model.typeArray[cellId] = CellType.VTK_EMPTY_CELL;
   };
+
   /**
    * Return the number of types in the list.
    */
+  publicAPI.getNumberOfTypes = () => model.maxId + 1;
 
-
-  publicAPI.getNumberOfTypes = function () {
-    return model.maxId + 1;
-  };
   /**
    * Return true if type specified is contained in list; false otherwise.
    */
-
-
-  publicAPI.isType = function (type) {
-    var numTypes = publicAPI.getNumberOfTypes();
-
-    for (var i = 0; i < numTypes; ++i) {
+  publicAPI.isType = type => {
+    const numTypes = publicAPI.getNumberOfTypes();
+    for (let i = 0; i < numTypes; ++i) {
       if (type === publicAPI.getCellType(i)) {
         return true;
       }
     }
-
     return false;
   };
+
   /**
    * Add the type specified to the end of the list. Range checking is performed.
    */
+  publicAPI.insertNextType = type => publicAPI.insertNextCell(type, -1);
 
-
-  publicAPI.insertNextType = function (type) {
-    return publicAPI.insertNextCell(type, -1);
-  };
   /**
    * Return the type of cell.
    */
+  publicAPI.getCellType = cellId => model.typeArray[cellId];
 
-
-  publicAPI.getCellType = function (cellId) {
-    return model.typeArray[cellId];
-  };
   /**
    * Reclaim any extra memory.
    */
@@ -167,29 +144,27 @@ function vtkCellTypes(publicAPI, model) {
   /**
    * Initialize object without releasing memory.
    */
-
-
-  publicAPI.reset = function () {
+  publicAPI.reset = () => {
     model.maxId = -1;
   };
+
   /**
    * Standard DeepCopy method.  Since this object contains no reference
    * to other objects, there is no ShallowCopy.
    */
-
-
-  publicAPI.deepCopy = function (src) {
+  publicAPI.deepCopy = src => {
     publicAPI.allocate(src.getSize(), src.getExtend());
     model.typeArray.set(src.getTypeArray());
     model.locationArray.set(src.getLocationArray());
     model.maxId = src.getMaxId();
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   // typeArray: null, // pointer to types array
   // locationArray: null;   // pointer to array of offsets
   size: 0,
@@ -197,23 +172,29 @@ var DEFAULT_VALUES = {
   maxId: -1,
   // maximum index inserted thus far
   extend: 1000 // grow array by this point
+};
 
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 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, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['size', 'maxId', 'extend']);
   macro.getArray(publicAPI, model, ['typeArray', 'locationArray']);
   vtkCellTypes(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkCellTypes'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkCellTypes');
+
+// ----------------------------------------------------------------------------
 
-var vtkCellTypes$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, STATIC);
+var vtkCellTypes$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
 
 export { STATIC, vtkCellTypes$1 as default, extend, newInstance };

package/Common/DataModel/Collection.js

@@ -1,35 +1,33 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkCollection methods
 // ----------------------------------------------------------------------------
 
 function vtkCollection(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCollection');
-
-  publicAPI.addItem = function (item) {
+  publicAPI.addItem = item => {
     model.collection.push(item);
     publicAPI.modified();
   };
-
-  publicAPI.insertItem = function (idx, item) {
+  publicAPI.insertItem = (idx, item) => {
     if (idx < 0 || model.collection.length < idx) {
       vtkErrorMacro('idx out of bounds for insertion.');
     }
-
     model.collection.splice(idx, 0, item);
     publicAPI.modified();
   };
-
-  publicAPI.replaceItem = function (idx, item) {
+  publicAPI.replaceItem = (idx, item) => {
     model.collection.splice(idx, 1, item);
     publicAPI.modified();
   };
-
-  publicAPI.removeItem = function (inValue) {
-    var idx = typeof inValue === 'number' ? inValue : model.collection.indexOf(inValue);
-
+  publicAPI.removeItem = inValue => {
+    const idx = typeof inValue === 'number' ? inValue : model.collection.indexOf(inValue);
     if (idx >= 0 && idx < model.collection.length) {
       model.collection.splice(idx, 1);
       publicAPI.modified();
@@ -37,77 +35,63 @@ function vtkCollection(publicAPI, model) {
       vtkErrorMacro('idx out of bounds for removeItem.');
     }
   };
-
-  publicAPI.removeAllItems = function () {
+  publicAPI.removeAllItems = () => {
     model.collection = [];
     publicAPI.modified();
   };
-
-  publicAPI.isItemPresent = function (item) {
-    return model.collection.includes(item);
-  };
-
-  publicAPI.getNumberOfItems = function () {
-    return model.collection.length;
-  };
-
-  publicAPI.empty = function () {
-    return model.collection.length === 0;
-  };
-
-  publicAPI.getItem = function (idx) {
-    return model.collection[idx];
-  };
-
-  publicAPI.forEach = function (ftor) {
-    model.collection.forEach(ftor); // Call modified() for the collection, since ftor could have modified the elements.
-
+  publicAPI.isItemPresent = item => model.collection.includes(item);
+  publicAPI.getNumberOfItems = () => model.collection.length;
+  publicAPI.empty = () => model.collection.length === 0;
+  publicAPI.getItem = idx => model.collection[idx];
+  publicAPI.forEach = ftor => {
+    model.collection.forEach(ftor);
+    // Call modified() for the collection, since ftor could have modified the elements.
     publicAPI.updateMTimeWithElements();
   };
-
-  publicAPI.reduce = function (ftor, initialValue) {
-    return model.collection.reduce(ftor, initialValue);
-  };
-
-  publicAPI.map = function (ftor) {
-    return model.collection.map(ftor);
-  };
-
-  publicAPI.updateMTimeWithElements = function () {
-    var maxMTimeOfItems = 0; // we expect time values to be positive numbers
-
-    for (var i = 0; i < model.collection.length; ++i) {
-      var elem = model.collection[i];
+  publicAPI.reduce = (ftor, initialValue) => model.collection.reduce(ftor, initialValue);
+  publicAPI.map = ftor => model.collection.map(ftor);
+  publicAPI.updateMTimeWithElements = () => {
+    let maxMTimeOfItems = 0; // we expect time values to be positive numbers
+    for (let i = 0; i < model.collection.length; ++i) {
+      const elem = model.collection[i];
       maxMTimeOfItems = Math.max(maxMTimeOfItems, elem.getMTime());
     }
-
     if (maxMTimeOfItems > publicAPI.getMTime()) {
       publicAPI.modified();
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   collection: []
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
 
-  macro.obj(publicAPI, model); // Object specific methods
+  // Object methods
+  macro.obj(publicAPI, model);
 
+  // Object specific methods
   vtkCollection(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkCollection'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkCollection');
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { index as default, extend, newInstance };

package/Common/DataModel/Cone.js

@@ -1,11 +1,14 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { r as radiansFromDegrees } from '../Core/Math/index.js';
 
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
+
 // ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
+
 // ----------------------------------------------------------------------------
 // vtkCone methods
 // ----------------------------------------------------------------------------
@@ -13,41 +16,46 @@ import { r as radiansFromDegrees } from '../Core/Math/index.js';
 function vtkCone(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCone');
-
-  publicAPI.evaluateFunction = function (x) {
-    var tanTheta = Math.tan(radiansFromDegrees(model.angle));
-    var retVal = x[1] * x[1] + x[2] * x[2] - x[0] * x[0] * tanTheta * tanTheta;
+  publicAPI.evaluateFunction = x => {
+    const tanTheta = Math.tan(radiansFromDegrees(model.angle));
+    const retVal = x[1] * x[1] + x[2] * x[2] - x[0] * x[0] * tanTheta * tanTheta;
     return retVal;
   };
-
-  publicAPI.evaluateGradient = function (x) {
-    var tanTheta = Math.tan(radiansFromDegrees(model.angle));
-    var retVal = [-2.0 * x[0] * tanTheta * tanTheta, 2.0 * x[1], 2.0 * x[2]];
+  publicAPI.evaluateGradient = x => {
+    const tanTheta = Math.tan(radiansFromDegrees(model.angle));
+    const retVal = [-2.0 * x[0] * tanTheta * tanTheta, 2.0 * x[1], 2.0 * x[2]];
     return retVal;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   angle: 15.0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, ['angle']);
   vtkCone(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkCone'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkCone');
+
+// ----------------------------------------------------------------------------
 
 var vtkCone$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkCone$1 as default, extend, newInstance };

package/Common/DataModel/Cylinder.js

@@ -1,75 +1,81 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { d as dot } from '../Core/Math/index.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
 function evaluate(radius, center, axis, x) {
-  var x2C = new Float32Array(3);
+  const x2C = new Float32Array(3);
   x2C[0] = x[0] - center[0];
   x2C[1] = x[1] - center[1];
   x2C[2] = x[2] - center[2];
-  var proj = dot(axis, x2C);
-  var retVal = dot(x2C, x2C) - proj * proj - radius * radius;
+  const proj = dot(axis, x2C);
+  const retVal = dot(x2C, x2C) - proj * proj - radius * radius;
   return retVal;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
 
+const STATIC = {
+  evaluate
+};
 
-var STATIC = {
-  evaluate: evaluate
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkCylinder methods
 // ----------------------------------------------------------------------------
 
 function vtkCylinder(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCylinder');
-
-  publicAPI.evaluateFunction = function (xyz) {
-    var x2C = [xyz[0] - model.center[0], xyz[1] - model.center[1], xyz[2] - model.center[2]];
-    var proj = dot(model.axis, x2C);
-    var retVal = dot(x2C, x2C) - proj * proj - model.radius * model.radius;
+  publicAPI.evaluateFunction = xyz => {
+    const x2C = [xyz[0] - model.center[0], xyz[1] - model.center[1], xyz[2] - model.center[2]];
+    const proj = dot(model.axis, x2C);
+    const retVal = dot(x2C, x2C) - proj * proj - model.radius * model.radius;
     return retVal;
   };
-
-  publicAPI.evaluateGradient = function (xyz) {
-    var t = model.axis[0] * (xyz[0] - model.center[0]) + model.axis[1] * (xyz[1] - model.center[1]) + model.axis[2] * (xyz[2] - model.center[2]);
-    var cp = [model.center[0] + t * model.axis[0], model.center[1] + t * model.axis[1], model.center[2] + t * model.axis[2]];
-    var retVal = [2.0 * (xyz[0] - cp[0]), 2.0 * (xyz[1] - cp[1]), 2.0 * (xyz[2] - cp[2])];
+  publicAPI.evaluateGradient = xyz => {
+    const t = model.axis[0] * (xyz[0] - model.center[0]) + model.axis[1] * (xyz[1] - model.center[1]) + model.axis[2] * (xyz[2] - model.center[2]);
+    const cp = [model.center[0] + t * model.axis[0], model.center[1] + t * model.axis[1], model.center[2] + t * model.axis[2]];
+    const retVal = [2.0 * (xyz[0] - cp[0]), 2.0 * (xyz[1] - cp[1]), 2.0 * (xyz[2] - cp[2])];
     return retVal;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   radius: 0.5,
   center: [0.0, 0.0, 0.0],
   axis: [0.0, 1.0, 0.0]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, ['radius']);
   macro.setGetArray(publicAPI, model, ['center', 'axis'], 3);
   vtkCylinder(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkCylinder'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkCylinder');
+
+// ----------------------------------------------------------------------------
 
-var vtkCylinder$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, STATIC);
+var vtkCylinder$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
 
 export { STATIC, vtkCylinder$1 as default, extend, newInstance };