@kitware/vtk.js 28.10.2 → 28.11.1

package/Widgets/Widgets3D/ShapeWidget/behavior.js

@@ -1,6 +1,4 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../../macros.js';
+import { m as macro } from '../../../macros2.js';
 import { f as vtkMath } from '../../../Common/Core/Math/index.js';
 import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
 import vtkPlane from '../../../Common/DataModel/Plane.js';
@@ -8,92 +6,61 @@ import { ShapeBehavior, BehaviorCategory, TextPosition } from './Constants.js';
 import { boundPlane } from '../ResliceCursorWidget/helpers.js';
 import { vec3 } from 'gl-matrix';
 
-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; }
-var vtkErrorMacro = macro.vtkErrorMacro;
-var EPSILON = 1e-6;
+const {
+  vtkErrorMacro
+} = macro;
+const EPSILON = 1e-6;
 function widgetBehavior(publicAPI, model) {
   model.classHierarchy.push('vtkShapeWidgetProp');
   model._isDragging = false;
   model.keysDown = {};
+  const superClass = {
+    ...publicAPI
+  };
 
-  var superClass = _objectSpread({}, publicAPI); // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
   // Display 2D
   // --------------------------------------------------------------------------
 
-
-  publicAPI.setDisplayCallback = function (callback) {
-    return model.representations[0].setDisplayCallback(callback);
+  publicAPI.setDisplayCallback = callback => model.representations[0].setDisplayCallback(callback);
+  publicAPI.setText = text => {
+    model.widgetState.getText().setText(text);
+    // Recompute position
+    model._interactor.render();
   };
 
-  publicAPI.setText = function (text) {
-    model.widgetState.getText().setText(text); // Recompute position
-
-    model._interactor.render();
-  }; // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
   // Public methods
   // --------------------------------------------------------------------------
-
-
   publicAPI.setResetAfterPointPlacement = model._factory.setResetAfterPointPlacement;
   publicAPI.getResetAfterPointPlacement = model._factory.getResetAfterPointPlacement;
   publicAPI.setModifierBehavior = model._factory.setModifierBehavior;
   publicAPI.getModifierBehavior = model._factory.getModifierBehavior;
-
-  publicAPI.isBehaviorActive = function (category, flag) {
-    return Object.keys(model.keysDown).some(function (key) {
-      return model.keysDown[key] && publicAPI.getModifierBehavior()[key] && publicAPI.getModifierBehavior()[key][category] === flag;
-    });
-  };
-
-  publicAPI.isOppositeBehaviorActive = function (category, flag) {
-    return Object.values(ShapeBehavior[category]).some(function (flagToTry) {
-      return flag !== flagToTry && publicAPI.isBehaviorActive(category, flagToTry);
-    });
-  };
-
-  publicAPI.getActiveBehaviorFromCategory = function (category) {
-    return Object.values(ShapeBehavior[category]).find(function (flag) {
-      return publicAPI.isBehaviorActive(category, flag) || !publicAPI.isOppositeBehaviorActive(category, flag) && publicAPI.getModifierBehavior().None[category] === flag;
-    });
-  };
-
-  publicAPI.isRatioFixed = function () {
-    return publicAPI.getActiveBehaviorFromCategory(BehaviorCategory.RATIO) === ShapeBehavior[BehaviorCategory.RATIO].FIXED;
-  };
-
-  publicAPI.isDraggingEnabled = function () {
-    var behavior = publicAPI.getActiveBehaviorFromCategory(BehaviorCategory.PLACEMENT);
+  publicAPI.isBehaviorActive = (category, flag) => Object.keys(model.keysDown).some(key => model.keysDown[key] && publicAPI.getModifierBehavior()[key] && publicAPI.getModifierBehavior()[key][category] === flag);
+  publicAPI.isOppositeBehaviorActive = (category, flag) => Object.values(ShapeBehavior[category]).some(flagToTry => flag !== flagToTry && publicAPI.isBehaviorActive(category, flagToTry));
+  publicAPI.getActiveBehaviorFromCategory = category => Object.values(ShapeBehavior[category]).find(flag => publicAPI.isBehaviorActive(category, flag) || !publicAPI.isOppositeBehaviorActive(category, flag) && publicAPI.getModifierBehavior().None[category] === flag);
+  publicAPI.isRatioFixed = () => publicAPI.getActiveBehaviorFromCategory(BehaviorCategory.RATIO) === ShapeBehavior[BehaviorCategory.RATIO].FIXED;
+  publicAPI.isDraggingEnabled = () => {
+    const behavior = publicAPI.getActiveBehaviorFromCategory(BehaviorCategory.PLACEMENT);
     return behavior === ShapeBehavior[BehaviorCategory.PLACEMENT].DRAG || behavior === ShapeBehavior[BehaviorCategory.PLACEMENT].CLICK_AND_DRAG;
   };
-
-  publicAPI.isDraggingForced = function () {
-    return publicAPI.isBehaviorActive(BehaviorCategory.PLACEMENT, ShapeBehavior[BehaviorCategory.PLACEMENT].DRAG) || publicAPI.getModifierBehavior().None[BehaviorCategory.PLACEMENT] === ShapeBehavior[BehaviorCategory.PLACEMENT].DRAG;
-  };
-
-  publicAPI.getPoint1 = function () {
-    return model.point1;
-  };
-
-  publicAPI.getPoint2 = function () {
-    return model.point2;
-  };
-
-  publicAPI.setPoints = function (point1, point2) {
+  publicAPI.isDraggingForced = () => publicAPI.isBehaviorActive(BehaviorCategory.PLACEMENT, ShapeBehavior[BehaviorCategory.PLACEMENT].DRAG) || publicAPI.getModifierBehavior().None[BehaviorCategory.PLACEMENT] === ShapeBehavior[BehaviorCategory.PLACEMENT].DRAG;
+  publicAPI.getPoint1 = () => model.point1;
+  publicAPI.getPoint2 = () => model.point2;
+  publicAPI.setPoints = (point1, point2) => {
     model.point1 = point1;
     model.point2 = point2;
     model.point1Handle.setOrigin(model.point1);
     model.point2Handle.setOrigin(model.point2);
     publicAPI.updateShapeBounds();
-  }; // This method is to be called to place the first point
+  };
+
+  // This method is to be called to place the first point
   // for the first time. It is not inlined so that
   // the user can specify himself where the first point
   // is right after publicAPI.grabFocus() without waiting
   // for interactions.
-
-
-  publicAPI.placePoint1 = function (point) {
+  publicAPI.placePoint1 = point => {
     if (model.hasFocus) {
       publicAPI.setPoints(point, point);
       model.point1Handle.deactivate();
@@ -105,30 +72,29 @@ function widgetBehavior(publicAPI, model) {
       model.shapeHandle.setVisible(true);
     }
   };
-
-  publicAPI.placePoint2 = function (point2) {
+  publicAPI.placePoint2 = point2 => {
     if (model.hasFocus) {
       model.point2 = point2;
       model.point2Handle.setOrigin(model.point2);
       publicAPI.updateShapeBounds();
     }
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Private methods
   // --------------------------------------------------------------------------
 
-
-  publicAPI.makeSquareFromPoints = function (point1, point2) {
-    var diagonal = [0, 0, 0];
+  publicAPI.makeSquareFromPoints = (point1, point2) => {
+    const diagonal = [0, 0, 0];
     vec3.subtract(diagonal, point2, point1);
-    var dir = model.shapeHandle.getDirection();
-    var right = model.shapeHandle.getRight();
-    var up = model.shapeHandle.getUp();
-    var dirComponent = vec3.dot(diagonal, dir);
-    var rightComponent = vec3.dot(diagonal, right);
-    var upComponent = vec3.dot(diagonal, up);
-    var absRightComponent = Math.abs(rightComponent);
-    var absUpComponent = Math.abs(upComponent);
-
+    const dir = model.shapeHandle.getDirection();
+    const right = model.shapeHandle.getRight();
+    const up = model.shapeHandle.getUp();
+    const dirComponent = vec3.dot(diagonal, dir);
+    let rightComponent = vec3.dot(diagonal, right);
+    let upComponent = vec3.dot(diagonal, up);
+    const absRightComponent = Math.abs(rightComponent);
+    const absUpComponent = Math.abs(upComponent);
     if (absRightComponent < EPSILON) {
       rightComponent = upComponent;
     } else if (absUpComponent < EPSILON) {
@@ -138,148 +104,117 @@ function widgetBehavior(publicAPI, model) {
     } else {
       rightComponent = rightComponent / absRightComponent * absUpComponent;
     }
-
     return [point1[0] + rightComponent * right[0] + upComponent * up[0] + dirComponent * dir[0], point1[1] + rightComponent * right[1] + upComponent * up[1] + dirComponent * dir[1], point1[2] + rightComponent * right[2] + upComponent * up[2] + dirComponent * dir[2]];
   };
-
-  var getCornersFromRadius = function getCornersFromRadius(center, pointOnCircle) {
-    var radius = vec3.distance(center, pointOnCircle);
-    var up = model.shapeHandle.getUp();
-    var right = model.shapeHandle.getRight();
-    var point1 = [center[0] + (up[0] - right[0]) * radius, center[1] + (up[1] - right[1]) * radius, center[2] + (up[2] - right[2]) * radius];
-    var point2 = [center[0] + (right[0] - up[0]) * radius, center[1] + (right[1] - up[1]) * radius, center[2] + (right[2] - up[2]) * radius];
+  const getCornersFromRadius = (center, pointOnCircle) => {
+    const radius = vec3.distance(center, pointOnCircle);
+    const up = model.shapeHandle.getUp();
+    const right = model.shapeHandle.getRight();
+    const point1 = [center[0] + (up[0] - right[0]) * radius, center[1] + (up[1] - right[1]) * radius, center[2] + (up[2] - right[2]) * radius];
+    const point2 = [center[0] + (right[0] - up[0]) * radius, center[1] + (right[1] - up[1]) * radius, center[2] + (right[2] - up[2]) * radius];
     return {
-      point1: point1,
-      point2: point2
+      point1,
+      point2
     };
   };
-
-  var getCornersFromDiameter = function getCornersFromDiameter(point1, point2) {
-    var center = [0.5 * (point1[0] + point2[0]), 0.5 * (point1[1] + point2[1]), 0.5 * (point1[2] + point2[2])];
+  const getCornersFromDiameter = (point1, point2) => {
+    const center = [0.5 * (point1[0] + point2[0]), 0.5 * (point1[1] + point2[1]), 0.5 * (point1[2] + point2[2])];
     return getCornersFromRadius(center, point1);
-  }; // TODO: move to ShapeWidget/index.js
-
-
-  publicAPI.getBounds = function () {
-    return model.point1 && model.point2 ? vtkBoundingBox.addPoints(vtkBoundingBox.reset([]), [model.point1, model.point2]) : vtkMath.uninitializeBounds([]);
-  }; // To be reimplemented by subclass
+  };
 
+  // TODO: move to ShapeWidget/index.js
+  publicAPI.getBounds = () => model.point1 && model.point2 ? vtkBoundingBox.addPoints(vtkBoundingBox.reset([]), [model.point1, model.point2]) : vtkMath.uninitializeBounds([]);
 
-  publicAPI.setCorners = function (point1, point2) {
+  // To be reimplemented by subclass
+  publicAPI.setCorners = (point1, point2) => {
     publicAPI.updateTextPosition(point1, point2);
   };
-
-  publicAPI.updateShapeBounds = function () {
+  publicAPI.updateShapeBounds = () => {
     if (model.point1 && model.point2) {
-      var point1 = _toConsumableArray(model.point1);
-
-      var point2 = _toConsumableArray(model.point2);
-
+      const point1 = [...model.point1];
+      let point2 = [...model.point2];
       if (publicAPI.isRatioFixed()) {
         point2 = publicAPI.makeSquareFromPoints(point1, point2);
       }
-
       switch (publicAPI.getActiveBehaviorFromCategory(BehaviorCategory.POINTS)) {
         case ShapeBehavior[BehaviorCategory.POINTS].CORNER_TO_CORNER:
           {
             publicAPI.setCorners(point1, point2);
             break;
           }
-
         case ShapeBehavior[BehaviorCategory.POINTS].CENTER_TO_CORNER:
           {
-            var diagonal = [0, 0, 0];
+            const diagonal = [0, 0, 0];
             vec3.subtract(diagonal, point1, point2);
             vec3.add(point1, point1, diagonal);
             publicAPI.setCorners(point1, point2);
             break;
           }
-
         case ShapeBehavior[BehaviorCategory.POINTS].RADIUS:
           {
-            var points = getCornersFromRadius(point1, point2);
+            const points = getCornersFromRadius(point1, point2);
             publicAPI.setCorners(points.point1, points.point2);
             break;
           }
-
         case ShapeBehavior[BehaviorCategory.POINTS].DIAMETER:
           {
-            var _points = getCornersFromDiameter(point1, point2);
-
-            publicAPI.setCorners(_points.point1, _points.point2);
+            const points = getCornersFromDiameter(point1, point2);
+            publicAPI.setCorners(points.point1, points.point2);
             break;
           }
-
         default:
           // This should never be executed
           vtkErrorMacro('vtk internal error');
       }
     }
   };
-
-  var computePositionVector = function computePositionVector(textPosition, minPoint, maxPoint) {
-    var positionVector = [0, 0, 0];
-
+  const computePositionVector = (textPosition, minPoint, maxPoint) => {
+    const positionVector = [0, 0, 0];
     switch (textPosition) {
       case TextPosition.MIN:
         break;
-
       case TextPosition.MAX:
         vtkMath.subtract(maxPoint, minPoint, positionVector);
         break;
-
       case TextPosition.CENTER:
       default:
         vtkMath.subtract(maxPoint, minPoint, positionVector);
         vtkMath.multiplyScalar(positionVector, 0.5);
         break;
     }
-
     return positionVector;
   };
-
-  var computeTextPosition = function computeTextPosition(worldBounds, textPosition) {
-    var _model$_apiSpecificRe, _model$_apiSpecificRe2, _model$_apiSpecificRe5;
-
-    var worldMargin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-    var viewPlaneOrigin = vtkBoundingBox.getCenter(worldBounds);
-
-    var viewPlaneNormal = model._renderer.getActiveCamera().getDirectionOfProjection();
-
-    var viewUp = model._renderer.getActiveCamera().getViewUp();
-
-    var positionMargin = Array.isArray(worldMargin) ? _toConsumableArray(worldMargin) : [worldMargin, worldMargin, viewPlaneOrigin ? worldMargin : 0]; // Map bounds from world positions to display positions
-
-    var minPoint = (_model$_apiSpecificRe = model._apiSpecificRenderWindow).worldToDisplay.apply(_model$_apiSpecificRe, _toConsumableArray(vtkBoundingBox.getMinPoint(worldBounds)).concat([model._renderer]));
-
-    var maxPoint = (_model$_apiSpecificRe2 = model._apiSpecificRenderWindow).worldToDisplay.apply(_model$_apiSpecificRe2, _toConsumableArray(vtkBoundingBox.getMaxPoint(worldBounds)).concat([model._renderer]));
-
-    var displayBounds = vtkBoundingBox.addPoints(vtkBoundingBox.reset([]), [minPoint, maxPoint]);
-    var planeOrigin = [];
-    var p1 = [];
-    var p2 = [];
-    var p3 = []; // If we are in a 2D projection
-
+  const computeTextPosition = function (worldBounds, textPosition) {
+    let worldMargin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    const viewPlaneOrigin = vtkBoundingBox.getCenter(worldBounds);
+    const viewPlaneNormal = model._renderer.getActiveCamera().getDirectionOfProjection();
+    const viewUp = model._renderer.getActiveCamera().getViewUp();
+    const positionMargin = Array.isArray(worldMargin) ? [...worldMargin] : [worldMargin, worldMargin, viewPlaneOrigin ? worldMargin : 0];
+
+    // Map bounds from world positions to display positions
+    const minPoint = model._apiSpecificRenderWindow.worldToDisplay(...vtkBoundingBox.getMinPoint(worldBounds), model._renderer);
+    const maxPoint = model._apiSpecificRenderWindow.worldToDisplay(...vtkBoundingBox.getMaxPoint(worldBounds), model._renderer);
+    const displayBounds = vtkBoundingBox.addPoints(vtkBoundingBox.reset([]), [minPoint, maxPoint]);
+    let planeOrigin = [];
+    let p1 = [];
+    let p2 = [];
+    let p3 = [];
+
+    // If we are in a 2D projection
     if (viewPlaneOrigin && viewPlaneNormal && viewUp && vtkBoundingBox.intersectPlane(displayBounds, viewPlaneOrigin, viewPlaneNormal)) {
-      var _model$_apiSpecificRe3, _model$_apiSpecificRe4;
-
       // Map plane origin from world positions to display positions
-      var displayPlaneOrigin = (_model$_apiSpecificRe3 = model._apiSpecificRenderWindow).worldToDisplay.apply(_model$_apiSpecificRe3, _toConsumableArray(viewPlaneOrigin).concat([model._renderer])); // Map plane normal from world positions to display positions
-
-
-      var planeNormalPoint = vtkMath.add(viewPlaneOrigin, viewPlaneNormal, []);
-
-      var displayPlaneNormalPoint = (_model$_apiSpecificRe4 = model._apiSpecificRenderWindow).worldToDisplay.apply(_model$_apiSpecificRe4, _toConsumableArray(planeNormalPoint).concat([model._renderer]));
-
-      var displayPlaneNormal = vtkMath.subtract(displayPlaneNormalPoint, displayPlaneOrigin, []); // Project view plane into bounding box
-
-      var largeDistance = 10 * vtkBoundingBox.getDiagonalLength(displayBounds);
+      const displayPlaneOrigin = model._apiSpecificRenderWindow.worldToDisplay(...viewPlaneOrigin, model._renderer);
+      // Map plane normal from world positions to display positions
+      const planeNormalPoint = vtkMath.add(viewPlaneOrigin, viewPlaneNormal, []);
+      const displayPlaneNormalPoint = model._apiSpecificRenderWindow.worldToDisplay(...planeNormalPoint, model._renderer);
+      const displayPlaneNormal = vtkMath.subtract(displayPlaneNormalPoint, displayPlaneOrigin, []);
+
+      // Project view plane into bounding box
+      const largeDistance = 10 * vtkBoundingBox.getDiagonalLength(displayBounds);
       vtkPlane.projectPoint(vtkBoundingBox.getCenter(displayBounds), displayPlaneOrigin, displayPlaneNormal, planeOrigin);
-      var planeU = vtkMath.cross(viewUp, displayPlaneNormal, []);
+      const planeU = vtkMath.cross(viewUp, displayPlaneNormal, []);
       vtkMath.normalize(planeU); // u
-
       vtkMath.normalize(viewUp); // v
-
       vtkMath.normalize(displayPlaneNormal); // w
 
       vtkMath.multiplyAccumulate(planeOrigin, viewUp, -largeDistance, planeOrigin);
@@ -293,34 +228,32 @@ function widgetBehavior(publicAPI, model) {
       p1 = [displayBounds[1], displayBounds[2], displayBounds[4]];
       p2 = [displayBounds[0], displayBounds[3], displayBounds[4]];
       p3 = [displayBounds[0], displayBounds[2], displayBounds[5]];
-    } // Compute horizontal, vertical and depth position
-
+    }
 
-    var u = computePositionVector(textPosition[0], planeOrigin, p1);
-    var v = computePositionVector(textPosition[1], planeOrigin, p2);
-    var w = computePositionVector(textPosition[2], planeOrigin, p3);
-    var finalPosition = planeOrigin;
+    // Compute horizontal, vertical and depth position
+    const u = computePositionVector(textPosition[0], planeOrigin, p1);
+    const v = computePositionVector(textPosition[1], planeOrigin, p2);
+    const w = computePositionVector(textPosition[2], planeOrigin, p3);
+    const finalPosition = planeOrigin;
     vtkMath.add(finalPosition, u, finalPosition);
     vtkMath.add(finalPosition, v, finalPosition);
     vtkMath.add(finalPosition, w, finalPosition);
     vtkMath.add(finalPosition, positionMargin, finalPosition);
-    return (_model$_apiSpecificRe5 = model._apiSpecificRenderWindow).displayToWorld.apply(_model$_apiSpecificRe5, finalPosition.concat([model._renderer]));
+    return model._apiSpecificRenderWindow.displayToWorld(...finalPosition, model._renderer);
   };
-
-  publicAPI.updateTextPosition = function (point1, point2) {
-    var bounds = vtkBoundingBox.addPoints(vtkBoundingBox.reset([]), [point1, point2]);
-    var screenPosition = computeTextPosition(bounds, model.widgetState.getTextPosition(), model.widgetState.getTextWorldMargin());
-    var textHandle = model.widgetState.getText();
+  publicAPI.updateTextPosition = (point1, point2) => {
+    const bounds = vtkBoundingBox.addPoints(vtkBoundingBox.reset([]), [point1, point2]);
+    const screenPosition = computeTextPosition(bounds, model.widgetState.getTextPosition(), model.widgetState.getTextWorldMargin());
+    const textHandle = model.widgetState.getText();
     textHandle.setOrigin(screenPosition);
   };
+
   /*
    * If the widget has the focus, this method reset the widget
    * to it's state just after it grabbed the focus. Otherwise
    * it resets the widget to its state before it grabbed the focus.
    */
-
-
-  publicAPI.reset = function () {
+  publicAPI.reset = () => {
     model.point1 = null;
     model.point2 = null;
     model.widgetState.getText().setVisible(false);
@@ -330,7 +263,6 @@ function widgetBehavior(publicAPI, model) {
     model.shapeHandle.setVisible(false);
     model.point2Handle.setVisible(false);
     model.point2Handle.deactivate();
-
     if (model.hasFocus) {
       model.point1Handle.activate();
       model.activeState = model.point1Handle;
@@ -339,43 +271,35 @@ function widgetBehavior(publicAPI, model) {
       model.point1Handle.deactivate();
       model.activeState = null;
     }
-
     publicAPI.updateShapeBounds();
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Interactor events
   // --------------------------------------------------------------------------
 
-
-  publicAPI.handleMouseMove = function (callData) {
-    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;
-
+  publicAPI.handleMouseMove = callData => {
+    const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
     if (!manipulator || !model.activeState || !model.activeState.getActive() || !model.pickable || !model.dragable) {
       return macro.VOID;
     }
-
     if (!model.point2) {
       // Update orientation to match the camera's plane
       // if the corners are not yet placed
-      var normal = model._camera.getDirectionOfProjection();
-
-      var up = model._camera.getViewUp();
-
-      var right = [];
+      const normal = model._camera.getDirectionOfProjection();
+      const up = model._camera.getViewUp();
+      const right = [];
       vec3.cross(right, up, normal);
       model.shapeHandle.setUp(up);
       model.shapeHandle.setRight(right);
       model.shapeHandle.setDirection(normal);
     }
-
-    var _manipulator$handleEv = manipulator.handleEvent(callData, model._apiSpecificRenderWindow),
-        worldCoords = _manipulator$handleEv.worldCoords;
-
+    const {
+      worldCoords
+    } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
     if (!worldCoords.length) {
       return macro.VOID;
     }
-
     if (model.hasFocus) {
       if (!model.point1) {
         model.point1Handle.setOrigin(worldCoords);
@@ -393,30 +317,25 @@ function widgetBehavior(publicAPI, model) {
         model.point2Handle.setOrigin(worldCoords);
         model.point2 = worldCoords;
       }
-
       publicAPI.updateShapeBounds();
       publicAPI.invokeInteractionEvent();
     }
-
     return model.hasFocus || model._isDragging ? macro.EVENT_ABORT : macro.VOID;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Left click: Add point / End interaction
   // --------------------------------------------------------------------------
 
-
-  publicAPI.handleLeftButtonPress = function (e) {
-    var _model$activeState$ge3, _model$activeState2, _model$activeState2$g;
-
-    var manipulator = (_model$activeState$ge3 = (_model$activeState2 = model.activeState) === null || _model$activeState2 === void 0 ? void 0 : (_model$activeState2$g = _model$activeState2.getManipulator) === null || _model$activeState2$g === void 0 ? void 0 : _model$activeState2$g.call(_model$activeState2)) !== null && _model$activeState$ge3 !== void 0 ? _model$activeState$ge3 : model.manipulator;
-
+  publicAPI.handleLeftButtonPress = e => {
+    const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
     if (!model.activeState || !model.activeState.getActive() || !model.pickable || !manipulator) {
       return macro.VOID;
     }
-
     if (model.hasFocus) {
-      var _manipulator$handleEv2 = manipulator.handleEvent(e, model._apiSpecificRenderWindow),
-          worldCoords = _manipulator$handleEv2.worldCoords;
-
+      const {
+        worldCoords
+      } = manipulator.handleEvent(e, model._apiSpecificRenderWindow);
       if (!model.point1) {
         model.point1Handle.setOrigin(worldCoords);
         publicAPI.placePoint1(model.point1Handle.getOrigin());
@@ -426,67 +345,51 @@ function widgetBehavior(publicAPI, model) {
         publicAPI.placePoint2(model.point2Handle.getOrigin());
         publicAPI.invokeInteractionEvent();
         publicAPI.invokeEndInteractionEvent();
-
         if (publicAPI.getResetAfterPointPlacement()) {
           publicAPI.reset();
         } else {
           publicAPI.loseFocus();
         }
       }
-
       return macro.EVENT_ABORT;
     }
-
     if (model.point1 && (model.activeState === model.point1Handle || model.activeState === model.point2Handle) && model.dragable) {
       model._isDragging = true;
-
       model._apiSpecificRenderWindow.setCursor('grabbing');
-
       model._interactor.requestAnimation(publicAPI);
     }
-
     publicAPI.invokeStartInteractionEvent();
     return macro.EVENT_ABORT;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Left release: Maybe end interaction
   // --------------------------------------------------------------------------
 
-
-  publicAPI.handleLeftButtonRelease = function (e) {
+  publicAPI.handleLeftButtonRelease = e => {
     if (model._isDragging) {
       model._isDragging = false;
-
       model._apiSpecificRenderWindow.setCursor('pointer');
-
       model.widgetState.deactivate();
-
       model._interactor.cancelAnimation(publicAPI);
-
       publicAPI.invokeEndInteractionEvent();
       return macro.EVENT_ABORT;
     }
-
     if (!model.hasFocus || !model.pickable) {
       return macro.VOID;
     }
-
-    var viewSize = model._apiSpecificRenderWindow.getSize();
-
+    const viewSize = model._apiSpecificRenderWindow.getSize();
     if (e.position.x < 0 || e.position.x > viewSize[0] - 1 || e.position.y < 0 || e.position.y > viewSize[1] - 1) {
       return macro.VOID;
     }
-
     if (model.point1) {
       publicAPI.placePoint2(model.point2Handle.getOrigin());
-
       if (publicAPI.isDraggingEnabled()) {
-        var distance = vec3.squaredDistance(model.point1, model.point2);
-        var maxDistance = 100;
-
+        const distance = vec3.squaredDistance(model.point1, model.point2);
+        const maxDistance = 100;
         if (distance > maxDistance || publicAPI.isDraggingForced()) {
           publicAPI.invokeInteractionEvent();
           publicAPI.invokeEndInteractionEvent();
-
           if (publicAPI.getResetAfterPointPlacement()) {
             publicAPI.reset();
           } else {
@@ -495,16 +398,17 @@ function widgetBehavior(publicAPI, model) {
         }
       }
     }
-
     return macro.EVENT_ABORT;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Register key presses/releases
   // --------------------------------------------------------------------------
 
-
-  publicAPI.handleKeyDown = function (_ref) {
-    var key = _ref.key;
-
+  publicAPI.handleKeyDown = _ref => {
+    let {
+      key
+    } = _ref;
     if (key === 'Escape') {
       if (model.hasFocus) {
         publicAPI.reset();
@@ -514,7 +418,6 @@ function widgetBehavior(publicAPI, model) {
     } else {
       model.keysDown[key] = true;
     }
-
     if (model.hasFocus) {
       if (model.point1) {
         model.point2 = model.point2Handle.getOrigin();
@@ -522,56 +425,51 @@ function widgetBehavior(publicAPI, model) {
       }
     }
   };
-
-  publicAPI.handleKeyUp = function (_ref2) {
-    var key = _ref2.key;
+  publicAPI.handleKeyUp = _ref2 => {
+    let {
+      key
+    } = _ref2;
     model.keysDown[key] = false;
-
     if (model.hasFocus) {
       if (model.point1) {
         model.point2 = model.point2Handle.getOrigin();
         publicAPI.updateShapeBounds();
       }
     }
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Focus API - follow mouse when widget has focus
   // --------------------------------------------------------------------------
 
-
-  publicAPI.grabFocus = function () {
+  publicAPI.grabFocus = () => {
     if (!model.hasFocus) {
       publicAPI.reset();
       model.point1Handle.activate();
       model.activeState = model.point1Handle;
       model.point1Handle.setVisible(true);
       model.shapeHandle.setVisible(false);
-
       model._interactor.requestAnimation(publicAPI);
     }
-
     superClass.grabFocus();
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.loseFocus = function () {
+  publicAPI.loseFocus = () => {
     if (model.hasFocus) {
       model._interactor.cancelAnimation(publicAPI);
     }
-
     if (!model.point1) {
       model.point1Handle.setVisible(false);
       model.point2Handle.setVisible(false);
     }
-
     model.widgetState.deactivate();
     model.point1Handle.deactivate();
     model.point2Handle.deactivate();
     model.activeState = null;
-
     model._interactor.render();
-
     model._widgetManager.enablePicking();
-
     superClass.loseFocus();
   };
 }