@kitware/vtk.js 28.10.2 → 28.11.0

package/Widgets/Widgets3D/LineWidget/behavior.js

@@ -1,129 +1,118 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import Constants from './Constants.js';
-import macro from '../../../macros.js';
+import { m as macro } from '../../../macros2.js';
 import { s as subtract, k as add, l as normalize } from '../../../Common/Core/Math/index.js';
 import { getNumberOfPlacedHandles, isHandlePlaced, calculateTextPosition, updateTextPosition, getPoint } from './helpers.js';
 
-var ShapeType = Constants.ShapeType; // Total number of points to place
-
-var MAX_POINTS = 2;
-var handleGetters = ['getHandle1', 'getHandle2', 'getMoveHandle'];
+const {
+  ShapeType
+} = Constants;
+// Total number of points to place
+const MAX_POINTS = 2;
+const handleGetters = ['getHandle1', 'getHandle2', 'getMoveHandle'];
 function widgetBehavior(publicAPI, model) {
   model.classHierarchy.push('vtkLineWidgetProp');
   model._isDragging = false;
+
   /**
    * Returns the handle at the handleIndex'th index.
    * @param {number} handleIndex 0, 1 or 2
    */
+  publicAPI.getHandle = handleIndex => model.widgetState[handleGetters[handleIndex]]();
 
-  publicAPI.getHandle = function (handleIndex) {
-    return model.widgetState[handleGetters[handleIndex]]();
-  };
   /**
    * Return the index in the of tbe handle in `representations` array,
    * or -1 if the handle is not present in the widget state.
    */
-
-
-  publicAPI.getHandleIndex = function (handle) {
+  publicAPI.getHandleIndex = handle => {
     switch (handle) {
       case model.widgetState.getHandle1():
         return 0;
-
       case model.widgetState.getHandle2():
         return 1;
-
       case model.widgetState.getMoveHandle():
         return 2;
-
       default:
         return -1;
     }
   };
+  publicAPI.isPlaced = () => getNumberOfPlacedHandles(model.widgetState) === MAX_POINTS;
 
-  publicAPI.isPlaced = function () {
-    return getNumberOfPlacedHandles(model.widgetState) === MAX_POINTS;
-  }; // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
   // Interactor event
   // --------------------------------------------------------------------------
 
-
   function ignoreKey(e) {
     return e.altKey || e.controlKey || e.shiftKey;
   }
-
   function updateCursor(callData) {
-    var _model$activeState$ge, _model$activeState, _model$activeState$ge2;
-
     model._isDragging = true;
-    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;
     model.previousPosition = manipulator.handleEvent(callData, model._apiSpecificRenderWindow).worldCoords;
-
     model._apiSpecificRenderWindow.setCursor('grabbing');
-
     model._interactor.requestAnimation(publicAPI);
-  } // --------------------------------------------------------------------------
+  }
+
+  // --------------------------------------------------------------------------
   // Text methods
   // --------------------------------------------------------------------------
 
-
-  publicAPI.setText = function (text) {
+  publicAPI.setText = text => {
     model.widgetState.getText().setText(text);
-
     model._interactor.render();
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Handle positioning methods
   // --------------------------------------------------------------------------
-  // Handle utilities ---------------------------------------------------------
 
+  // Handle utilities ---------------------------------------------------------
 
   function getLineDirection(p1, p2) {
-    var dir = subtract(p1, p2, []);
+    const dir = subtract(p1, p2, []);
     normalize(dir);
     return dir;
-  } // Handle orientation & rotation ---------------------------------------------------------
+  }
 
+  // Handle orientation & rotation ---------------------------------------------------------
 
   function computeMousePosition(p1, callData) {
-    var displayMousePos = publicAPI.computeWorldToDisplay.apply(publicAPI, [model._renderer].concat(_toConsumableArray(p1)));
-    var worldMousePos = publicAPI.computeDisplayToWorld(model._renderer, callData.position.x, callData.position.y, displayMousePos[2]);
+    const displayMousePos = publicAPI.computeWorldToDisplay(model._renderer, ...p1);
+    const worldMousePos = publicAPI.computeDisplayToWorld(model._renderer, callData.position.x, callData.position.y, displayMousePos[2]);
     return worldMousePos;
   }
+
   /**
    * Returns the  handle orientation to match the direction vector of the polyLine from one tip to another
    * @param {number} handleIndex 0 for handle1, 1 for handle2
    * @param {object} callData if specified, uses mouse position as 2nd point
    */
-
-
   function getHandleOrientation(handleIndex) {
-    var callData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-    var point1 = getPoint(handleIndex, model.widgetState);
-    var point2 = callData ? computeMousePosition(point1, callData) : getPoint(1 - handleIndex, model.widgetState);
+    let callData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    const point1 = getPoint(handleIndex, model.widgetState);
+    const point2 = callData ? computeMousePosition(point1, callData) : getPoint(1 - handleIndex, model.widgetState);
     return point1 && point2 ? getLineDirection(point1, point2) : null;
   }
+
   /**
    * Orient handle
    * @param {number} handleIndex 0, 1 or 2
    * @param {object} callData optional, see getHandleOrientation for details.
    */
-
-
   function updateHandleOrientation(handleIndex) {
-    var orientation = getHandleOrientation(Math.min(1, handleIndex));
+    const orientation = getHandleOrientation(Math.min(1, handleIndex));
     model.representations[handleIndex].setOrientation(orientation);
   }
-
-  publicAPI.updateHandleOrientations = function () {
+  publicAPI.updateHandleOrientations = () => {
     updateHandleOrientation(0);
     updateHandleOrientation(1);
     updateHandleOrientation(2);
   };
-
-  publicAPI.rotateHandlesToFaceCamera = function () {
+  publicAPI.rotateHandlesToFaceCamera = () => {
     model.representations[0].setViewMatrix(Array.from(model._camera.getViewMatrix()));
     model.representations[1].setViewMatrix(Array.from(model._camera.getViewMatrix()));
-  }; // Handles visibility ---------------------------------------------------------
+  };
+
+  // Handles visibility ---------------------------------------------------------
 
   /**
    * Set actor visibility to true unless it is a NONE handle
@@ -132,55 +121,46 @@ function widgetBehavior(publicAPI, model) {
    * @param handle : the handle state object
    * @param handleNb : the handle number according to its label in widget state
    */
-
-
-  publicAPI.updateHandleVisibility = function (handleIndex) {
-    var handle = publicAPI.getHandle(handleIndex);
-    var visibility = handle.getVisible() && isHandlePlaced(handleIndex, model.widgetState);
+  publicAPI.updateHandleVisibility = handleIndex => {
+    const handle = publicAPI.getHandle(handleIndex);
+    const visibility = handle.getVisible() && isHandlePlaced(handleIndex, model.widgetState);
     model.representations[handleIndex].setVisibilityFlagArray([visibility, visibility && handle.getShape() !== ShapeType.NONE]);
     model.representations[handleIndex].updateActorVisibility();
-
     model._interactor.render();
   };
+
   /**
    * Called when placing a point from the first time.
    * @param {number} handleIndex
    */
-
-
-  publicAPI.placeHandle = function (handleIndex) {
-    var handle = publicAPI.getHandle(handleIndex);
-    handle.setOrigin.apply(handle, _toConsumableArray(model.widgetState.getMoveHandle().getOrigin()));
+  publicAPI.placeHandle = handleIndex => {
+    const handle = publicAPI.getHandle(handleIndex);
+    handle.setOrigin(...model.widgetState.getMoveHandle().getOrigin());
     publicAPI.updateHandleOrientations();
     publicAPI.rotateHandlesToFaceCamera();
     model.widgetState.getText().setOrigin(calculateTextPosition(model));
     publicAPI.updateHandleVisibility(handleIndex);
-
     if (handleIndex === 0) {
-      var _publicAPI$getHandle;
-
       // For the line (handle1, handle2, moveHandle) to be displayed
       // correctly, handle2 origin must be valid.
-      (_publicAPI$getHandle = publicAPI.getHandle(1)).setOrigin.apply(_publicAPI$getHandle, _toConsumableArray(model.widgetState.getMoveHandle().getOrigin())); // Now that handle2 has a valid origin, hide it
-
-
+      publicAPI.getHandle(1).setOrigin(...model.widgetState.getMoveHandle().getOrigin());
+      // Now that handle2 has a valid origin, hide it
       publicAPI.updateHandleVisibility(1);
       model.widgetState.getMoveHandle().setShape(publicAPI.getHandle(1).getShape());
     }
-
     if (handleIndex === 1) {
       publicAPI.loseFocus();
     }
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Left press: Select handle to drag
   // --------------------------------------------------------------------------
 
-
-  publicAPI.handleLeftButtonPress = function (e) {
+  publicAPI.handleLeftButtonPress = e => {
     if (!model.activeState || !model.activeState.getActive() || !model.pickable || ignoreKey(e)) {
       return macro.VOID;
     }
-
     if (model.activeState === model.widgetState.getMoveHandle() && getNumberOfPlacedHandles(model.widgetState) === 0) {
       publicAPI.placeHandle(0);
     } else if (model.widgetState.getMoveHandle().getActive() && getNumberOfPlacedHandles(model.widgetState) === 1) {
@@ -189,28 +169,26 @@ function widgetBehavior(publicAPI, model) {
       // Grab handle1, handle2 or whole widget
       updateCursor(e);
     }
-
     publicAPI.invokeStartInteractionEvent();
     return macro.EVENT_ABORT;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Mouse move: Drag selected handle / Handle follow the mouse
   // --------------------------------------------------------------------------
 
-
-  publicAPI.handleMouseMove = function (callData) {
-    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.handleMouseMove = callData => {
+    const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
     if (manipulator && model.pickable && model.dragable && model.activeState && model.activeState.getActive() && !ignoreKey(callData)) {
-      var _manipulator$handleEv = manipulator.handleEvent(callData, model._apiSpecificRenderWindow),
-          worldCoords = _manipulator$handleEv.worldCoords;
-
-      var translation = model.previousPosition ? subtract(worldCoords, model.previousPosition, []) : [0, 0, 0];
+      const {
+        worldCoords
+      } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+      const translation = model.previousPosition ? subtract(worldCoords, model.previousPosition, []) : [0, 0, 0];
       model.previousPosition = worldCoords;
-
-      if ( // is placing first or second handle
-      model.activeState === model.widgetState.getMoveHandle() || // is dragging already placed first or second handle
+      if (
+      // is placing first or second handle
+      model.activeState === model.widgetState.getMoveHandle() ||
+      // is dragging already placed first or second handle
       model._isDragging) {
         if (model.activeState.setOrigin) {
           model.activeState.setOrigin(worldCoords);
@@ -220,96 +198,81 @@ function widgetBehavior(publicAPI, model) {
           publicAPI.getHandle(0).setOrigin(add(publicAPI.getHandle(0).getOrigin(), translation, []));
           publicAPI.getHandle(1).setOrigin(add(publicAPI.getHandle(1).getOrigin(), translation, []));
         }
-
         publicAPI.updateHandleOrientations();
         updateTextPosition(model);
         publicAPI.invokeInteractionEvent();
         return macro.EVENT_ABORT;
       }
     }
-
     return macro.VOID;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Left release: Finish drag
   // --------------------------------------------------------------------------
 
-
-  publicAPI.handleLeftButtonRelease = function () {
+  publicAPI.handleLeftButtonRelease = () => {
     if (!model.activeState || !model.activeState.getActive() || !model.pickable) {
       publicAPI.rotateHandlesToFaceCamera();
       return macro.VOID;
     }
-
     if (model.hasFocus && publicAPI.isPlaced()) {
       publicAPI.loseFocus();
       return macro.VOID;
     }
-
     if (model._isDragging && publicAPI.isPlaced()) {
-      var wasTextActive = model.widgetState.getText().getActive(); // Recompute offsets
-
+      const wasTextActive = model.widgetState.getText().getActive();
+      // Recompute offsets
       model.widgetState.deactivate();
       model.activeState = null;
-
       if (!wasTextActive) {
         model._interactor.cancelAnimation(publicAPI);
       }
-
       model._apiSpecificRenderWindow.setCursor('pointer');
-
       model.hasFocus = false;
       model._isDragging = false;
     } else if (model.activeState !== model.widgetState.getMoveHandle()) {
       model.widgetState.deactivate();
     }
-
     if (model.hasFocus && !model.activeState || model.activeState && !model.activeState.getActive()) {
       model._widgetManager.enablePicking();
-
       model._interactor.render();
     }
-
     publicAPI.invokeEndInteractionEvent();
     return macro.EVENT_ABORT;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Focus API - moveHandle follow mouse when widget has focus
   // --------------------------------------------------------------------------
 
-
-  publicAPI.grabFocus = function () {
+  publicAPI.grabFocus = () => {
     if (!model.hasFocus && !publicAPI.isPlaced()) {
       model.activeState = model.widgetState.getMoveHandle();
       model.activeState.setShape(publicAPI.getHandle(0).getShape());
       model.activeState.activate();
-
       model._interactor.requestAnimation(publicAPI);
-
       publicAPI.invokeStartInteractionEvent();
     }
-
     model.hasFocus = true;
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.loseFocus = function () {
+  publicAPI.loseFocus = () => {
     if (model.hasFocus) {
       model._interactor.cancelAnimation(publicAPI);
-
       publicAPI.invokeEndInteractionEvent();
     }
-
     model.widgetState.deactivate();
     model.widgetState.getMoveHandle().deactivate();
     model.widgetState.getMoveHandle().setOrigin(null);
     model.activeState = null;
     model.hasFocus = false;
-
     model._widgetManager.enablePicking();
-
     model._interactor.render();
   };
-
-  publicAPI.reset = function () {
+  publicAPI.reset = () => {
     model.widgetState.deactivate();
     model.widgetState.getMoveHandle().deactivate();
     model.widgetState.getHandle1().setOrigin(null);

package/Widgets/Widgets3D/LineWidget/helpers.js

@@ -1,15 +1,13 @@
 import { s as subtract, w as multiplyScalar, k as add, B as areEquals } from '../../../Common/Core/Math/index.js';
 
 function calculateTextPosition(model) {
-  var vector = [0, 0, 0];
-  var handle1WorldPos = model.widgetState.getHandle1().getOrigin();
-  var handle2WorldPos = model.widgetState.getHandle2().getOrigin();
-
+  const vector = [0, 0, 0];
+  const handle1WorldPos = model.widgetState.getHandle1().getOrigin();
+  const handle2WorldPos = model.widgetState.getHandle2().getOrigin();
   if (!handle1WorldPos || !handle2WorldPos) {
     return null;
   }
-
-  var statePositionOnLine = model.widgetState.getPositionOnLine().getPosOnLine();
+  let statePositionOnLine = model.widgetState.getPositionOnLine().getPosOnLine();
   statePositionOnLine = 1 - statePositionOnLine;
   subtract(handle1WorldPos, handle2WorldPos, vector);
   multiplyScalar(vector, statePositionOnLine);
@@ -17,23 +15,21 @@ function calculateTextPosition(model) {
   return vector;
 }
 function updateTextPosition(model) {
-  var SVGTextState = model.widgetState.getText();
+  const SVGTextState = model.widgetState.getText();
   SVGTextState.setOrigin(calculateTextPosition(model));
 }
 function isHandlePlaced(handleIndex, widgetState) {
   if (handleIndex === 2) {
     return widgetState.getMoveHandle().getOrigin() != null;
   }
-
-  var handle1Origin = widgetState.getHandle1().getOrigin();
-
+  const handle1Origin = widgetState.getHandle1().getOrigin();
   if (handleIndex === 0) {
     return handle1Origin != null;
   }
-
-  var handle2Origin = widgetState.getHandle2().getOrigin();
+  const handle2Origin = widgetState.getHandle2().getOrigin();
   return handle1Origin && handle2Origin && !areEquals(handle1Origin, handle2Origin, 0);
 }
+
 /**
  * Returns the world position of line extremities (placed or not).
  * Returns null if no extremity exist.
@@ -41,26 +37,23 @@ function isHandlePlaced(handleIndex, widgetState) {
  * @param {object} widgetState state of line widget
  * @param {bool} moveHandle Get move handle position if moveHandle is true and handle is not placed
  */
-
 function getPoint(handleIndex, widgetState) {
-  var moveHandle = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-  var handle = moveHandle && !isHandlePlaced(handleIndex, widgetState) ? widgetState.getMoveHandle() : widgetState["getHandle".concat(handleIndex + 1)]();
-  var origin = handle.getOrigin();
+  let moveHandle = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  const handle = moveHandle && !isHandlePlaced(handleIndex, widgetState) ? widgetState.getMoveHandle() : widgetState[`getHandle${handleIndex + 1}`]();
+  const origin = handle.getOrigin();
   return origin || null;
 }
+
 /**
  * Returns the number of handle placed on the scene by checking
  * handle positions. Returns 2 when the user is still
  * placing 2nd handle
  * */
-
 function getNumberOfPlacedHandles(widgetState) {
-  var numberOfPlacedHandles = 0;
-
+  let numberOfPlacedHandles = 0;
   if (isHandlePlaced(0, widgetState)) {
     numberOfPlacedHandles = 1 + isHandlePlaced(1, widgetState);
   }
-
   return numberOfPlacedHandles;
 }
 

package/Widgets/Widgets3D/LineWidget/state.js

@@ -1,8 +1,9 @@
 import vtkStateBuilder from '../../Core/StateBuilder.js';
 
+// make line position a sub-state so we can listen to it
 // separately from the rest of the widget state.
 
-var linePosState = vtkStateBuilder.createBuilder().addField({
+const linePosState = vtkStateBuilder.createBuilder().addField({
   name: 'posOnLine',
   initialValue: 0.5
 }).build();

package/Widgets/Widgets3D/LineWidget.js

@@ -1,6 +1,5 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import generateState from './LineWidget/state.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkArrowHandleRepresentation from '../Representations/ArrowHandleRepresentation.js';
@@ -11,21 +10,20 @@ import { Behavior } from '../Representations/WidgetRepresentation/Constants.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.js';
 import { getPoint, updateTextPosition } from './LineWidget/helpers.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 vtkLineWidget(publicAPI, model) {
   model.classHierarchy.push('vtkLineWidget');
+  const superClass = {
+    ...publicAPI
+  };
 
-  var superClass = _objectSpread({}, publicAPI); // --- Widget Requirement ---------------------------------------------------
-
+  // --- Widget Requirement ---------------------------------------------------
 
   model.methodsToLink = ['activeScaleFactor', 'activeColor', 'useActiveColor', 'glyphResolution', 'defaultScale', 'scaleInPixels'];
-
-  publicAPI.getRepresentationsForViewType = function (viewType) {
+  publicAPI.getRepresentationsForViewType = viewType => {
     switch (viewType) {
       case ViewTypes.DEFAULT:
       case ViewTypes.GEOMETRY:
@@ -115,65 +113,71 @@ function vtkLineWidget(publicAPI, model) {
           }
         }];
     }
-  }; // --- Public methods -------------------------------------------------------
+  };
 
+  // --- Public methods -------------------------------------------------------
 
-  publicAPI.getDistance = function () {
-    var p1 = getPoint(0, model.widgetState);
-    var p2 = getPoint(1, model.widgetState);
+  publicAPI.getDistance = () => {
+    const p1 = getPoint(0, model.widgetState);
+    const p2 = getPoint(1, model.widgetState);
     return p1 && p2 ? Math.sqrt(distance2BetweenPoints(p1, p2)) : 0;
   };
-
-  publicAPI.setManipulator = function (manipulator) {
+  publicAPI.setManipulator = manipulator => {
     superClass.setManipulator(manipulator);
     model.widgetState.getMoveHandle().setManipulator(manipulator);
     model.widgetState.getHandle1().setManipulator(manipulator);
     model.widgetState.getHandle2().setManipulator(manipulator);
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // initialization
   // --------------------------------------------------------------------------
 
   /**
    * TBD: Why setting the move handle ?
    */
-
-
-  model.widgetState.onBoundsChange(function (bounds) {
-    var center = [(bounds[0] + bounds[1]) * 0.5, (bounds[2] + bounds[3]) * 0.5, (bounds[4] + bounds[5]) * 0.5];
+  model.widgetState.onBoundsChange(bounds => {
+    const center = [(bounds[0] + bounds[1]) * 0.5, (bounds[2] + bounds[3]) * 0.5, (bounds[4] + bounds[5]) * 0.5];
     model.widgetState.getMoveHandle().setOrigin(center);
   });
-  model.widgetState.getPositionOnLine().onModified(function () {
+  model.widgetState.getPositionOnLine().onModified(() => {
     updateTextPosition(model);
-  }); // Default manipulator
+  });
 
+  // Default manipulator
   publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
     useCameraNormal: true
   }));
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
-var defaultValues = function defaultValues(initialValues) {
-  return _objectSpread({
-    // manipulator: null,
-    behavior: widgetBehavior,
-    widgetState: generateState()
-  }, initialValues);
-}; // ----------------------------------------------------------------------------
+const defaultValues = initialValues => ({
+  // manipulator: null,
+  behavior: widgetBehavior,
+  widgetState: 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);
   macro.setGet(publicAPI, model, ['manipulator']);
   vtkLineWidget(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkLineWidget'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkLineWidget');
+
+// ----------------------------------------------------------------------------
 
 var vtkLineWidget$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkLineWidget$1 as default, extend, newInstance };