@kitware/vtk.js 28.10.2 → 28.11.1

package/Common/DataModel/DataSetAttributes.js

@@ -1,227 +1,178 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkFieldData from './DataSetAttributes/FieldData.js';
 import Constants from './DataSetAttributes/Constants.js';
 import vtkDataArray from '../Core/DataArray.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; }
+const {
+  AttributeTypes,
+  AttributeCopyOperations
+} = Constants;
+const {
+  vtkWarningMacro
+} = macro;
 
-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; }
-var AttributeTypes = Constants.AttributeTypes,
-    AttributeCopyOperations = Constants.AttributeCopyOperations;
-var vtkWarningMacro = macro.vtkWarningMacro; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkDataSetAttributes methods
 // ----------------------------------------------------------------------------
 
 function vtkDataSetAttributes(publicAPI, model) {
-  var attrTypes = ['Scalars', 'Vectors', 'Normals', 'TCoords', 'Tensors', 'GlobalIds', 'PedigreeIds'];
-
+  const attrTypes = ['Scalars', 'Vectors', 'Normals', 'TCoords', 'Tensors', 'GlobalIds', 'PedigreeIds'];
   function cleanAttributeType(attType) {
     // Given an integer or string, convert the result to one of the
     // strings in the "attrTypes" array above or null (if
     // no match is found)
-    var cleanAttType = attrTypes.find(function (ee) {
-      return AttributeTypes[ee.toUpperCase()] === attType || typeof attType !== 'number' && ee.toLowerCase() === attType.toLowerCase();
-    });
-
+    let cleanAttType = attrTypes.find(ee => AttributeTypes[ee.toUpperCase()] === attType || typeof attType !== 'number' && ee.toLowerCase() === attType.toLowerCase());
     if (typeof cleanAttType === 'undefined') {
       cleanAttType = null;
     }
-
     return cleanAttType;
-  } // Set our className
-
+  }
 
+  // Set our className
   model.classHierarchy.push('vtkDataSetAttributes');
+  const superClass = {
+    ...publicAPI
+  };
+  publicAPI.checkNumberOfComponents = x => true; // TODO
 
-  var superClass = _objectSpread({}, publicAPI);
-
-  publicAPI.checkNumberOfComponents = function (x) {
-    return true;
-  }; // TODO
-
-
-  publicAPI.setAttribute = function (arr, uncleanAttType) {
-    var attType = cleanAttributeType(uncleanAttType);
-
+  publicAPI.setAttribute = (arr, uncleanAttType) => {
+    const attType = cleanAttributeType(uncleanAttType);
     if (arr && attType.toUpperCase() === 'PEDIGREEIDS' && !arr.isA('vtkDataArray')) {
-      vtkWarningMacro("Cannot set attribute ".concat(attType, ". The attribute must be a vtkDataArray."));
+      vtkWarningMacro(`Cannot set attribute ${attType}. The attribute must be a vtkDataArray.`);
       return -1;
     }
-
     if (arr && !publicAPI.checkNumberOfComponents(arr, attType)) {
-      vtkWarningMacro("Cannot set attribute ".concat(attType, ". Incorrect number of components."));
+      vtkWarningMacro(`Cannot set attribute ${attType}. Incorrect number of components.`);
       return -1;
     }
-
-    var currentAttribute = model["active".concat(attType)];
-
+    let currentAttribute = model[`active${attType}`];
     if (currentAttribute >= 0 && currentAttribute < model.arrays.length) {
       if (model.arrays[currentAttribute] === arr) {
         return currentAttribute;
-      } // FIXME setting an array actually changes its index
-
-
+      }
+      // FIXME setting an array actually changes its index
       publicAPI.removeArrayByIndex(currentAttribute);
     }
-
     if (arr) {
       currentAttribute = publicAPI.addArray(arr);
-      model["active".concat(attType)] = currentAttribute;
+      model[`active${attType}`] = currentAttribute;
     } else {
-      model["active".concat(attType)] = -1;
+      model[`active${attType}`] = -1;
     }
-
     publicAPI.modified();
-    return model["active".concat(attType)];
-  };
-
-  publicAPI.getAttributes = function (arr) {
-    return attrTypes.filter(function (attrType) {
-      return publicAPI["get".concat(attrType)]() === arr;
-    });
-  };
-
-  publicAPI.setActiveAttributeByName = function (arrayName, attType) {
-    return publicAPI.setActiveAttributeByIndex(publicAPI.getArrayWithIndex(arrayName).index, attType);
+    return model[`active${attType}`];
   };
