@kitware/vtk.js 28.10.2 → 28.11.1

package/Widgets/Widgets3D/ShapeWidget.js

@@ -1,52 +1,49 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import { BehaviorCategory, ShapeBehavior } from './ShapeWidget/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; }
-
 function vtkShapeWidget(publicAPI, model) {
   model.classHierarchy.push('vtkShapeWidget');
-
-  var superClass = _objectSpread({}, publicAPI);
-
+  const superClass = {
+    ...publicAPI
+  };
   model.methodsToLink = ['scaleInPixels'];
-
-  publicAPI.setManipulator = function (manipulator) {
+  publicAPI.setManipulator = manipulator => {
     superClass.setManipulator(manipulator);
-    model.widgetState.getStatesWithLabel('moveHandle').forEach(function (handle) {
-      return handle.setManipulator(manipulator);
-    });
+    model.widgetState.getStatesWithLabel('moveHandle').forEach(handle => handle.setManipulator(manipulator));
   };
 }
-
 function defaultValues(initialValues) {
-  var _None;
-
-  return _objectSpread({
+  return {
     // manipulator: null,
     modifierBehavior: {
-      None: (_None = {}, _defineProperty(_None, BehaviorCategory.PLACEMENT, ShapeBehavior[BehaviorCategory.PLACEMENT].CLICK_AND_DRAG), _defineProperty(_None, BehaviorCategory.POINTS, ShapeBehavior[BehaviorCategory.POINTS].CORNER_TO_CORNER), _defineProperty(_None, BehaviorCategory.RATIO, ShapeBehavior[BehaviorCategory.RATIO].FREE), _None)
+      None: {
+        [BehaviorCategory.PLACEMENT]: ShapeBehavior[BehaviorCategory.PLACEMENT].CLICK_AND_DRAG,
+        [BehaviorCategory.POINTS]: ShapeBehavior[BehaviorCategory.POINTS].CORNER_TO_CORNER,
+        [BehaviorCategory.RATIO]: ShapeBehavior[BehaviorCategory.RATIO].FREE
+      }
     },
-    resetAfterPointPlacement: false
-  }, initialValues);
-} // ----------------------------------------------------------------------------
+    resetAfterPointPlacement: false,
+    ...initialValues
+  };
+}
 
+// ----------------------------------------------------------------------------
 
 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, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['manipulator', 'modifierBehavior', 'resetAfterPointPlacement']);
   vtkShapeWidget(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkShapeWidget');
+const newInstance = macro.newInstance(extend, 'vtkShapeWidget');
 var vtkShapeWidget$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkShapeWidget$1 as default, extend, newInstance };

package/Widgets/Widgets3D/SphereWidget/behavior.js

@@ -1,97 +1,81 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../../macros.js';
+import { m as macro } from '../../../macros2.js';
 import { vec3 } from 'gl-matrix';
 
 function widgetBehavior(publicAPI, model) {
-  var state = model.widgetState;
-  var moveHandle = state.getMoveHandle();
-  var centerHandle = state.getCenterHandle();
-  var borderHandle = state.getBorderHandle();
-  var shapeHandle = state.getSphereHandle(); // Set while moving the center or border handle.
-
-  model._isDragging = false; // The last world coordinate of the mouse cursor during dragging.
-
+  const state = model.widgetState;
+  const moveHandle = state.getMoveHandle();
+  const centerHandle = state.getCenterHandle();
+  const borderHandle = state.getBorderHandle();
+  const shapeHandle = state.getSphereHandle();
+
+  // Set while moving the center or border handle.
+  model._isDragging = false;
+  // The last world coordinate of the mouse cursor during dragging.
   model.previousPosition = null;
   model.classHierarchy.push('vtkSphereWidgetProp');
   moveHandle.setVisible(true);
   centerHandle.setVisible(false);
   borderHandle.setVisible(false);
   shapeHandle.setVisible(true);
-
   function isValidHandle(handle) {
     return handle === centerHandle || handle === borderHandle || handle === moveHandle;
   }
-
   function isPlaced() {
     return !!centerHandle.getOrigin() && !!borderHandle.getOrigin();
-  } // Update the sphereHandle parameters from {center,border}Handle.
-
+  }
 
