@kitware/vtk.js 28.10.1 → 28.11.0

package/Widgets/Widgets3D/ImageCroppingWidget.js

@@ -1,7 +1,4 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-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 vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkLineManipulator from '../Manipulators/LineManipulator.js';
@@ -12,106 +9,94 @@ import build from './ImageCroppingWidget/state.js';
 import { transformVec3, AXES } from './ImageCroppingWidget/helpers.js';
 import { ViewTypes } from '../Core/WidgetManager/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; }
 // ----------------------------------------------------------------------------
 // Factory
 // ----------------------------------------------------------------------------
 
 function vtkImageCroppingWidget(publicAPI, model) {
   model.classHierarchy.push('vtkImageCroppingWidget');
+  const superClass = {
+    ...publicAPI
+  };
+  let stateSub = null;
 
-  var superClass = _objectSpread({}, publicAPI);
-
-  var stateSub = null; // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
 
   function setHandlesEnabled(label, flag) {
-    model.widgetState.getStatesWithLabel(label).forEach(function (handle) {
+    model.widgetState.getStatesWithLabel(label).forEach(handle => {
       handle.setVisible(flag);
     });
-  } // Set the visibility of the three classes of handles: face, edge, corner
-
+  }
 
-  publicAPI.setFaceHandlesEnabled = function (flag) {
-    return setHandlesEnabled('faces', flag);
-  };
+  // Set the visibility of the three classes of handles: face, edge, corner
+  publicAPI.setFaceHandlesEnabled = flag => setHandlesEnabled('faces', flag);
+  publicAPI.setEdgeHandlesEnabled = flag => setHandlesEnabled('edges', flag);
+  publicAPI.setCornerHandlesEnabled = flag => setHandlesEnabled('corners', flag);
 
-  publicAPI.setEdgeHandlesEnabled = function (flag) {
-    return setHandlesEnabled('edges', flag);
-  };
+  // --------------------------------------------------------------------------
 
-  publicAPI.setCornerHandlesEnabled = function (flag) {
-    return setHandlesEnabled('corners', flag);
-  }; // --------------------------------------------------------------------------
   // Copies the transforms and dimension of a vtkImageData
-
-
-  publicAPI.copyImageDataDescription = function (im) {
-    var _model$widgetState, _model$widgetState2;
-
-    (_model$widgetState = model.widgetState).setIndexToWorldT.apply(_model$widgetState, _toConsumableArray(im.getIndexToWorld()));
-
-    (_model$widgetState2 = model.widgetState).setWorldToIndexT.apply(_model$widgetState2, _toConsumableArray(im.getWorldToIndex()));
-
-    var dims = im.getDimensions();
-    var planeState = model.widgetState.getCroppingPlanes();
+  publicAPI.copyImageDataDescription = im => {
+    model.widgetState.setIndexToWorldT(...im.getIndexToWorld());
+    model.widgetState.setWorldToIndexT(...im.getWorldToIndex());
+    const dims = im.getDimensions();
+    const planeState = model.widgetState.getCroppingPlanes();
     planeState.setPlanes([0, dims[0], 0, dims[1], 0, dims[2]]);
     publicAPI.modified();
-  }; // --------------------------------------------------------------------------
-  // Updates handle positions based on cropping planes
-
-
-  publicAPI.updateHandles = function () {
-    var planes = model.widgetState.getCroppingPlanes().getPlanes();
-    var midpts = [(planes[0] + planes[1]) / 2, (planes[2] + planes[3]) / 2, (planes[4] + planes[5]) / 2];
-    var iAxis = [planes[0], midpts[0], planes[1]];
-    var jAxis = [planes[2], midpts[1], planes[3]];
-    var kAxis = [planes[4], midpts[2], planes[5]];
-    var indexToWorldT = model.widgetState.getIndexToWorldT();
+  };
 
-    var getAxis = function getAxis(a) {
-      return AXES[a];
-    };
+  // --------------------------------------------------------------------------
 
-    for (var i = 0; i < 3; i++) {
-      for (var j = 0; j < 3; j++) {
-        for (var k = 0; k < 3; k++) {
+  // Updates handle positions based on cropping planes
+  publicAPI.updateHandles = () => {
+    const planes = model.widgetState.getCroppingPlanes().getPlanes();
+    const midpts = [(planes[0] + planes[1]) / 2, (planes[2] + planes[3]) / 2, (planes[4] + planes[5]) / 2];
+    const iAxis = [planes[0], midpts[0], planes[1]];
+    const jAxis = [planes[2], midpts[1], planes[3]];
+    const kAxis = [planes[4], midpts[2], planes[5]];
+    const indexToWorldT = model.widgetState.getIndexToWorldT();
+    const getAxis = a => AXES[a];
+    for (let i = 0; i < 3; i++) {
+      for (let j = 0; j < 3; j++) {
+        for (let k = 0; k < 3; k++) {
           // skip center of box
           if (i !== 1 || j !== 1 || k !== 1) {
-            var name = [i, j, k].map(getAxis).join('');
-            var coord = transformVec3([iAxis[i], jAxis[j], kAxis[k]], indexToWorldT);
-
-            var _model$widgetState$ge = model.widgetState.getStatesWithLabel(name),
-                _model$widgetState$ge2 = _slicedToArray(_model$widgetState$ge, 1),
-                handle = _model$widgetState$ge2[0];
-
-            handle.setOrigin.apply(handle, _toConsumableArray(coord));
+            const name = [i, j, k].map(getAxis).join('');
+            const coord = transformVec3([iAxis[i], jAxis[j], kAxis[k]], indexToWorldT);
+            const [handle] = model.widgetState.getStatesWithLabel(name);
+            handle.setOrigin(...coord);
           }
         }
       }
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.delete = macro.chain(publicAPI.delete, function () {
+  publicAPI.delete = macro.chain(publicAPI.delete, () => {
     if (stateSub) {
       stateSub.unsubscribe();
     }
-  }); // --- Widget Requirement ---------------------------------------------------
+  });
+
+  // --- Widget Requirement ---------------------------------------------------
+
+  model.methodsToLink = ['scaleInPixels'];
 
-  model.methodsToLink = ['scaleInPixels']; // Given a view type (geometry, slice, volume), return a description
+  // Given a view type (geometry, slice, volume), return a description
   // of what representations to create and what widget state to pass
   // to the respective representations.
-
-  publicAPI.getRepresentationsForViewType = function (viewType) {
+  publicAPI.getRepresentationsForViewType = viewType => {
     switch (viewType) {
       case ViewTypes.DEFAULT:
       case ViewTypes.GEOMETRY:
       case ViewTypes.SLICE:
       case ViewTypes.VOLUME:
       default:
-        return [// Describes constructing a vtkSphereHandleRepresentation, and every
+        return [
+        // Describes constructing a vtkSphereHandleRepresentation, and every
         // time the widget state updates, we will give the representation
         // a list of all handle states (which have the label "handles").
         {
@@ -123,67 +108,64 @@ function vtkImageCroppingWidget(publicAPI, model) {
           labels: ['corners']
         }];
     }
-  }; // Update handle positions when cropping planes update
-
+  };
 
+  // Update handle positions when cropping planes update
   stateSub = model.widgetState.getCroppingPlanes().onModified(publicAPI.updateHandles);
-
-  publicAPI.setCornerManipulator = function (manipulator) {
+  publicAPI.setCornerManipulator = manipulator => {
     superClass.setCornerManipulator(manipulator);
-    model.widgetState.getStatesWithLabel('corners').forEach(function (handle) {
-      return handle.setManipulator(manipulator);
-    });
+    model.widgetState.getStatesWithLabel('corners').forEach(handle => handle.setManipulator(manipulator));
   };
-
-  publicAPI.setEdgeManipulator = function (manipulator) {
+  publicAPI.setEdgeManipulator = manipulator => {
     superClass.setEdgeManipulator(manipulator);
-    model.widgetState.getStatesWithLabel('edges').forEach(function (handle) {
-      return handle.setManipulator(manipulator);
-    });
+    model.widgetState.getStatesWithLabel('edges').forEach(handle => handle.setManipulator(manipulator));
   };
-
-  publicAPI.setFaceManipulator = function (manipulator) {
+  publicAPI.setFaceManipulator = manipulator => {
     superClass.setFaceManipulator(manipulator);
-    model.widgetState.getStatesWithLabel('faces').forEach(function (handle) {
-      return handle.setManipulator(manipulator);
-    });
-  }; // --------------------------------------------------------------------------
+    model.widgetState.getStatesWithLabel('faces').forEach(handle => handle.setManipulator(manipulator));
+  };
+
+  // --------------------------------------------------------------------------
   // initialization
   // --------------------------------------------------------------------------
 
-
   publicAPI.setCornerManipulator(vtkPlanePointManipulator.newInstance({
     useCameraNormal: true
   }));
   publicAPI.setEdgeManipulator(vtkPlanePointManipulator.newInstance());
   publicAPI.setFaceManipulator(vtkLineManipulator.newInstance());
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
-var defaultValues = function defaultValues(initialValues) {
-  return _objectSpread({
-    // cornerManipulator: null,
-    // edgeManipulator: null,
-    // faceManipulator: null,
-    behavior: widgetBehavior,
-    widgetState: build()
-  }, initialValues);
-}; // ----------------------------------------------------------------------------
+const defaultValues = initialValues => ({
+  // cornerManipulator: null,
+  // edgeManipulator: null,
+  // faceManipulator: null,
+  behavior: widgetBehavior,
+  widgetState: build(),
+  ...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, ['cornerManipulator', 'edgeManipulator', 'faceManipulator']);
   vtkImageCroppingWidget(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkImageCroppingWidget'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkImageCroppingWidget');
+
+// ----------------------------------------------------------------------------
 
 var vtkImageCroppingWidget$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImageCroppingWidget$1 as default, extend, newInstance };

package/Widgets/Widgets3D/ImplicitPlaneWidget.js

@@ -1,6 +1,4 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkImplicitPlaneRepresentation from '../Representations/ImplicitPlaneRepresentation.js';
 import vtkLineManipulator from '../Manipulators/LineManipulator.js';
@@ -8,155 +6,130 @@ import vtkTrackballManipulator from '../Manipulators/TrackballManipulator.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import { ViewTypes } from '../Core/WidgetManager/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; }
+// ----------------------------------------------------------------------------
 // Widget linked to a view
 // ----------------------------------------------------------------------------
 
 function widgetBehavior(publicAPI, model) {
   model.classHierarchy.push('vtkPlaneWidget');
   model._isDragging = false;
-
-  publicAPI.setDisplayCallback = function (callback) {
-    return model.representations[0].setDisplayCallback(callback);
-  };
-
-  publicAPI.updateCursor = function () {
+  publicAPI.setDisplayCallback = callback => model.representations[0].setDisplayCallback(callback);
+  publicAPI.updateCursor = () => {
     switch (model.activeState.getUpdateMethodName()) {
       case 'updateFromOrigin':
         model._apiSpecificRenderWindow.setCursor('crosshair');
-
         break;
-
       case 'updateFromPlane':
         model._apiSpecificRenderWindow.setCursor('move');
-
         break;
-
       case 'updateFromNormal':
         model._apiSpecificRenderWindow.setCursor('alias');
-
         break;
-
       default:
         model._apiSpecificRenderWindow.setCursor('grabbing');
-
         break;
     }
   };
-
-  publicAPI.handleLeftButtonPress = function (callData) {
+  publicAPI.handleLeftButtonPress = callData => {
     if (!model.activeState || !model.activeState.getActive() || !model.pickable) {
       return macro.VOID;
     }
-
     model.lineManipulator.setWidgetOrigin(model.widgetState.getOrigin());
     model.planeManipulator.setWidgetOrigin(model.widgetState.getOrigin());
     model.trackballManipulator.reset(callData); // setup trackball delta
 
     if (model.dragable) {
       model._isDragging = true;
-
       model._apiSpecificRenderWindow.setCursor('grabbing');
-
       model._interactor.requestAnimation(publicAPI);
     }
-
     publicAPI.invokeStartInteractionEvent();
     return macro.EVENT_ABORT;
   };
-
-  publicAPI.handleMouseMove = function (callData) {
+  publicAPI.handleMouseMove = callData => {
     if (model._isDragging) {
       return publicAPI.handleEvent(callData);
     }
-
     return macro.VOID;
   };
-
-  publicAPI.handleLeftButtonRelease = function () {
+  publicAPI.handleLeftButtonRelease = () => {
     if (!model.activeState || !model.activeState.getActive() || !model.pickable) {
       return macro.VOID;
     }
-
     if (model._isDragging) {
       model._interactor.cancelAnimation(publicAPI);
-
       model._isDragging = false;
     }
-
     model.widgetState.deactivate();
     publicAPI.invokeEndInteractionEvent();
     return macro.EVENT_ABORT;
   };
-
-  publicAPI.handleEvent = function (callData) {
+  publicAPI.handleEvent = callData => {
     if (model.pickable && model.activeState && model.activeState.getActive()) {
       publicAPI[model.activeState.getUpdateMethodName()](callData);
       publicAPI.invokeInteractionEvent();
       return macro.EVENT_ABORT;
     }
-
     return macro.VOID;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Event coordinate translation
   // --------------------------------------------------------------------------
 
-
-  publicAPI.updateFromOrigin = function (callData) {
+  publicAPI.updateFromOrigin = callData => {
     model.planeManipulator.setWidgetNormal(model.widgetState.getNormal());
-
-    var _model$planeManipulat = model.planeManipulator.handleEvent(callData, model._apiSpecificRenderWindow),
-        worldCoords = _model$planeManipulat.worldCoords;
-
+    const {
+      worldCoords
+    } = model.planeManipulator.handleEvent(callData, model._apiSpecificRenderWindow);
     if (model.widgetState.containsPoint(worldCoords)) {
       model.activeState.setOrigin(worldCoords);
     }
-  }; // --------------------------------------------------------------------------
-
+  };
 
-  publicAPI.updateFromPlane = function (callData) {
-    var _model$widgetState;
+  // --------------------------------------------------------------------------
 
+  publicAPI.updateFromPlane = callData => {
     // Move origin along normal axis
     model.lineManipulator.setWidgetNormal(model.activeState.getNormal());
-
-    var _model$lineManipulato = model.lineManipulator.handleEvent(callData, model._apiSpecificRenderWindow),
-        worldCoords = _model$lineManipulato.worldCoords;
-
-    if ((_model$widgetState = model.widgetState).containsPoint.apply(_model$widgetState, _toConsumableArray(worldCoords))) {
+    const {
+      worldCoords
+    } = model.lineManipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+    if (model.widgetState.containsPoint(...worldCoords)) {
       model.activeState.setOrigin(worldCoords);
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.updateFromNormal = function (callData) {
+  publicAPI.updateFromNormal = callData => {
     model.trackballManipulator.setWidgetNormal(model.activeState.getNormal());
-
-    var _model$trackballManip = model.trackballManipulator.handleEvent(callData, model._apiSpecificRenderWindow),
-        newNormal = _model$trackballManip.worldCoords;
-
+    const {
+      worldCoords: newNormal
+    } = model.trackballManipulator.handleEvent(callData, model._apiSpecificRenderWindow);
     model.activeState.setNormal(newNormal);
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // initialization
   // --------------------------------------------------------------------------
 
-
   model.lineManipulator = vtkLineManipulator.newInstance();
   model.planeManipulator = vtkPlanePointManipulator.newInstance();
   model.trackballManipulator = vtkTrackballManipulator.newInstance();
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Factory
 // ----------------------------------------------------------------------------
 
-
 function vtkImplicitPlaneWidget(publicAPI, model) {
-  model.classHierarchy.push('vtkPlaneWidget'); // --- Widget Requirement ---------------------------------------------------
+  model.classHierarchy.push('vtkPlaneWidget');
 
-  model.methodsToLink = ['representationStyle', 'sphereResolution', 'handleSizeRatio', 'axisScale', 'normalVisible', 'originVisible', 'planeVisible', 'outlineVisible'];
+  // --- Widget Requirement ---------------------------------------------------
 
-  publicAPI.getRepresentationsForViewType = function (viewType) {
+  model.methodsToLink = ['representationStyle', 'sphereResolution', 'handleSizeRatio', 'axisScale', 'normalVisible', 'originVisible', 'planeVisible', 'outlineVisible'];
+  publicAPI.getRepresentationsForViewType = viewType => {
     switch (viewType) {
       case ViewTypes.DEFAULT:
       case ViewTypes.GEOMETRY:
@@ -168,29 +141,34 @@ function vtkImplicitPlaneWidget(publicAPI, model) {
         }];
     }
   };
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
-var defaultValues = function defaultValues(initialValues) {
-  return _objectSpread({
-    behavior: widgetBehavior,
-    widgetState: vtkImplicitPlaneRepresentation.generateState()
-  }, initialValues);
-}; // ----------------------------------------------------------------------------
+const defaultValues = initialValues => ({
+  behavior: widgetBehavior,
+  widgetState: vtkImplicitPlaneRepresentation.generateState(),
+  ...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);
   vtkImplicitPlaneWidget(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkImplicitPlaneWidget'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkImplicitPlaneWidget');
+
+// ----------------------------------------------------------------------------
 
 var vtkImplicitPlaneWidget$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImplicitPlaneWidget$1 as default, extend, newInstance };

package/Widgets/Widgets3D/InteractiveOrientationWidget/behavior.js

@@ -1,39 +1,38 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../../macros.js';
+import { m as macro } from '../../../macros2.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 widgetBehavior(publicAPI, model) {
   model.classHierarchy.push('vtkInteractiveOrientationWidgetProp');
-  macro.event(publicAPI, model, 'OrientationChange'); // --------------------------------------------------------------------------
+  macro.event(publicAPI, model, 'OrientationChange');
+
+  // --------------------------------------------------------------------------
   // Right click: Delete handle
   // --------------------------------------------------------------------------
 
-  publicAPI.handleRightButtonPress = function (e) {
+  publicAPI.handleRightButtonPress = e => {
     if (!model.activeState || !model.activeState.getActive() || !model.pickable) {
       return macro.VOID;
     }
-
-    publicAPI.invokeOrientationChange(_objectSpread({
+    publicAPI.invokeOrientationChange({
       action: 'rightPress',
-      event: e
-    }, model.activeState.get('up', 'right', 'direction')));
+      event: e,
+      ...model.activeState.get('up', 'right', 'direction')
+    });
     return macro.EVENT_ABORT;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Left press: Select handle to drag
   // --------------------------------------------------------------------------
 
-
-  publicAPI.handleLeftButtonPress = function (e) {
+  publicAPI.handleLeftButtonPress = e => {
     if (!model.activeState || !model.activeState.getActive() || !model.pickable) {
       return macro.VOID;
     }
-
-    publicAPI.invokeOrientationChange(_objectSpread({
+    publicAPI.invokeOrientationChange({
       action: 'leftPress',
-      event: e
-    }, model.activeState.get('up', 'right', 'direction')));
+      event: e,
+      ...model.activeState.get('up', 'right', 'direction')
+    });
     return macro.EVENT_ABORT;
   };
 }

package/Widgets/Widgets3D/InteractiveOrientationWidget/state.js

@@ -1,14 +1,22 @@
 import vtkStateBuilder from '../../Core/StateBuilder.js';
 
-var INITIAL_POINTS = [[-1, -1, -1], // 0
-[-1, 1, -1], // 1
-[1, -1, -1], // 2
-[1, 1, -1], // 3
-[-1, -1, 1], // 4
-[-1, 1, 1], // 5
-[1, -1, 1], // 6
+const INITIAL_POINTS = [[-1, -1, -1],
+// 0
+[-1, 1, -1],
+// 1
+[1, -1, -1],
+// 2
+[1, 1, -1],
+// 3
+[-1, -1, 1],
+// 4
+[-1, 1, 1],
+// 5
+[1, -1, 1],
+// 6
 [1, 1, 1] // 7
 ];
+
 function generateState() {
   return vtkStateBuilder.createBuilder().addStateFromMixin({
     labels: ['handles', '---'],