@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/Core/ImageSlice.js

@@ -1,181 +1,135 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { mat4 } from 'gl-matrix';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkProp3D from './Prop3D.js';
 import vtkImageProperty from './ImageProperty.js';
 
-var vtkDebugMacro = macro.vtkDebugMacro; // ----------------------------------------------------------------------------
+const {
+  vtkDebugMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkImageSlice methods
 // ----------------------------------------------------------------------------
 
 function vtkImageSlice(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImageSlice');
-
-  publicAPI.getActors = function () {
-    return publicAPI;
-  };
-
-  publicAPI.getImages = function () {
-    return publicAPI;
-  };
-
-  publicAPI.getIsOpaque = function () {
+  publicAPI.getActors = () => publicAPI;
+  publicAPI.getImages = () => publicAPI;
+  publicAPI.getIsOpaque = () => {
     if (model.forceOpaque) {
       return true;
     }
-
     if (model.forceTranslucent) {
       return false;
-    } // make sure we have a property
-
-
+    }
+    // make sure we have a property
     if (!model.property) {
       // force creation of a property
       publicAPI.getProperty();
     }
+    let isOpaque = model.property.getOpacity() >= 1.0;
 
-    var isOpaque = model.property.getOpacity() >= 1.0; // are we using an opaque scalar array, if any?
-
+    // are we using an opaque scalar array, if any?
     isOpaque = isOpaque && (!model.mapper || model.mapper.getIsOpaque());
     return isOpaque;
-  }; // Always render during opaque pass, to keep the behavior
+  };
+
+  // Always render during opaque pass, to keep the behavior
   // predictable and because depth-peeling kills alpha-blending.
   // In the future, the Renderer should render images in layers,
   // i.e. where each image will have a layer number assigned to it,
   // and the Renderer will do the images in their own pass.
-
-
-  publicAPI.hasTranslucentPolygonalGeometry = function () {
-    return false;
-  };
-
+  publicAPI.hasTranslucentPolygonalGeometry = () => false;
   publicAPI.makeProperty = vtkImageProperty.newInstance;
-
-  publicAPI.getProperty = function () {
+  publicAPI.getProperty = () => {
     if (model.property === null) {
       model.property = publicAPI.makeProperty();
     }
-
     return model.property;
   };
-
-  publicAPI.getBounds = function () {
+  publicAPI.getBounds = () => {
     if (model.mapper === null) {
       return model.bounds;
-    } // Check for the special case when the mapper's bounds are unknown
-
-
-    var bds = model.mapper.getBounds();
+    }
 
+    // Check for the special case when the mapper's bounds are unknown
+    const bds = model.mapper.getBounds();
     if (!bds || bds.length !== 6) {
       return bds;
-    } // Check for the special case when the actor is empty.
-
+    }
 
+    // Check for the special case when the actor is empty.
     if (bds[0] > bds[1]) {
       model.mapperBounds = bds.concat(); // copy the mapper's bounds
-
       model.bounds = [1, -1, 1, -1, 1, -1];
       model.boundsMTime.modified();
       return bds;
-    } // Check if we have cached values for these bounds - we cache the
+    }
+
+    // Check if we have cached values for these bounds - we cache the
     // values returned by model.mapper.getBounds() and we store the time
     // of caching. If the values returned this time are different, or
     // the modified time of this class is newer than the cached time,
     // then we need to rebuild.
-
-
-    var zip = function zip(rows) {
-      return rows[0].map(function (_, c) {
-        return rows.map(function (row) {
-          return row[c];
-        });
-      });
-    };
-
-    if (!model.mapperBounds || !zip([bds, model.mapperBounds]).reduce(function (a, b) {
-      return a && b[0] === b[1];
-    }, true) || publicAPI.getMTime() > model.boundsMTime.getMTime()) {
+    const zip = rows => rows[0].map((_, c) => rows.map(row => row[c]));
+    if (!model.mapperBounds || !zip([bds, model.mapperBounds]).reduce((a, b) => a && b[0] === b[1], true) || publicAPI.getMTime() > model.boundsMTime.getMTime()) {
       vtkDebugMacro('Recomputing bounds...');
-      model.mapperBounds = bds.map(function (x) {
-        return x;
-      });
+      model.mapperBounds = bds.map(x => x);
       publicAPI.computeMatrix();
-      var tmp4 = new Float64Array(16);
+      const tmp4 = new Float64Array(16);
       mat4.transpose(tmp4, model.matrix);
       vtkBoundingBox.transformBounds(bds, tmp4, model.bounds);
       model.boundsMTime.modified();
     }
-
     return model.bounds;
   };
-
-  publicAPI.getBoundsForSlice = function (slice, thickness) {
+  publicAPI.getBoundsForSlice = (slice, thickness) => {
     // Check for the special case when the mapper's bounds are unknown
-    var bds = model.mapper.getBoundsForSlice(slice, thickness); // Check for the special case when the actor is empty.
-
+    const bds = model.mapper.getBoundsForSlice(slice, thickness);
+    // Check for the special case when the actor is empty.
     if (!vtkBoundingBox.isValid(bds)) {
       return bds;
     }
-
     publicAPI.computeMatrix();
-    var tmp4 = new Float64Array(16);
+    const tmp4 = new Float64Array(16);
     mat4.transpose(tmp4, model.matrix);
-    var newBounds = vtkBoundingBox.transformBounds(bds, tmp4);
+    const newBounds = vtkBoundingBox.transformBounds(bds, tmp4);
     return newBounds;
-  }; //----------------------------------------------------------------------------
-  // Get the minimum X bound
-
-
-  publicAPI.getMinXBound = function () {
-    return publicAPI.getBounds()[0];
-  }; // Get the maximum X bound
-
-
-  publicAPI.getMaxXBound = function () {
-    return publicAPI.getBounds()[1];
-  }; // Get the minimum Y bound
-
-
-  publicAPI.getMinYBound = function () {
-    return publicAPI.getBounds()[2];
-  }; // Get the maximum Y bound
-
-
-  publicAPI.getMaxYBound = function () {
-    return publicAPI.getBounds()[3];
-  }; // Get the minimum Z bound
+  };
 
+  //----------------------------------------------------------------------------
+  // Get the minimum X bound
+  publicAPI.getMinXBound = () => publicAPI.getBounds()[0];
 
-  publicAPI.getMinZBound = function () {
-    return publicAPI.getBounds()[4];
-  }; // Get the maximum Z bound
+  // Get the maximum X bound
+  publicAPI.getMaxXBound = () => publicAPI.getBounds()[1];
 
+  // Get the minimum Y bound
+  publicAPI.getMinYBound = () => publicAPI.getBounds()[2];
 
-  publicAPI.getMaxZBound = function () {
-    return publicAPI.getBounds()[5];
-  };
+  // Get the maximum Y bound
+  publicAPI.getMaxYBound = () => publicAPI.getBounds()[3];
 
-  publicAPI.getMTime = function () {
-    var mt = model.mtime;
+  // Get the minimum Z bound
+  publicAPI.getMinZBound = () => publicAPI.getBounds()[4];
 
+  // Get the maximum Z bound
+  publicAPI.getMaxZBound = () => publicAPI.getBounds()[5];
+  publicAPI.getMTime = () => {
+    let mt = model.mtime;
     if (model.property !== null) {
-      var time = model.property.getMTime();
+      const time = model.property.getMTime();
       mt = time > mt ? time : mt;
     }
-
     return mt;
   };
-
-  publicAPI.getRedrawMTime = function () {
-    var mt = model.mtime;
-
+  publicAPI.getRedrawMTime = () => {
+    let mt = model.mtime;
     if (model.mapper !== null) {
-      var time = model.mapper.getMTime();
+      let time = model.mapper.getMTime();
       mt = time > mt ? time : mt;
-
       if (model.mapper.getInput() !== null) {
         // FIXME !!! getInputAlgorithm / getInput
         model.mapper.getInputAlgorithm().update();
@@ -183,56 +137,60 @@ function vtkImageSlice(publicAPI, model) {
         mt = time > mt ? time : mt;
       }
     }
-
     if (model.property !== null) {
-      var _time = model.property.getMTime();
-
-      mt = _time > mt ? _time : mt;
-
+      let time = model.property.getMTime();
+      mt = time > mt ? time : mt;
       if (model.property.getRGBTransferFunction() !== null) {
-        _time = model.property.getRGBTransferFunction().getMTime();
-        mt = _time > mt ? _time : mt;
+        time = model.property.getRGBTransferFunction().getMTime();
+        mt = time > mt ? time : mt;
       }
     }
-
     return mt;
   };
+  publicAPI.getSupportsSelection = () => model.mapper ? model.mapper.getSupportsSelection() : false;
+}
 
-  publicAPI.getSupportsSelection = function () {
-    return model.mapper ? model.mapper.getSupportsSelection() : false;
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   mapper: null,
   property: null,
-  bounds: _toConsumableArray(vtkBoundingBox.INIT_BOUNDS)
-}; // ----------------------------------------------------------------------------
+  bounds: [...vtkBoundingBox.INIT_BOUNDS]
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  vtkProp3D.extend(publicAPI, model, initialValues); // vtkTimeStamp
+  // Inheritance
+  vtkProp3D.extend(publicAPI, model, initialValues);
 
+  // vtkTimeStamp
   model.boundsMTime = {};
-  macro.obj(model.boundsMTime); // Build VTK API
+  macro.obj(model.boundsMTime);
 
+  // Build VTK API
   macro.set(publicAPI, model, ['property']);
   macro.setGet(publicAPI, model, ['mapper']);
-  macro.getArray(publicAPI, model, ['bounds'], 6); // Object methods
+  macro.getArray(publicAPI, model, ['bounds'], 6);
 
+  // Object methods
   vtkImageSlice(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkImageSlice'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkImageSlice');
+
+// ----------------------------------------------------------------------------
 
 var vtkImageSlice$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImageSlice$1 as default, extend, newInstance };

package/Rendering/Core/InteractorObserver.js

@@ -1,175 +1,184 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkRenderWindowInteractor from './RenderWindowInteractor.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 {
+  vtkErrorMacro,
+  VOID
+} = 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 vtkErrorMacro = macro.vtkErrorMacro,
-    VOID = macro.VOID; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
+
 //----------------------------------------------------------------------------
 // Description:
 // Transform from world to display coordinates.
-
 function computeWorldToDisplay(renderer, x, y, z) {
-  var view = renderer.getRenderWindow().getViews()[0];
+  const view = renderer.getRenderWindow().getViews()[0];
   return view.worldToDisplay(x, y, z, renderer);
-} //----------------------------------------------------------------------------
+}
+
+//----------------------------------------------------------------------------
 // Description:
 // Transform from display to world coordinates.