+  // Update the sphereHandle parameters from {center,border}Handle.
   function updateSphere() {
-    var center = centerHandle.getOrigin();
+    const center = centerHandle.getOrigin();
     if (!center) return;
     centerHandle.setVisible(true);
-    var border = borderHandle.getOrigin();
-
+    let border = borderHandle.getOrigin();
     if (border) {
       borderHandle.setVisible(true);
     } else {
       border = moveHandle.getOrigin();
       if (!border) return;
     }
-
     if (isPlaced()) {
       moveHandle.setVisible(false);
     }
-
-    var radius = vec3.distance(center, border);
+    const radius = vec3.distance(center, border);
     shapeHandle.setVisible(true);
     shapeHandle.setOrigin(center);
     shapeHandle.setScale1(radius * 2);
-
     model._interactor.render();
   }
-
   function currentWorldCoords(e) {
-    var _model$activeState$ge, _model$activeState, _model$activeState$ge2;
-
-    var manipulator = (_model$activeState$ge = (_model$activeState = model.activeState) === null || _model$activeState === void 0 ? void 0 : (_model$activeState$ge2 = _model$activeState.getManipulator) === null || _model$activeState$ge2 === void 0 ? void 0 : _model$activeState$ge2.call(_model$activeState)) !== null && _model$activeState$ge !== void 0 ? _model$activeState$ge : model.manipulator;
+    const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
     return manipulator.handleEvent(e, model._apiSpecificRenderWindow).worldCoords;
-  } // Update the sphere's center and radius.  Example:
-  // handle.setCenterAndRadius([1,2,3], 10);
-
-
-  publicAPI.setCenterAndRadius = function (newCenter, newRadius) {
-    var oldCenter = centerHandle.getOrigin();
-    var oldBorder = borderHandle.getOrigin();
-    var newBorder = [newCenter[0] + newRadius, newCenter[1], newCenter[2]];
+  }
 
+  // Update the sphere's center and radius.  Example:
+  // handle.setCenterAndRadius([1,2,3], 10);
+  publicAPI.setCenterAndRadius = (newCenter, newRadius) => {
+    const oldCenter = centerHandle.getOrigin();
+    const oldBorder = borderHandle.getOrigin();
+    let newBorder = [newCenter[0] + newRadius, newCenter[1], newCenter[2]];
     if (oldBorder) {
       // Move the boundary handle to reflect the new radius, while preserving
       // its direction relative to the center.
-      var direction = vec3.sub(vec3.create(), oldBorder, oldCenter);
-      var oldRadius = vec3.length(direction);
-
+      const direction = vec3.sub(vec3.create(), oldBorder, oldCenter);
+      const oldRadius = vec3.length(direction);
       if (oldRadius > 1e-10) {
         newBorder = vec3.add(vec3.create(), newCenter, vec3.scale(vec3.create(), direction, newRadius / oldRadius));
       }
     }
-
     centerHandle.setOrigin(newCenter);
     borderHandle.setOrigin(newBorder);
     updateSphere();
-
     model._widgetManager.enablePicking();
   };