-
-  publicAPI.setActiveAttributeByIndex = function (arrayIdx, uncleanAttType) {
-    var attType = cleanAttributeType(uncleanAttType);
-
+  publicAPI.getAttributes = arr => attrTypes.filter(attrType => publicAPI[`get${attrType}`]() === arr);
+  publicAPI.setActiveAttributeByName = (arrayName, attType) => publicAPI.setActiveAttributeByIndex(publicAPI.getArrayWithIndex(arrayName).index, attType);
+  publicAPI.setActiveAttributeByIndex = (arrayIdx, uncleanAttType) => {
+    const attType = cleanAttributeType(uncleanAttType);
     if (arrayIdx >= 0 && arrayIdx < model.arrays.length) {
       if (attType.toUpperCase() !== 'PEDIGREEIDS') {
-        var arr = publicAPI.getArrayByIndex(arrayIdx);
-
+        const arr = publicAPI.getArrayByIndex(arrayIdx);
         if (!arr.isA('vtkDataArray')) {
-          vtkWarningMacro("Cannot set attribute ".concat(attType, ". Only vtkDataArray subclasses can be set as active attributes."));
+          vtkWarningMacro(`Cannot set attribute ${attType}. Only vtkDataArray subclasses can be set as active attributes.`);
           return -1;
         }
-
         if (!publicAPI.checkNumberOfComponents(arr, attType)) {
-          vtkWarningMacro("Cannot set attribute ".concat(attType, ". Incorrect number of components."));
+          vtkWarningMacro(`Cannot set attribute ${attType}. Incorrect number of components.`);
           return -1;
         }
       }
-
-      model["active".concat(attType)] = arrayIdx;
+      model[`active${attType}`] = arrayIdx;
       publicAPI.modified();
       return arrayIdx;
     }
-
     if (arrayIdx === -1) {
-      model["active".concat(attType)] = arrayIdx;
+      model[`active${attType}`] = arrayIdx;
       publicAPI.modified();
     }
-
     return -1;
   };
-
-  publicAPI.getActiveAttribute = function (attType) {
+  publicAPI.getActiveAttribute = attType => {
     // Given an integer enum value or a string (with random capitalization),
     // find the matching string in attrTypes.
-    var cleanAttType = cleanAttributeType(attType);
-    return publicAPI["get".concat(cleanAttType)]();
-  }; // Override to allow proper handling of active attributes
-
+    const cleanAttType = cleanAttributeType(attType);
+    return publicAPI[`get${cleanAttType}`]();
+  };
 
-  publicAPI.removeAllArrays = function () {
-    attrTypes.forEach(function (attType) {
-      model["active".concat(attType)] = -1;
+  // Override to allow proper handling of active attributes
+  publicAPI.removeAllArrays = () => {
+    attrTypes.forEach(attType => {
+      model[`active${attType}`] = -1;
     });
     superClass.removeAllArrays();
-  }; // Override to allow proper handling of active attributes
-
+  };
 
-  publicAPI.removeArrayByIndex = function (arrayIdx) {
+  // Override to allow proper handling of active attributes
+  publicAPI.removeArrayByIndex = arrayIdx => {
     if (arrayIdx !== -1) {
-      attrTypes.forEach(function (attType) {
-        if (arrayIdx === model["active".concat(attType)]) {
-          model["active".concat(attType)] = -1;
-        } else if (arrayIdx < model["active".concat(attType)]) {
-          model["active".concat(attType)] -= 1;
+      attrTypes.forEach(attType => {
+        if (arrayIdx === model[`active${attType}`]) {
+          model[`active${attType}`] = -1;
+        } else if (arrayIdx < model[`active${attType}`]) {
+          model[`active${attType}`] -= 1;
         }
       });
     }
-
     return superClass.removeArrayByIndex(arrayIdx);
   };
-
-  attrTypes.forEach(function (value) {
-    var activeVal = "active".concat(value);
-
-    publicAPI["get".concat(value)] = function () {
-      return publicAPI.getArrayByIndex(model[activeVal]);
-    };
-
-    publicAPI["set".concat(value)] = function (da) {
-      return publicAPI.setAttribute(da, value);
-    };
-
-    publicAPI["setActive".concat(value)] = function (arrayName) {
-      return publicAPI.setActiveAttributeByIndex(publicAPI.getArrayWithIndex(arrayName).index, value);
-    };
-
-    publicAPI["copy".concat(value, "Off")] = function () {
-      var attType = value.toUpperCase();
+  attrTypes.forEach(value => {
+    const activeVal = `active${value}`;
+    publicAPI[`get${value}`] = () => publicAPI.getArrayByIndex(model[activeVal]);
+    publicAPI[`set${value}`] = da => publicAPI.setAttribute(da, value);
+    publicAPI[`setActive${value}`] = arrayName => publicAPI.setActiveAttributeByIndex(publicAPI.getArrayWithIndex(arrayName).index, value);
+    publicAPI[`copy${value}Off`] = () => {
+      const attType = value.toUpperCase();
       model.copyAttributeFlags[AttributeCopyOperations.PASSDATA][AttributeTypes[attType]] = false;
     };
-
-    publicAPI["copy".concat(value, "On")] = function () {
-      var attType = value.toUpperCase();
+    publicAPI[`copy${value}On`] = () => {
+      const attType = value.toUpperCase();
       model.copyAttributeFlags[AttributeCopyOperations.PASSDATA][AttributeTypes[attType]] = true;
     };
   });
-
-  publicAPI.initializeAttributeCopyFlags = function () {
+  publicAPI.initializeAttributeCopyFlags = () => {
     // Default to copying all attributes in every circumstance:
     model.copyAttributeFlags = [];
-    Object.keys(AttributeCopyOperations).filter(function (op) {
-      return op !== 'ALLCOPY';
-    }).forEach(function (attCopyOp) {
-      model.copyAttributeFlags[AttributeCopyOperations[attCopyOp]] = Object.keys(AttributeTypes).filter(function (ty) {
-        return ty !== 'NUM_ATTRIBUTES';
-      }).reduce(function (a, b) {
+    Object.keys(AttributeCopyOperations).filter(op => op !== 'ALLCOPY').forEach(attCopyOp => {
+      model.copyAttributeFlags[AttributeCopyOperations[attCopyOp]] = Object.keys(AttributeTypes).filter(ty => ty !== 'NUM_ATTRIBUTES').reduce((a, b) => {
         a[AttributeTypes[b]] = true;
         return a;
       }, []);
-    }); // Override some operations where we don't want to copy:
-
+    });
+    // Override some operations where we don't want to copy:
     model.copyAttributeFlags[AttributeCopyOperations.COPYTUPLE][AttributeTypes.GLOBALIDS] = false;
     model.copyAttributeFlags[AttributeCopyOperations.INTERPOLATE][AttributeTypes.GLOBALIDS] = false;
     model.copyAttributeFlags[AttributeCopyOperations.COPYTUPLE][AttributeTypes.PEDIGREEIDS] = false;
   };
+  publicAPI.initialize = macro.chain(publicAPI.initialize, publicAPI.initializeAttributeCopyFlags);
 
-  publicAPI.initialize = macro.chain(publicAPI.initialize, publicAPI.initializeAttributeCopyFlags); // Process dataArrays if any
-
+  // Process dataArrays if any
   if (model.dataArrays && Object.keys(model.dataArrays).length) {
-    Object.keys(model.dataArrays).forEach(function (name) {
+    Object.keys(model.dataArrays).forEach(name => {
       if (!model.dataArrays[name].ref && model.dataArrays[name].type === 'vtkDataArray') {
         publicAPI.addArray(vtkDataArray.newInstance(model.dataArrays[name]));
       }
     });
   }
-
-  var superShallowCopy = publicAPI.shallowCopy;
-
-  publicAPI.shallowCopy = function (other, debug) {
+  const superShallowCopy = publicAPI.shallowCopy;
+  publicAPI.shallowCopy = (other, debug) => {
     superShallowCopy(other, debug);
-    model.arrays = other.getArrays().map(function (arr) {
-      var arrNew = arr.newClone();
+    model.arrays = other.getArrays().map(arr => {
+      const arrNew = arr.newClone();
       arrNew.shallowCopy(arr, debug);
       return {
         data: arrNew
       };
     });
   };
-
   publicAPI.initializeAttributeCopyFlags();
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   activeScalars: -1,
   activeVectors: -1,
   activeTensors: -1,
@@ -229,28 +180,35 @@ var DEFAULT_VALUES = {
   activeTCoords: -1,
   activeGlobalIds: -1,
   activePedigreeIds: -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
   vtkFieldData.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['activeScalars', 'activeNormals', 'activeTCoords', 'activeVectors', 'activeTensors', 'activeGlobalIds', 'activePedigreeIds']);
-
   if (!model.arrays) {
     model.arrays = {};
-  } // Object specific methods
-
+  }
 
+  // Object specific methods
   vtkDataSetAttributes(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkDataSetAttributes'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkDataSetAttributes');
+
+// ----------------------------------------------------------------------------
 
-var vtkDataSetAttributes$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, Constants);
+var vtkDataSetAttributes$1 = {
+  newInstance,
+  extend,
+  ...Constants
+};
 
 export { vtkDataSetAttributes$1 as default, extend, newInstance };

package/Common/DataModel/EdgeLocator.js

@@ -1,85 +1,60 @@
-import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
-import _createClass from '@babel/runtime/helpers/createClass';
-
-var EdgeLocator = /*#__PURE__*/function () {
-  function EdgeLocator() {
-    var oriented = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-
-    _classCallCheck(this, EdgeLocator);
-
+class EdgeLocator {
+  constructor() {
+    let oriented = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     this.oriented = oriented;
     this.edgeMap = new Map();
   }
-
-  _createClass(EdgeLocator, [{
-    key: "initialize",
-    value: function initialize() {
-      this.edgeMap.clear();
-    }
-  }, {
-    key: "computeEdgeKey",
-    value: function computeEdgeKey(pointId0, pointId1) {
-      return this.oriented || pointId0 < pointId1 ? // Cantor pairing function:
-      0.5 * (pointId0 * pointId1) * (pointId0 * pointId1 + 1) + pointId1 : 0.5 * (pointId1 * pointId0) * (pointId1 * pointId0 + 1) + pointId0;
-    }
-  }, {
-    key: "insertUniqueEdge",
-    value: function insertUniqueEdge(pointId0, pointId1, newEdgeValue) {
-      // Generate a unique key
-      var key = this.computeEdgeKey(pointId0, pointId1);
-      var node = this.edgeMap.get(key);
-
-      if (!node) {
-        // Didn't find key, so add a new edge entry
-        node = {
-          key: key,
-          edgeId: this.edgeMap.size,
-          value: newEdgeValue
-        };
-        this.edgeMap.set(key, node);
-      }
-
-      return node;
-    }
-  }, {
-    key: "insertEdge",
-    value: function insertEdge(pointId0, pointId1, newEdgeValue) {
-      // Generate a unique key
-      var key = this.computeEdgeKey(pointId0, pointId1);
-      var node = {
-        key: key,
+  initialize() {
+    this.edgeMap.clear();
+  }
+  computeEdgeKey(pointId0, pointId1) {
+    return this.oriented || pointId0 < pointId1 ?
+    // Cantor pairing function:
+    0.5 * (pointId0 * pointId1) * (pointId0 * pointId1 + 1) + pointId1 : 0.5 * (pointId1 * pointId0) * (pointId1 * pointId0 + 1) + pointId0;
+  }
+  insertUniqueEdge(pointId0, pointId1, newEdgeValue) {
+    // Generate a unique key
+    const key = this.computeEdgeKey(pointId0, pointId1);
+    let node = this.edgeMap.get(key);
+    if (!node) {
+      // Didn't find key, so add a new edge entry
+      node = {
+        key,
         edgeId: this.edgeMap.size,
         value: newEdgeValue
       };
       this.edgeMap.set(key, node);
-      return node;
     }
-  }, {
-    key: "isInsertedEdge",
-    value: function isInsertedEdge(pointId0, pointId1) {
-      var key = this.computeEdgeKey(pointId0, pointId1);
-      return this.edgeMap.get(key);
-    }
-  }], [{
-    key: "getEdgePointIds",
-    value: function getEdgePointIds(node) {
-      var n = 0.5 * (-1 + Math.sqrt(8 * node.key + 1));
-      var pointId0 = node.key - 0.5 * (n + 1) * n;
-      var pointId1 = n - pointId0;
-      return [pointId0, pointId1];
-    }
-  }]);
-
-  return EdgeLocator;
-}();
-
+    return node;
+  }
+  insertEdge(pointId0, pointId1, newEdgeValue) {
+    // Generate a unique key
+    const key = this.computeEdgeKey(pointId0, pointId1);
+    const node = {
+      key,
+      edgeId: this.edgeMap.size,
+      value: newEdgeValue
+    };
+    this.edgeMap.set(key, node);
+    return node;
+  }
+  isInsertedEdge(pointId0, pointId1) {
+    const key = this.computeEdgeKey(pointId0, pointId1);
+    return this.edgeMap.get(key);
+  }
+  static getEdgePointIds(node) {
+    const n = 0.5 * (-1 + Math.sqrt(8 * node.key + 1));
+    const pointId0 = node.key - 0.5 * (n + 1) * n;
+    const pointId1 = n - pointId0;
+    return [pointId0, pointId1];
+  }
+}
 function newInstance() {
-  var initialValues = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  let initialValues = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   return new EdgeLocator(initialValues.oriented);
 }
-
 var vtkEdgeLocator = {
-  newInstance: newInstance
+  newInstance
 };
 
 export { vtkEdgeLocator as default };