@kitware/vtk.js 28.10.2 → 28.11.1

package/Common/DataModel/DataSet/Constants.js

@@ -1,35 +1,41 @@
 // Specify how data arrays can be used by data objects
-var FieldDataTypes = {
+const FieldDataTypes = {
   UNIFORM: 0,
   // data that does not vary over points/cells/etc.
   DATA_OBJECT_FIELD: 0,
   // to match VTK
+
   COORDINATE: 1,
   // data that specifies the location of each point
   POINT_DATA: 1,
   // to match VTK
+
   POINT: 2,
   // data defined at each point, but that does not specify the point location
   POINT_FIELD_DATA: 2,
   // to match VTK
+
   CELL: 3,
   // data defined at each cell, but that does not specify the cell
   CELL_FIELD_DATA: 3,
   // to match VTK
+
   VERTEX: 4,
   // data defined at each graph vertex, but that does not specify the graph vertex
   VERTEX_FIELD_DATA: 4,
   // to match VTK
+
   EDGE: 5,
   // data defined at each graph edge, but that does not specify the graph edge
   EDGE_FIELD_DATA: 5,
   // to match VTK
+
   ROW: 6,
   // data specifying a table row
   ROW_DATA: 6 // to match VTK
-
 };
-var FieldAssociations = {
+
+const FieldAssociations = {
   FIELD_ASSOCIATION_POINTS: 0,
   FIELD_ASSOCIATION_CELLS: 1,
   FIELD_ASSOCIATION_NONE: 2,
@@ -40,8 +46,8 @@ var FieldAssociations = {
   NUMBER_OF_ASSOCIATIONS: 7
 };
 var Constants = {
-  FieldDataTypes: FieldDataTypes,
-  FieldAssociations: FieldAssociations
+  FieldDataTypes,
+  FieldAssociations
 };
 
 export { FieldAssociations, FieldDataTypes, Constants as default };

package/Common/DataModel/DataSet.js

@@ -1,12 +1,9 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtk from '../../vtk.js';
 import vtkDataSetAttributes from './DataSetAttributes.js';
 import Constants from './DataSet/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; }
+// import vtkBoundingBox from '../BoundingBox';
 // import * as vtkMath from '../../Core/Math';
 //
 // function getBounds(dataset) {
@@ -21,6 +18,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 //     if (ds.Points && ds.Points.bounds) {
 //       return ds.Points.bounds;
 //     }
+
 //     if (ds.Points && ds.Points.values) {
 //       const array = ds.Points.values;
 //       const bbox = [...vtkBoundingBox.INIT_BOUNDS];
@@ -35,60 +33,74 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 //   }
 //   return vtkMath.createUninitializedBounds();
 // }
+
 // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
-var DATASET_FIELDS = ['pointData', 'cellData', 'fieldData']; // ----------------------------------------------------------------------------
+const DATASET_FIELDS = ['pointData', 'cellData', 'fieldData'];
+
+// ----------------------------------------------------------------------------
 // vtkDataSet methods
 // ----------------------------------------------------------------------------
 
 function vtkDataSet(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkDataSet'); // Add dataset attributes
+  model.classHierarchy.push('vtkDataSet');
 
-  DATASET_FIELDS.forEach(function (fieldName) {
+  // Add dataset attributes
+  DATASET_FIELDS.forEach(fieldName => {
     if (!model[fieldName]) {
       model[fieldName] = vtkDataSetAttributes.newInstance();
     } else {
       model[fieldName] = vtk(model[fieldName]);
     }
   });
-  var superShallowCopy = publicAPI.shallowCopy;
-
+  const superShallowCopy = publicAPI.shallowCopy;
   publicAPI.shallowCopy = function (other) {
-    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    let debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     superShallowCopy(other, debug);
-    DATASET_FIELDS.forEach(function (fieldName) {
+    DATASET_FIELDS.forEach(fieldName => {
       model[fieldName] = vtkDataSetAttributes.newInstance();
       model[fieldName].shallowCopy(other.getReferenceByName(fieldName));
     });
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {// pointData: null,
+const DEFAULT_VALUES = {
+  // pointData: null,
   // cellData: null,
   // fieldData: 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, DATASET_FIELDS); // Object specific methods
+  macro.setGet(publicAPI, model, DATASET_FIELDS);
 
+  // Object specific methods
   vtkDataSet(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkDataSet'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkDataSet');
+
+// ----------------------------------------------------------------------------
 
-var vtkDataSet$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, Constants);
+var vtkDataSet$1 = {
+  newInstance,
+  extend,
+  ...Constants
+};
 
 export { vtkDataSet$1 as default, extend, newInstance };

package/Common/DataModel/DataSetAttributes/Constants.js

@@ -1,4 +1,4 @@
-var AttributeTypes = {
+const AttributeTypes = {
   SCALARS: 0,
   VECTORS: 1,
   NORMALS: 2,
@@ -9,12 +9,12 @@ var AttributeTypes = {
   EDGEFLAG: 7,
   NUM_ATTRIBUTES: 8
 };
-var AttributeLimitTypes = {
+const AttributeLimitTypes = {
   MAX: 0,
   EXACT: 1,
   NOLIMIT: 2
 };
-var CellGhostTypes = {
+const CellGhostTypes = {
   DUPLICATECELL: 1,
   // the cell is present on multiple processors
   HIGHCONNECTIVITYCELL: 2,
@@ -26,38 +26,38 @@ var CellGhostTypes = {
   EXTERIORCELL: 16,
   // the cell is on the exterior of the data set
   HIDDENCELL: 32 // the cell is needed to maintain connectivity, but the data values should be ignored.
-
 };
-var PointGhostTypes = {
+
+const PointGhostTypes = {
   DUPLICATEPOINT: 1,
   // the cell is present on multiple processors
   HIDDENPOINT: 2 // the point is needed to maintain connectivity, but the data values should be ignored.
-
 };
-var AttributeCopyOperations = {
+
+const AttributeCopyOperations = {
   COPYTUPLE: 0,
   INTERPOLATE: 1,
   PASSDATA: 2,
   ALLCOPY: 3 // all of the above
-
 };
-var ghostArrayName = 'vtkGhostType';
-var DesiredOutputPrecision = {
+
+const ghostArrayName = 'vtkGhostType';
+const DesiredOutputPrecision = {
   DEFAULT: 0,
   // use the point type that does not truncate any data
   SINGLE: 1,
   // use Float32Array
   DOUBLE: 2 // use Float64Array
-
 };
+
 var Constants = {
-  AttributeCopyOperations: AttributeCopyOperations,
-  AttributeLimitTypes: AttributeLimitTypes,
-  AttributeTypes: AttributeTypes,
-  CellGhostTypes: CellGhostTypes,
-  DesiredOutputPrecision: DesiredOutputPrecision,
-  PointGhostTypes: PointGhostTypes,
-  ghostArrayName: ghostArrayName
+  AttributeCopyOperations,
+  AttributeLimitTypes,
+  AttributeTypes,
+  CellGhostTypes,
+  DesiredOutputPrecision,
+  PointGhostTypes,
+  ghostArrayName
 };
 
 export { AttributeCopyOperations, AttributeLimitTypes, AttributeTypes, CellGhostTypes, DesiredOutputPrecision, PointGhostTypes, Constants as default, ghostArrayName };