-
-  publicAPI.handleLeftButtonPress = function (e) {
+  publicAPI.handleLeftButtonPress = e => {
     if (!isValidHandle(model.activeState)) {
       model.activeState = null;
       return macro.VOID;
     }
-
-    var worldCoords = currentWorldCoords(e);
-
+    const worldCoords = currentWorldCoords(e);
     if (model.activeState === moveHandle) {
       // Initial sphere placement.
       if (!centerHandle.getOrigin()) {
@@ -99,51 +83,38 @@ function widgetBehavior(publicAPI, model) {
       } else if (!borderHandle.getOrigin()) {
         borderHandle.setOrigin(worldCoords);
       }
-
       updateSphere();
     }
-
     model._isDragging = true;
-
     model._apiSpecificRenderWindow.setCursor('grabbing');
-
-    model.previousPosition = _toConsumableArray(currentWorldCoords(e));
+    model.previousPosition = [...currentWorldCoords(e)];
     publicAPI.invokeStartInteractionEvent();
     return macro.EVENT_ABORT;
   };
-
-  publicAPI.handleLeftButtonRelease = function (e) {
+  publicAPI.handleLeftButtonRelease = e => {
     if (!model._isDragging) {
       model.activeState = null;
       return macro.VOID;
     }
-
     if (isPlaced()) {
       model.previousPosition = null;
-
       model._widgetManager.enablePicking();
-
       model._apiSpecificRenderWindow.setCursor('pointer');
-
       model._isDragging = false;
       model.activeState = null;
       state.deactivate();
     }
-
     publicAPI.invokeEndInteractionEvent();
     return macro.EVENT_ABORT;
   };
-
-  publicAPI.handleMouseMove = function (e) {
+  publicAPI.handleMouseMove = e => {
     if (!model._isDragging) {
       model.activeState = null;
       return macro.VOID;
     }
-
     if (!model.activeState) throw Error('no activestate');
-    var worldCoords = currentWorldCoords(e);
+    const worldCoords = currentWorldCoords(e);
     model.activeState.setOrigin(worldCoords);
-
     if (model.activeState === centerHandle) {
       // When the sphere is fully placed, and the user is moving the
       // center, we move the whole sphere.
@@ -152,20 +123,17 @@ function widgetBehavior(publicAPI, model) {
           // !previousPosition here happens only immediately
           // after grabFocus, but grabFocus resets
           // borderHandle.origin.
-          throw Error("no pos ".concat(model.activeState, " ").concat(model.previousPosition));
+          throw Error(`no pos ${model.activeState} ${model.previousPosition}`);
         }
-
-        var translation = vec3.sub(vec3.create(), worldCoords, model.previousPosition);
+        const translation = vec3.sub(vec3.create(), worldCoords, model.previousPosition);
         borderHandle.setOrigin(vec3.add(vec3.create(), borderHandle.getOrigin(), translation));
       }
     }
-
     model.previousPosition = worldCoords;
     updateSphere();
     return macro.VOID;
   };
-
-  publicAPI.grabFocus = function () {
+  publicAPI.grabFocus = () => {
     moveHandle.setVisible(true);
     centerHandle.setVisible(false);
     borderHandle.setVisible(false);
@@ -173,11 +141,9 @@ function widgetBehavior(publicAPI, model) {
     borderHandle.setOrigin(null);
     model._isDragging = true;
     model.activeState = moveHandle;
-
     model._interactor.render();
   };
-
-  publicAPI.loseFocus = function () {
+  publicAPI.loseFocus = () => {
     model._isDragging = false;
     model.activeState = null;
   };

package/Widgets/Widgets3D/SphereWidget/state.js

@@ -1,9 +1,10 @@
 import vtkStateBuilder from '../../Core/StateBuilder.js';
 
+// Defines the structure of the widget state.
 // See https://kitware.github.io/vtk-js/docs/concepts_widgets.html.
-
 function stateGenerator() {
-  return vtkStateBuilder.createBuilder() // The handle used only for during initial placement.
+  return vtkStateBuilder.createBuilder()
+  // The handle used only for during initial placement.
   .addStateFromMixin({
     labels: ['moveHandle'],
     mixins: ['origin', 'color', 'scale1', 'visible', 'manipulator'],
@@ -12,7 +13,8 @@ function stateGenerator() {
       scale1: 20,
       visible: true
     }
-  }) // The handle for the center of the sphere.
+  })
+  // The handle for the center of the sphere.
   .addStateFromMixin({
     labels: ['centerHandle'],
     mixins: ['origin', 'color', 'scale1', 'visible', 'manipulator'],
@@ -21,7 +23,8 @@ function stateGenerator() {
       scale1: 20,
       visible: true
     }
-  }) // The handle for a border point of the sphere.
+  })
+  // The handle for a border point of the sphere.
   .addStateFromMixin({
     labels: ['borderHandle'],
     mixins: ['origin', 'color', 'scale1', 'visible', 'manipulator'],
@@ -30,7 +33,8 @@ function stateGenerator() {
       scale1: 20,
       visible: true
     }
-  }) // For displaying the sphere.
+  })
+  // For displaying the sphere.
   .addStateFromMixin({
     labels: ['sphereHandle'],
     mixins: ['origin', 'color', 'scale1', 'visible', 'orientation'],

package/Widgets/Widgets3D/SphereWidget.js

@@ -1,80 +1,70 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
 import vtkSphereContextRepresentation from '../Representations/SphereContextRepresentation.js';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import widgetBehavior from './SphereWidget/behavior.js';
 import stateGenerator from './SphereWidget/state.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; }
-
 function vtkSphereWidget(publicAPI, model) {
   model.classHierarchy.push('vtkSphereWidget');
-
-  var superClass = _objectSpread({}, publicAPI);
-
+  const superClass = {
+    ...publicAPI
+  };
   model.methodsToLink = ['scaleInPixels'];
+  publicAPI.getRepresentationsForViewType = viewType => [{
+    builder: vtkSphereHandleRepresentation,
+    labels: ['moveHandle']
+  }, {
+    builder: vtkSphereHandleRepresentation,
+    labels: ['centerHandle']
+  }, {
+    builder: vtkSphereHandleRepresentation,
+    labels: ['borderHandle']
+  }, {
+    builder: vtkSphereContextRepresentation,
+    labels: ['sphereHandle']
+  }];
 
-  publicAPI.getRepresentationsForViewType = function (viewType) {
-    return [{
-      builder: vtkSphereHandleRepresentation,
-      labels: ['moveHandle']
-    }, {
-      builder: vtkSphereHandleRepresentation,
-      labels: ['centerHandle']
-    }, {
-      builder: vtkSphereHandleRepresentation,
-      labels: ['borderHandle']
-    }, {
-      builder: vtkSphereContextRepresentation,
-      labels: ['sphereHandle']
-    }];
-  }; // --- Public methods -------------------------------------------------------
-
+  // --- Public methods -------------------------------------------------------
 
-  publicAPI.getRadius = function () {
-    var h1 = model.widgetState.getCenterHandle();
-    var h2 = model.widgetState.getBorderHandle();
+  publicAPI.getRadius = () => {
+    const h1 = model.widgetState.getCenterHandle();
+    const h2 = model.widgetState.getBorderHandle();
     return Math.sqrt(distance2BetweenPoints(h1.getOrigin(), h2.getOrigin()));
   };
-
-  publicAPI.setManipulator = function (manipulator) {
+  publicAPI.setManipulator = manipulator => {
     superClass.setManipulator(manipulator);
     model.widgetState.getMoveHandle().setManipulator(manipulator);
     model.widgetState.getCenterHandle().setManipulator(manipulator);
     model.widgetState.getBorderHandle().setManipulator(manipulator);
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // initialization
   // --------------------------------------------------------------------------
 
-
   publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
     useCameraNormal: true
   }));
 }
-
-var defaultValues = function defaultValues(initialValues) {
-  return _objectSpread({
-    behavior: widgetBehavior,
-    widgetState: stateGenerator()
-  }, initialValues);
-};
-
+const defaultValues = initialValues => ({
+  behavior: widgetBehavior,
+  widgetState: stateGenerator(),
+  ...initialValues
+});
 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, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['manipulator', 'widgetState']);
   vtkSphereWidget(publicAPI, model);
 }
-var newInstance = macro.newInstance(extend, 'vtkSphereWidget');
+const newInstance = macro.newInstance(extend, 'vtkSphereWidget');
 var vtkSphereWidget$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkSphereWidget$1 as default, extend, newInstance };