-
-
 function computeDisplayToWorld(renderer, x, y, z) {
-  var view = renderer.getRenderWindow().getViews()[0];
+  const view = renderer.getRenderWindow().getViews()[0];
   return view.displayToWorld(x, y, z, renderer);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
+const STATIC = {
+  computeWorldToDisplay,
+  computeDisplayToWorld
+};
 
-
-var STATIC = {
-  computeWorldToDisplay: computeWorldToDisplay,
-  computeDisplayToWorld: computeDisplayToWorld
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkInteractorObserver methods
 // ----------------------------------------------------------------------------
 
 function vtkInteractorObserver(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkInteractorObserver');
+  const superClass = {
+    ...publicAPI
+  };
 
-  var superClass = _objectSpread({}, publicAPI); //----------------------------------------------------------------------------
-
-
+  //----------------------------------------------------------------------------
   function unsubscribeFromEvents() {
     while (model.subscribedEvents.length) {
       model.subscribedEvents.pop().unsubscribe();
     }
-  } //----------------------------------------------------------------------------
-  // Check what events we can handle and register callbacks
-
+  }
 
+  //----------------------------------------------------------------------------
+  // Check what events we can handle and register callbacks
   function subscribeToEvents() {
-    vtkRenderWindowInteractor.handledEvents.forEach(function (eventName) {
-      if (publicAPI["handle".concat(eventName)]) {
-        model.subscribedEvents.push(model._interactor["on".concat(eventName)](function (callData) {
+    vtkRenderWindowInteractor.handledEvents.forEach(eventName => {
+      if (publicAPI[`handle${eventName}`]) {
+        model.subscribedEvents.push(model._interactor[`on${eventName}`](callData => {
           if (model.processEvents) {
-            return publicAPI["handle".concat(eventName)](callData);
+            return publicAPI[`handle${eventName}`](callData);
           }
-
           return VOID;
         }, model.priority));
       }
     });
-  } //----------------------------------------------------------------------------
+  }
+
+  //----------------------------------------------------------------------------
   // Public API methods
   //----------------------------------------------------------------------------
-
-
-  publicAPI.setInteractor = function (i) {
+  publicAPI.setInteractor = i => {
     if (i === model._interactor) {
       return;
     }
-
     unsubscribeFromEvents();
     model._interactor = i;
-
     if (i && model.enabled) {
       subscribeToEvents();
     }
-
     publicAPI.modified();
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.setEnabled = function (enable) {
+  //----------------------------------------------------------------------------
+  publicAPI.setEnabled = enable => {
     if (enable === model.enabled) {
       return;
     }
-
     unsubscribeFromEvents();
-
     if (enable) {
       if (model._interactor) {
         subscribeToEvents();
       } else {
-        vtkErrorMacro("\n          The interactor must be set before subscribing to events\n        ");
+        vtkErrorMacro(`
+          The interactor must be set before subscribing to events
+        `);
       }
     }
-
     model.enabled = enable;
     publicAPI.modified();
-  }; //----------------------------------------------------------------------------
+  };
+
+  //----------------------------------------------------------------------------
   // Description:
   // Transform from display to world coordinates.
-
-
-  publicAPI.computeDisplayToWorld = function (renderer, x, y, z) {
+  publicAPI.computeDisplayToWorld = (renderer, x, y, z) => {
     if (!renderer) {
       return null;
     }
-
     return model._interactor.getView().displayToWorld(x, y, z, renderer);
-  }; //----------------------------------------------------------------------------
+  };
+
+  //----------------------------------------------------------------------------
   // Description:
   // Transform from world to display coordinates.
-
-
-  publicAPI.computeWorldToDisplay = function (renderer, x, y, z) {
+  publicAPI.computeWorldToDisplay = (renderer, x, y, z) => {
     if (!renderer) {
       return null;
     }
-
     return model._interactor.getView().worldToDisplay(x, y, z, renderer);
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.setPriority = function (priority) {
-    var modified = superClass.setPriority(priority);
+  //----------------------------------------------------------------------------
 
+  publicAPI.setPriority = priority => {
+    const modified = superClass.setPriority(priority);
     if (modified && model._interactor) {
       unsubscribeFromEvents();
       subscribeToEvents();
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   enabled: true,
   // _interactor: null,
   priority: 0.0,
   processEvents: true,
   subscribedEvents: []
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, 'InteractionEvent');
   macro.event(publicAPI, model, 'StartInteractionEvent');
-  macro.event(publicAPI, model, 'EndInteractionEvent'); // Create get-only macros
+  macro.event(publicAPI, model, 'EndInteractionEvent');
 
-  macro.get(publicAPI, model, ['_interactor', 'enabled']); // Create get-set macros
+  // Create get-only macros
+  macro.get(publicAPI, model, ['_interactor', 'enabled']);
 
+  // Create get-set macros
   macro.setGet(publicAPI, model, ['priority', 'processEvents']);
-  macro.moveToProtected(publicAPI, model, ['interactor']); // For more macro methods, see "Sources/macros.js"
-  // Object specific methods
+  macro.moveToProtected(publicAPI, model, ['interactor']);
+
+  // For more macro methods, see "Sources/macros.js"
 
+  // Object specific methods
   vtkInteractorObserver(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkInteractorObserver'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkInteractorObserver');
+
+// ----------------------------------------------------------------------------
 
-var vtkInteractorObserver$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, STATIC);
+var vtkInteractorObserver$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
 
 export { STATIC, vtkInteractorObserver$1 as default, extend, newInstance };

package/Rendering/Core/InteractorStyle/Constants.js

@@ -1,4 +1,4 @@
-var States = {
+const States = {
   IS_START: 0,
   IS_NONE: 0,
   IS_ROTATE: 1,
@@ -10,7 +10,7 @@ var States = {
   IS_SLICE: 1025
 };
 var vtkInteractorStyleConstants = {
-  States: States
+  States
 };
 
 export { States, vtkInteractorStyleConstants as default };