@kitware/vtk.js 28.10.1 → 28.11.0

package/Common/Core/Math.d.ts

@@ -878,6 +878,19 @@ export function createUninitializedBounds(): Bounds;
  */
 export function getMajorAxisIndex(vector: number[]): number;
 
+/**
+ * Return the closest orthogonal matrix of 1, -1 and 0
+ * It works for both column major and row major matrices
+ * This function iteratively associate a column with a row by choosing
+ * the greatest absolute value from the remaining row and columns
+ * For each association, a -1 or a 1 is set in the output, depending on
+ * the sign of the value in the original matrix
+ * 
+ * @param {Number[]} matrix The matrix of size nxn
+ * @param {Number[]} n The size of the square matrix, defaults to 3
+ */
+export function getSparseOrthogonalMatrix(matrix: number[], n: number): number[];
+
 /**
  *
  * @param {Number} value The value to convert.
@@ -1028,6 +1041,7 @@ export declare const vtkMath: {
 	isInf: typeof isInf;
 	createUninitializedBounds: typeof createUninitializedBounds;
 	getMajorAxisIndex: typeof getMajorAxisIndex;
+	getSparseOrthogonalMatrix: typeof getSparseOrthogonalMatrix;
 	floatToHex2: typeof floatToHex2;
 	floatRGB2HexCode: typeof floatRGB2HexCode;
 	float2CssRGBA: typeof float2CssRGBA;

package/Common/Core/Math.js

@@ -1,6 +1,4 @@
-import '@babel/runtime/helpers/slicedToArray';
-import '@babel/runtime/helpers/toConsumableArray';
 import 'seedrandom';
-import '../../macros.js';
+import '../../macros2.js';
 import './Math/Constants.js';
-export { aj as LUFactor3x3, ak as LUSolve3x3, U as Pi, k as add, R as angleBetweenVectors, P as areBoundsInitialized, B as areEquals, a as areMatricesEqual, Z as arrayMax, Y as arrayMin, D as arrayRange, a1 as beginCombination, a0 as binomial, aR as boundsIsWithinOtherBounds, V as ceil, _ as ceilLog2, aN as clampAndNormalizeValue, C as clampValue, c as clampVector, ai as columnsToMat3, ah as columnsToMat4, aM as computeBoundsFromPoints, T as createArray, F as createUninitializedBounds, j as cross, f as default, A as degreesFromRadians, o as determinant2x2, y as determinant3x3, az as diagonalize3x3, e as distance2BetweenPoints, d as dot, aa as dot2D, aE as estimateMatrixCondition, aQ as extentIsWithinOtherExtent, $ as factorial, a_ as float2CssRGBA, aZ as floatRGB2HexCode, aY as floatToHex2, K as floor, a5 as gaussian, ac as gaussianAmplitude, ad as gaussianWeight, aP as getAdjustedScalarRange, E as getMajorAxisIndex, aO as getScalarTypeFittingRange, a4 as getSeed, aH as hex2float, h as hsv2rgb, ar as identity, aq as identity3x3, aU as inf, ap as invert3x3, aD as invertMatrix, aW as isFinite, as as isIdentity, at as isIdentity3x3, G as isInf, aX as isNaN, i as isNan, Q as isPowerOfTwo, t as jacobi, p as jacobiN, J as lab2rgb, aI as lab2xyz, al as linearSolve3x3, aB as luFactorLinearSystem, aC as luSolveLinearSystem, aw as matrix3x3ToQuaternion, X as max, W as min, am as multiply3x3_mat3, O as multiply3x3_vect3, m as multiplyAccumulate, a7 as multiplyAccumulate2D, an as multiplyMatrix, ax as multiplyQuaternion, w as multiplyScalar, a6 as multiplyScalar2D, N as nearestPowerOfTwo, aV as negInf, a2 as nextCombination, n as norm, af as norm2D, l as normalize, M as normalize2D, ay as orthogonalize3x3, a8 as outer, ae as outer2D, q as perpendiculars, aS as pointIsWithinBounds, a9 as projectVector, ab as projectVector2D, au as quaternionToMatrix3x3, r as radiansFromDegrees, x as random, a3 as randomSeed, H as rgb2hsv, I as rgb2lab, aL as rgb2xyz, L as round, av as roundNumber, b as roundVector, z as rowsToMat3, ag as rowsToMat4, S as signedAngleBetweenVectors, aA as singularValueDecomposition3x3, aT as solve3PointCircle, aF as solveHomogeneousLeastSquares, aG as solveLeastSquares, g as solveLinearSystem, s as subtract, ao as transpose3x3, u as uninitializeBounds, aJ as xyz2lab, aK as xyz2rgb } from './Math/index.js';
+export { ak as LUFactor3x3, al as LUSolve3x3, V as Pi, k as add, S as angleBetweenVectors, Q as areBoundsInitialized, B as areEquals, a as areMatricesEqual, _ as arrayMax, Z as arrayMin, D as arrayRange, a2 as beginCombination, a1 as binomial, aS as boundsIsWithinOtherBounds, W as ceil, $ as ceilLog2, aO as clampAndNormalizeValue, C as clampValue, c as clampVector, aj as columnsToMat3, ai as columnsToMat4, aN as computeBoundsFromPoints, U as createArray, F as createUninitializedBounds, j as cross, f as default, A as degreesFromRadians, o as determinant2x2, y as determinant3x3, aA as diagonalize3x3, e as distance2BetweenPoints, d as dot, ab as dot2D, aF as estimateMatrixCondition, aR as extentIsWithinOtherExtent, a0 as factorial, a$ as float2CssRGBA, a_ as floatRGB2HexCode, aZ as floatToHex2, G as floor, a6 as gaussian, ad as gaussianAmplitude, ae as gaussianWeight, aQ as getAdjustedScalarRange, E as getMajorAxisIndex, aP as getScalarTypeFittingRange, a5 as getSeed, P as getSparseOrthogonalMatrix, aI as hex2float, h as hsv2rgb, as as identity, ar as identity3x3, aV as inf, aq as invert3x3, aE as invertMatrix, aX as isFinite, at as isIdentity, au as isIdentity3x3, H as isInf, aY as isNaN, i as isNan, R as isPowerOfTwo, t as jacobi, p as jacobiN, K as lab2rgb, aJ as lab2xyz, am as linearSolve3x3, aC as luFactorLinearSystem, aD as luSolveLinearSystem, ax as matrix3x3ToQuaternion, Y as max, X as min, an as multiply3x3_mat3, O as multiply3x3_vect3, m as multiplyAccumulate, a8 as multiplyAccumulate2D, ao as multiplyMatrix, ay as multiplyQuaternion, w as multiplyScalar, a7 as multiplyScalar2D, N as nearestPowerOfTwo, aW as negInf, a3 as nextCombination, n as norm, ag as norm2D, l as normalize, M as normalize2D, az as orthogonalize3x3, a9 as outer, af as outer2D, q as perpendiculars, aT as pointIsWithinBounds, aa as projectVector, ac as projectVector2D, av as quaternionToMatrix3x3, r as radiansFromDegrees, x as random, a4 as randomSeed, I as rgb2hsv, J as rgb2lab, aM as rgb2xyz, L as round, aw as roundNumber, b as roundVector, z as rowsToMat3, ah as rowsToMat4, T as signedAngleBetweenVectors, aB as singularValueDecomposition3x3, aU as solve3PointCircle, aG as solveHomogeneousLeastSquares, aH as solveLeastSquares, g as solveLinearSystem, s as subtract, ap as transpose3x3, u as uninitializeBounds, aK as xyz2lab, aL as xyz2rgb } from './Math/index.js';

package/Common/Core/MatrixBuilder.js

@@ -1,178 +1,126 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
-import _createClass from '@babel/runtime/helpers/createClass';
-import { vec3, mat4, glMatrix } from 'gl-matrix';
+import { mat4, glMatrix, vec3 } from 'gl-matrix';
 import { a as areMatricesEqual } from './Math/index.js';
 import { IDENTITY } from './Math/Constants.js';
 
-var NoOp = function NoOp(v) {
-  return v;
-};
-
-var EPSILON = 1e-6;
-
-var Transform = /*#__PURE__*/function () {
-  function Transform() {
-    var useDegree = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-
-    _classCallCheck(this, Transform);
-
+const NoOp = v => v;
+const EPSILON = 1e-6;
+class Transform {
+  constructor() {
+    let useDegree = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     this.matrix = mat4.identity(new Float64Array(16));
     this.tmp = new Float64Array(3);
     this.angleConv = useDegree ? glMatrix.toRadian : NoOp;
   }
-
-  _createClass(Transform, [{
-    key: "rotateFromDirections",
-    value: function rotateFromDirections(originDirection, targetDirection) {
-      var src = new Float64Array(3);
-      var dst = new Float64Array(3);
-      var transf = new Float64Array(16);
-      vec3.set(src, originDirection[0], originDirection[1], originDirection[2]);
-      vec3.set(dst, targetDirection[0], targetDirection[1], targetDirection[2]);
-      vec3.normalize(src, src);
-      vec3.normalize(dst, dst);
-      var cosAlpha = vec3.dot(src, dst);
-
-      if (cosAlpha >= 1) {
-        return this;
-      }
-
-      vec3.cross(this.tmp, src, dst);
-
-      if (vec3.length(this.tmp) < EPSILON) {
-        // cross product is 0, so pick arbitrary axis perpendicular
-        // to originDirection.
-        vec3.cross(this.tmp, [1, 0, 0], originDirection);
-
-        if (vec3.length(this.tmp) < EPSILON) {
-          vec3.cross(this.tmp, [0, 1, 0], originDirection);
-        }
-      }
-
-      mat4.fromRotation(transf, Math.acos(cosAlpha), this.tmp);
-      mat4.multiply(this.matrix, this.matrix, transf);
-      return this;
-    }
-  }, {
-    key: "rotate",
-    value: function rotate(angle, axis) {
-      vec3.set.apply(vec3, [this.tmp].concat(_toConsumableArray(axis)));
-      vec3.normalize(this.tmp, this.tmp);
-      mat4.rotate(this.matrix, this.matrix, this.angleConv(angle), this.tmp);
-      return this;
-    }
-  }, {
-    key: "rotateX",
-    value: function rotateX(angle) {
-      mat4.rotateX(this.matrix, this.matrix, this.angleConv(angle));
-      return this;
-    }
-  }, {
-    key: "rotateY",
-    value: function rotateY(angle) {
-      mat4.rotateY(this.matrix, this.matrix, this.angleConv(angle));
-      return this;
-    }
-  }, {
-    key: "rotateZ",
-    value: function rotateZ(angle) {
-      mat4.rotateZ(this.matrix, this.matrix, this.angleConv(angle));
-      return this;
-    }
-  }, {
-    key: "translate",
-    value: function translate(x, y, z) {
-      vec3.set(this.tmp, x, y, z);
-      mat4.translate(this.matrix, this.matrix, this.tmp);
-      return this;
-    }
-  }, {
-    key: "scale",
-    value: function scale(sx, sy, sz) {
-      vec3.set(this.tmp, sx, sy, sz);
-      mat4.scale(this.matrix, this.matrix, this.tmp);
-      return this;
-    }
-  }, {
-    key: "multiply",
-    value: function multiply(mat4x4) {
-      mat4.multiply(this.matrix, this.matrix, mat4x4);
-      return this;
-    }
-  }, {
-    key: "multiply3x3",
-    value: function multiply3x3(mat3x3) {
-      mat4.multiply(this.matrix, this.matrix, [mat3x3[0], mat3x3[1], mat3x3[2], 0, mat3x3[3], mat3x3[4], mat3x3[5], 0, mat3x3[6], mat3x3[7], mat3x3[8], 0, 0, 0, 0, 1]);
+  rotateFromDirections(originDirection, targetDirection) {
+    const src = new Float64Array(3);
+    const dst = new Float64Array(3);
+    const transf = new Float64Array(16);
+    vec3.set(src, originDirection[0], originDirection[1], originDirection[2]);
+    vec3.set(dst, targetDirection[0], targetDirection[1], targetDirection[2]);
+    vec3.normalize(src, src);
+    vec3.normalize(dst, dst);
+    const cosAlpha = vec3.dot(src, dst);
+    if (cosAlpha >= 1) {
       return this;
     }
-  }, {
-    key: "invert",
-    value: function invert() {
-      mat4.invert(this.matrix, this.matrix);
-      return this;
-    }
-  }, {
-    key: "identity",
-    value: function identity() {
-      mat4.identity(this.matrix);
-      return this;
-    } //-----------
-
-  }, {
-    key: "apply",
-    value: function apply(typedArray) {
-      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      var nbIterations = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
-
-      if (areMatricesEqual(IDENTITY, this.matrix)) {
-        // Make sure we can chain apply...
-        return this;
+    vec3.cross(this.tmp, src, dst);
+    if (vec3.length(this.tmp) < EPSILON) {
+      // cross product is 0, so pick arbitrary axis perpendicular
+      // to originDirection.
+      vec3.cross(this.tmp, [1, 0, 0], originDirection);
+      if (vec3.length(this.tmp) < EPSILON) {
+        vec3.cross(this.tmp, [0, 1, 0], originDirection);
       }
+    }
+    mat4.fromRotation(transf, Math.acos(cosAlpha), this.tmp);
+    mat4.multiply(this.matrix, this.matrix, transf);
+    return this;
+  }
+  rotate(angle, axis) {
+    vec3.set(this.tmp, ...axis);
+    vec3.normalize(this.tmp, this.tmp);
+    mat4.rotate(this.matrix, this.matrix, this.angleConv(angle), this.tmp);
+    return this;
+  }
+  rotateX(angle) {
+    mat4.rotateX(this.matrix, this.matrix, this.angleConv(angle));
+    return this;
+  }
+  rotateY(angle) {
+    mat4.rotateY(this.matrix, this.matrix, this.angleConv(angle));
+    return this;
+  }
+  rotateZ(angle) {
+    mat4.rotateZ(this.matrix, this.matrix, this.angleConv(angle));
+    return this;
+  }
+  translate(x, y, z) {
+    vec3.set(this.tmp, x, y, z);
+    mat4.translate(this.matrix, this.matrix, this.tmp);
+    return this;
+  }
+  scale(sx, sy, sz) {
+    vec3.set(this.tmp, sx, sy, sz);
+    mat4.scale(this.matrix, this.matrix, this.tmp);
+    return this;
+  }
+  multiply(mat4x4) {
+    mat4.multiply(this.matrix, this.matrix, mat4x4);
+    return this;
+  }
+  multiply3x3(mat3x3) {
+    mat4.multiply(this.matrix, this.matrix, [mat3x3[0], mat3x3[1], mat3x3[2], 0, mat3x3[3], mat3x3[4], mat3x3[5], 0, mat3x3[6], mat3x3[7], mat3x3[8], 0, 0, 0, 0, 1]);
+    return this;
+  }
+  invert() {
+    mat4.invert(this.matrix, this.matrix);
+    return this;
+  }
+  identity() {
+    mat4.identity(this.matrix);
+    return this;
+  }
 
-      var size = nbIterations === -1 ? typedArray.length : offset + nbIterations * 3;
-
-      for (var i = offset; i < size; i += 3) {
-        vec3.set(this.tmp, typedArray[i], typedArray[i + 1], typedArray[i + 2]);
-        vec3.transformMat4(this.tmp, this.tmp, this.matrix);
-        typedArray[i] = this.tmp[0];
-        typedArray[i + 1] = this.tmp[1];
-        typedArray[i + 2] = this.tmp[2];
-      } // Make sure we can chain apply...
-
+  //-----------
 
+  apply(typedArray) {
+    let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    let nbIterations = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+    if (areMatricesEqual(IDENTITY, this.matrix)) {
+      // Make sure we can chain apply...
       return this;
     }
-  }, {
-    key: "getMatrix",
-    value: function getMatrix() {
-      return this.matrix;
+    const size = nbIterations === -1 ? typedArray.length : offset + nbIterations * 3;
+    for (let i = offset; i < size; i += 3) {
+      vec3.set(this.tmp, typedArray[i], typedArray[i + 1], typedArray[i + 2]);
+      vec3.transformMat4(this.tmp, this.tmp, this.matrix);
+      typedArray[i] = this.tmp[0];
+      typedArray[i + 1] = this.tmp[1];
+      typedArray[i + 2] = this.tmp[2];
     }
-  }, {
-    key: "setMatrix",
-    value: function setMatrix(mat4x4) {
-      if (!!mat4x4 && mat4x4.length === 16) {
-        mat4.copy(this.matrix, mat4x4);
-      }
 
-      return this;
+    // Make sure we can chain apply...
+    return this;
+  }
+  getMatrix() {
+    return this.matrix;
+  }
+  setMatrix(mat4x4) {
+    if (!!mat4x4 && mat4x4.length === 16) {
+      mat4.copy(this.matrix, mat4x4);
     }
-  }]);
-
-  return Transform;
-}();
-
+    return this;
+  }
+}
 function buildFromDegree() {
   return new Transform(true);
 }
-
 function buildFromRadian() {
   return new Transform(false);
 }
-
 var vtkMatrixBuilder = {
-  buildFromDegree: buildFromDegree,
-  buildFromRadian: buildFromRadian
+  buildFromDegree,
+  buildFromRadian
 };
 
 export { vtkMatrixBuilder as default };

package/Common/Core/Points.js

@@ -1,21 +1,24 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from './DataArray.js';
 import { VtkDataTypes } from './DataArray/Constants.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro;
-var INVALID_BOUNDS = [1, -1, 1, -1, 1, -1]; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+const INVALID_BOUNDS = [1, -1, 1, -1, 1, -1];
+
+// ----------------------------------------------------------------------------
 // vtkPoints methods
 // ----------------------------------------------------------------------------
 
 function vtkPoints(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkPoints'); // Forwarding methods
+  model.classHierarchy.push('vtkPoints');
 
+  // Forwarding methods
   publicAPI.getNumberOfPoints = publicAPI.getNumberOfTuples;
-
   publicAPI.setNumberOfPoints = function (nbPoints) {
-    var dimension = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;
-
+    let dimension = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;
     if (publicAPI.getNumberOfPoints() !== nbPoints) {
       model.size = nbPoints * dimension;
       model.values = macro.newTypedArray(model.dataType, model.size);
@@ -23,82 +26,79 @@ function vtkPoints(publicAPI, model) {
       publicAPI.modified();
     }
   };
-
   publicAPI.setPoint = function (idx) {
     for (var _len = arguments.length, xyz = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
       xyz[_key - 1] = arguments[_key];
     }
-
     publicAPI.setTuple(idx, xyz);
   };
-
   publicAPI.getPoint = publicAPI.getTuple;
-
-  publicAPI.insertNextPoint = function (x, y, z) {
-    return publicAPI.insertNextTuple([x, y, z]);
-  };
-
-  publicAPI.getBounds = function () {
+  publicAPI.insertNextPoint = (x, y, z) => publicAPI.insertNextTuple([x, y, z]);
+  publicAPI.getBounds = () => {
     if (publicAPI.getNumberOfComponents() === 3) {
-      var _xRange = publicAPI.getRange(0);
-
-      model.bounds[0] = _xRange[0];
-      model.bounds[1] = _xRange[1];
-
-      var _yRange = publicAPI.getRange(1);
-
-      model.bounds[2] = _yRange[0];
-      model.bounds[3] = _yRange[1];
-      var zRange = publicAPI.getRange(2);
+      const xRange = publicAPI.getRange(0);
+      model.bounds[0] = xRange[0];
+      model.bounds[1] = xRange[1];
+      const yRange = publicAPI.getRange(1);
+      model.bounds[2] = yRange[0];
+      model.bounds[3] = yRange[1];
+      const zRange = publicAPI.getRange(2);
       model.bounds[4] = zRange[0];
       model.bounds[5] = zRange[1];
       return model.bounds;
     }
-
     if (publicAPI.getNumberOfComponents() !== 2) {
-      vtkErrorMacro("getBounds called on an array with components of\n        ".concat(publicAPI.getNumberOfComponents()));
+      vtkErrorMacro(`getBounds called on an array with components of
+        ${publicAPI.getNumberOfComponents()}`);
       return INVALID_BOUNDS;
     }
-
-    var xRange = publicAPI.getRange(0);
+    const xRange = publicAPI.getRange(0);
     model.bounds[0] = xRange[0];
     model.bounds[1] = xRange[1];
-    var yRange = publicAPI.getRange(1);
+    const yRange = publicAPI.getRange(1);
     model.bounds[2] = yRange[0];
     model.bounds[3] = yRange[1];
     model.bounds[4] = 0;
     model.bounds[5] = 0;
     return model.bounds;
-  }; // Trigger the computation of bounds
-
+  };
 
-  publicAPI.computeBounds = publicAPI.getBounds; // Initialize
+  // Trigger the computation of bounds
+  publicAPI.computeBounds = publicAPI.getBounds;
 
+  // Initialize
   publicAPI.setNumberOfComponents(model.numberOfComponents < 2 ? 3 : model.numberOfComponents);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   empty: true,
   numberOfComponents: 3,
   dataType: VtkDataTypes.FLOAT,
   bounds: [1, -1, 1, -1, 1, -1]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
   vtkDataArray.extend(publicAPI, model, initialValues);
   vtkPoints(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkPoints');
 
-var newInstance = macro.newInstance(extend, 'vtkPoints'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkPoints$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkPoints$1 as default, extend, newInstance };

package/Common/Core/PriorityQueue.js

@@ -1,63 +1,65 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
+// ----------------------------------------------------------------------------
 // vtkPriorityQueue methods
 // ----------------------------------------------------------------------------
 
 function vtkPriorityQueue(publicAPI, model) {
   // Set our classname
   model.classHierarchy.push('vtkPriorityQueue');
-
-  publicAPI.push = function (priority, element) {
+  publicAPI.push = (priority, element) => {
     // naive algo
-    var i = model.elements.findIndex(function (e) {
-      return e.priority > priority;
-    });
+    const i = model.elements.findIndex(e => e.priority > priority);
     model.elements.splice(i, 0, {
-      priority: priority,
-      element: element
+      priority,
+      element
     });
   };
-
-  publicAPI.pop = function () {
+  publicAPI.pop = () => {
     if (model.elements.length > 0) {
       return model.elements.shift().element;
     }
-
     return null;
   };
-
-  publicAPI.deleteById = function (id) {
-    model.elements = model.elements.filter(function (_ref) {
-      var element = _ref.element;
+  publicAPI.deleteById = id => {
+    model.elements = model.elements.filter(_ref => {
+      let {
+        element
+      } = _ref;
       return element.id !== id;
     });
   };
+  publicAPI.length = () => model.elements.length;
+}
 
-  publicAPI.length = function () {
-    return model.elements.length;
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   elements: []
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   vtkPriorityQueue(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkPriorityQueue'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkPriorityQueue');
+
+// ----------------------------------------------------------------------------
 
 var vtkPriorityQueue$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkPriorityQueue$1 as default, extend, newInstance };

package/Common/Core/ProgressHandler.js

@@ -1,75 +1,74 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
+// ----------------------------------------------------------------------------
 // vtkProgressHandler methods
 // ----------------------------------------------------------------------------
 
 function vtkProgressHandler(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkProgressHandler');
-
-  publicAPI.startWork = function () {
+  publicAPI.startWork = () => {
     model.workCount += 1;
-
     if (model.workCount === 1) {
       publicAPI.invokeChange(true);
     }
   };
-
-  publicAPI.stopWork = function () {
+  publicAPI.stopWork = () => {
     model.workCount -= 1;
-
     if (model.workCount === 0) {
       publicAPI.invokeChange(false);
     }
   };
-
-  publicAPI.isWorking = function () {
-    return !!model.workCount;
-  };
-
-  publicAPI.wrapPromise = function (promise) {
+  publicAPI.isWorking = () => !!model.workCount;
+  publicAPI.wrapPromise = promise => {
     publicAPI.startWork();
-    return new Promise(function (resolve, reject) {
+    return new Promise((resolve, reject) => {
       promise.then(function () {
         publicAPI.stopWork();
-        resolve.apply(void 0, arguments);
-      }, function (rejectError) {
+        resolve(...arguments);
+      }, rejectError => {
         publicAPI.stopWork();
         reject(rejectError);
       });
     });
   };
-
-  publicAPI.wrapPromiseFunction = function (fn) {
-    return function () {
-      return publicAPI.wrapPromise(fn.apply(void 0, arguments));
-    };
+  publicAPI.wrapPromiseFunction = fn => function () {
+    return publicAPI.wrapPromise(fn(...arguments));
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   workCount: 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.event(publicAPI, model, 'change');
-  macro.get(publicAPI, model, ['workCount']); // Object specific methods
+  macro.get(publicAPI, model, ['workCount']);
 
+  // Object specific methods
   vtkProgressHandler(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkProgressHandler'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkProgressHandler');
+
+// ----------------------------------------------------------------------------
 
 var vtkProgressHandler$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkProgressHandler$1 as default, extend, newInstance };