@kitware/vtk.js 28.10.2 → 28.11.0

package/Widgets/Representations/ArrowHandleRepresentation.js

@@ -1,5 +1,4 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkArrow2DSource from '../../Filters/Sources/Arrow2DSource.js';
 import vtkGlyphRepresentation from './GlyphRepresentation.js';
@@ -16,257 +15,240 @@ import { RenderingTypes } from '../Core/WidgetManager/Constants.js';
 import { OrientationModes } from '../../Rendering/Core/Glyph3DMapper/Constants.js';
 import { allocateArray } from './WidgetRepresentation.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+const {
+  ShapeType,
+  Shapes2D,
+  ShapesOrientable
+} = Constants;
 
-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 ShapeType = Constants.ShapeType,
-    Shapes2D = Constants.Shapes2D,
-    ShapesOrientable = Constants.ShapesOrientable; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkArrowHandleRepresentation methods
 // ----------------------------------------------------------------------------
 
 function vtkArrowHandleRepresentation(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkArrowHandleRepresentation');
-
-  var superClass = _objectSpread({}, publicAPI); // --------------------------------------------------------------------------
+  const superClass = {
+    ...publicAPI
+  };
+  // --------------------------------------------------------------------------
   // Internal polydata dataset
   // --------------------------------------------------------------------------
 
   /**
    * Set the shape for the glyph according to lineWidget state inputs
    */
-
-
   function createGlyph(shape) {
-    var _representationToSour;
-
-    var representationToSource = (_representationToSour = {}, _defineProperty(_representationToSour, ShapeType.STAR, {
-      builder: vtkArrow2DSource,
-      initialValues: {
-        shape: 'star',
-        height: 0.6
-      }
-    }), _defineProperty(_representationToSour, ShapeType.ARROWHEAD3, {
-      builder: vtkArrow2DSource,
-      initialValues: {
-        shape: 'triangle'
-      }
-    }), _defineProperty(_representationToSour, ShapeType.ARROWHEAD4, {
-      builder: vtkArrow2DSource,
-      initialValues: {
-        shape: 'arrow4points'
-      }
-    }), _defineProperty(_representationToSour, ShapeType.ARROWHEAD6, {
-      builder: vtkArrow2DSource,
-      initialValues: {
-        shape: 'arrow6points'
-      }
-    }), _defineProperty(_representationToSour, ShapeType.CONE, {
-      builder: vtkConeSource,
-      initialValues: {
-        direction: [0, 1, 0]
-      }
-    }), _defineProperty(_representationToSour, ShapeType.SPHERE, {
-      builder: vtkSphereSource
-    }), _defineProperty(_representationToSour, ShapeType.CUBE, {
-      builder: vtkCubeSource,
-      initialValues: {
-        xLength: 0.8,
-        yLength: 0.8,
-        zLength: 0.8
-      }
-    }), _defineProperty(_representationToSour, ShapeType.DISK, {
-      builder: vtkCircleSource,
-      initialValues: {
-        resolution: 30,
-        radius: 0.5,
-        direction: [0, 0, 1],
-        lines: false,
-        face: true
-      }
-    }), _defineProperty(_representationToSour, ShapeType.CIRCLE, {
-      builder: vtkCircleSource,
-      initialValues: {
-        resolution: 30,
-        radius: 0.5,
-        direction: [0, 0, 1],
-        lines: true,
-        face: false
-      }
-    }), _defineProperty(_representationToSour, ShapeType.VIEWFINDER, {
-      builder: vtkViewFinderSource,
-      initialValues: {
-        radius: 0.1,
-        spacing: 0.3,
-        width: 1.4
+    const representationToSource = {
+      [ShapeType.STAR]: {
+        builder: vtkArrow2DSource,
+        initialValues: {
+          shape: 'star',
+          height: 0.6
+        }
+      },
+      [ShapeType.ARROWHEAD3]: {
+        builder: vtkArrow2DSource,
+        initialValues: {
+          shape: 'triangle'
+        }
+      },
+      [ShapeType.ARROWHEAD4]: {
+        builder: vtkArrow2DSource,
+        initialValues: {
+          shape: 'arrow4points'
+        }
+      },
+      [ShapeType.ARROWHEAD6]: {
+        builder: vtkArrow2DSource,
+        initialValues: {
+          shape: 'arrow6points'
+        }
+      },
+      [ShapeType.CONE]: {
+        builder: vtkConeSource,
+        initialValues: {
+          direction: [0, 1, 0]
+        }
+      },
+      [ShapeType.SPHERE]: {
+        builder: vtkSphereSource
+      },
+      [ShapeType.CUBE]: {
+        builder: vtkCubeSource,
+        initialValues: {
+          xLength: 0.8,
+          yLength: 0.8,
+          zLength: 0.8
+        }
+      },
+      [ShapeType.DISK]: {
+        builder: vtkCircleSource,
+        initialValues: {
+          resolution: 30,
+          radius: 0.5,
+          direction: [0, 0, 1],
+          lines: false,
+          face: true
+        }
+      },
+      [ShapeType.CIRCLE]: {
+        builder: vtkCircleSource,
+        initialValues: {
+          resolution: 30,
+          radius: 0.5,
+          direction: [0, 0, 1],
+          lines: true,
+          face: false
+        }
+      },
+      [ShapeType.VIEWFINDER]: {
+        builder: vtkViewFinderSource,
+        initialValues: {
+          radius: 0.1,
+          spacing: 0.3,
+          width: 1.4
+        }
+      },
+      [ShapeType.NONE]: {
+        builder: vtkSphereSource
       }
-    }), _defineProperty(_representationToSour, ShapeType.NONE, {
-      builder: vtkSphereSource
-    }), _representationToSour);
-    var rep = representationToSource[shape];
+    };
+    const rep = representationToSource[shape];
     return rep.builder.newInstance(rep.initialValues);
-  } // --------------------------------------------------------------------------
+  }
+
+  // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
+
   // displayActors and displayMappers are used to render objects in HTML,
   // allowing objects to be 'rendered' internally in a VTK scene without
   // being visible on the final output.
-
-
   model.displayMapper = vtkPixelSpaceCallbackMapper.newInstance();
   model.displayActor = vtkActor.newInstance({
     parentProp: publicAPI
-  }); // model.displayActor.getProperty().setOpacity(0); // don't show in 3D
-
+  });
+  // model.displayActor.getProperty().setOpacity(0); // don't show in 3D
   model.displayActor.setMapper(model.displayMapper);
   model.displayMapper.setInputConnection(publicAPI.getOutputPort());
   publicAPI.addActor(model.displayActor);
-  model.alwaysVisibleActors = [model.displayActor]; // --------------------------------------------------------------------------
+  model.alwaysVisibleActors = [model.displayActor];
+
+  // --------------------------------------------------------------------------
 
-  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, function (r) {
-    return model._pipeline.glyph.setPhiResolution(r);
-  }, function (r) {
-    return model._pipeline.glyph.setThetaResolution(r);
-  }); // --------------------------------------------------------------------------
+  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, r => model._pipeline.glyph.setPhiResolution(r), r => model._pipeline.glyph.setThetaResolution(r));
+
+  // --------------------------------------------------------------------------
 
   function callbackProxy(coords) {
     if (model.displayCallback) {
-      var filteredList = [];
-      var states = publicAPI.getRepresentationStates();
-
-      for (var i = 0; i < states.length; i++) {
+      const filteredList = [];
+      const states = publicAPI.getRepresentationStates();
+      for (let i = 0; i < states.length; i++) {
         if (states[i].getActive()) {
           filteredList.push(coords[i]);
         }
       }
-
       if (filteredList.length) {
         model.displayCallback(filteredList);
         return;
       }
     }
-
     model.displayCallback();
   }
-
-  publicAPI.setDisplayCallback = function (callback) {
+  publicAPI.setDisplayCallback = callback => {
     model.displayCallback = callback;
     model.displayMapper.setCallback(callback ? callbackProxy : null);
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.is2DShape = function () {
-    return Shapes2D.includes(model.shape);
-  };
+  publicAPI.is2DShape = () => Shapes2D.includes(model.shape);
+  publicAPI.isOrientableShape = () => ShapesOrientable.includes(model.shape);
 
-  publicAPI.isOrientableShape = function () {
-    return ShapesOrientable.includes(model.shape);
-  };
   /**
    * Returns the orientation matrix to align glyph on model.orientation.
    * */
-
-
   function getOrientationRotation(viewMatrixInv) {
-    var displayOrientation = new Float64Array(3);
-    var baseDir = [0, 1, 0];
+    const displayOrientation = new Float64Array(3);
+    const baseDir = [0, 1, 0];
     vec3.transformMat3(displayOrientation, model.orientation, viewMatrixInv);
     displayOrientation[2] = 0;
-    var displayMatrix = vtkMatrixBuilder.buildFromDegree().rotateFromDirections(baseDir, displayOrientation).getMatrix();
-    var displayRotation = new Float64Array(9);
+    const displayMatrix = vtkMatrixBuilder.buildFromDegree().rotateFromDirections(baseDir, displayOrientation).getMatrix();
+    const displayRotation = new Float64Array(9);
     mat3.fromMat4(displayRotation, displayMatrix);
     return displayRotation;
   }
-
   function getCameraFacingRotation(scale3, displayRotation, viewMatrix) {
-    var rotation = new Float64Array(9);
+    const rotation = new Float64Array(9);
     mat3.multiply(rotation, viewMatrix, displayRotation);
     vec3.transformMat3(scale3, scale3, rotation);
     return rotation;
   }
+
   /**
    * Computes the rotation matrix of the glyph. There are 2 rotations:
    *  - a first rotation to be oriented along model.rotation
    *  - an optional second rotation to face the camera
    * @param {vec3} scale3 Scale of the glyph, rotated when glyph is rotated.
    */
-
-
   function getGlyphRotation(scale3) {
-    var shouldFaceCamera = model.faceCamera === true || model.faceCamera == null && publicAPI.is2DShape();
-    var viewMatrix = new Float64Array(9);
+    const shouldFaceCamera = model.faceCamera === true || model.faceCamera == null && publicAPI.is2DShape();
+    const viewMatrix = new Float64Array(9);
     mat3.fromMat4(viewMatrix, model.viewMatrix);
-    var viewMatrixInv = mat3.identity(new Float64Array(9));
-
+    const viewMatrixInv = mat3.identity(new Float64Array(9));
     if (shouldFaceCamera) {
       mat3.invert(viewMatrixInv, viewMatrix);
     }
-
-    var orientationRotation = null;
-
+    let orientationRotation = null;
     if (publicAPI.isOrientableShape()) {
       orientationRotation = getOrientationRotation(viewMatrixInv);
     } else {
       orientationRotation = mat3.identity(new Float64Array(9));
     }
-
     if (shouldFaceCamera) {
       orientationRotation = getCameraFacingRotation(scale3, orientationRotation, viewMatrix);
     }
-
     return orientationRotation;
   }
-
   function applyOrientation(polyData, states) {
     model._pipeline.mapper.setOrientationArray('orientation');
-
     model._pipeline.mapper.setOrientationMode(OrientationModes.MATRIX);
-
-    var orientation = allocateArray(polyData, 'orientation', states.length, 'Float32Array', 9).getData();
-    var defaultScale3 = [1, 1, 1];
-
-    for (var i = 0; i < states.length; ++i) {
-      var _states$i$getScale, _states$i$getScale2, _states$i;
-
-      var scale3 = (_states$i$getScale = (_states$i$getScale2 = (_states$i = states[i]).getScale3) === null || _states$i$getScale2 === void 0 ? void 0 : _states$i$getScale2.call(_states$i)) !== null && _states$i$getScale !== void 0 ? _states$i$getScale : defaultScale3;
-      var rotation = getGlyphRotation(scale3);
+    const orientation = allocateArray(polyData, 'orientation', states.length, 'Float32Array', 9).getData();
+    const defaultScale3 = [1, 1, 1];
+    for (let i = 0; i < states.length; ++i) {
+      const scale3 = states[i].getScale3?.() ?? defaultScale3;
+      const rotation = getGlyphRotation(scale3);
       orientation.set(rotation, 9 * i);
     }
   }
-
   publicAPI.setDirection(applyOrientation);
   publicAPI.setNoOrientation(applyOrientation);
-
-  publicAPI.requestData = function (inData, outData) {
-    var _publicAPI$getReprese;
-
+  publicAPI.requestData = (inData, outData) => {
     // FIXME: shape should NOT be mixin, but a representation property.
-    var shape = (_publicAPI$getReprese = publicAPI.getRepresentationStates(inData[0])[0]) === null || _publicAPI$getReprese === void 0 ? void 0 : _publicAPI$getReprese.getShape();
-    var shouldCreateGlyph = model._pipeline.glyph == null;
-
+    const shape = publicAPI.getRepresentationStates(inData[0])[0]?.getShape();
+    let shouldCreateGlyph = model._pipeline.glyph == null;
     if (model.shape !== shape && Object.values(ShapeType).includes(shape)) {
       model.shape = shape;
       shouldCreateGlyph = true;
     }
-
     if (shouldCreateGlyph && model.shape) {
       model._pipeline.glyph = createGlyph(model.shape);
-
       model._pipeline.mapper.setInputConnection(model._pipeline.glyph.getOutputPort(), 1);
     }
-
     return superClass.requestData(inData, outData);
   };
-
   publicAPI.updateActorVisibility = function () {
-    var renderingType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : RenderingTypes.FRONT_BUFFER;
-    var ctxVisible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    var handleVisible = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-    var hasValidState = publicAPI.getRepresentationStates().length > 0;
+    let renderingType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : RenderingTypes.FRONT_BUFFER;
+    let ctxVisible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    let handleVisible = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    const hasValidState = publicAPI.getRepresentationStates().length > 0;
     superClass.updateActorVisibility(renderingType, ctxVisible, handleVisible && hasValidState);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
@@ -278,35 +260,39 @@ function vtkArrowHandleRepresentation(publicAPI, model) {
  *    - true to face camera
  *    - false to not face camera
  */
-
-
 function defaultValues(initialValues) {
-  return _objectSpread({
+  return {
     faceCamera: null,
     orientation: [1, 0, 0],
     shape: ShapeType.SPHERE,
-    viewMatrix: mat4.identity(new Float64Array(16))
-  }, initialValues);
-} // ----------------------------------------------------------------------------
+    viewMatrix: mat4.identity(new Float64Array(16)),
+    ...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));
   vtkGlyphRepresentation.extend(publicAPI, model, initialValues);
   macro.setGetArray(publicAPI, model, ['visibilityFlagArray'], 2);
   macro.setGetArray(publicAPI, model, ['orientation'], 3);
   macro.setGetArray(publicAPI, model, ['viewMatrix'], 16);
-  macro.setGet(publicAPI, model, ['faceCamera']); // Object specific methods
-
+  macro.setGet(publicAPI, model, ['faceCamera']);
+  // Object specific methods
   vtkArrowHandleRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkArrowHandleRepresentation'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkArrowHandleRepresentation');
+
+// ----------------------------------------------------------------------------
 
 var vtkArrowHandleRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkArrowHandleRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations/CircleContextRepresentation.js

@@ -1,82 +1,88 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCircleSource from '../../Filters/Sources/CircleSource.js';
 import vtkGlyphRepresentation from './GlyphRepresentation.js';
 import { Behavior } from './WidgetRepresentation/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; }
+// ----------------------------------------------------------------------------
 // vtkCircleContextRepresentation methods
 // ----------------------------------------------------------------------------
 
 function vtkCircleContextRepresentation(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkCircleContextRepresentation'); // --------------------------------------------------------------------------
+  model.classHierarchy.push('vtkCircleContextRepresentation');
+
+  // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 
   model._pipeline.actor.getProperty().setOpacity(0.2);
-
   model._pipeline.mapper.setResolveCoincidentTopology(true);
+  model._pipeline.mapper.setRelativeCoincidentTopologyPolygonOffsetParameters(-1, -1);
 
-  model._pipeline.mapper.setRelativeCoincidentTopologyPolygonOffsetParameters(-1, -1); // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
 
+  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, model._pipeline.glyph.setResolution);
 
-  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, model._pipeline.glyph.setResolution); // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
+
+  publicAPI.setDrawBorder = macro.chain(publicAPI.setDrawBorder, draw => model._pipeline.glyph.setLines(draw));
 
-  publicAPI.setDrawBorder = macro.chain(publicAPI.setDrawBorder, function (draw) {
-    return model._pipeline.glyph.setLines(draw);
-  }); // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
 
-  publicAPI.setDrawFace = macro.chain(publicAPI.setDrawFace, function (draw) {
-    return model._pipeline.glyph.setFace(draw);
-  }); // --------------------------------------------------------------------------
+  publicAPI.setDrawFace = macro.chain(publicAPI.setDrawFace, draw => model._pipeline.glyph.setFace(draw));
+
+  // --------------------------------------------------------------------------
 
-  publicAPI.setOpacity = function (opacity) {
+  publicAPI.setOpacity = opacity => {
     model._pipeline.actor.getProperty().setOpacity(opacity);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
 function defaultValues(initialValues) {
-  var _initialValues$pipeli, _initialValues$pipeli2, _initialValues$glyphR, _initialValues$drawBo, _initialValues$drawFa;
-
-  return _objectSpread(_objectSpread({
+  return {
     behavior: Behavior.CONTEXT,
     glyphResolution: 32,
     drawBorder: false,
-    drawFace: true
-  }, initialValues), {}, {
-    _pipeline: _objectSpread({
-      glyph: (_initialValues$pipeli = initialValues === null || initialValues === void 0 ? void 0 : (_initialValues$pipeli2 = initialValues.pipeline) === null || _initialValues$pipeli2 === void 0 ? void 0 : _initialValues$pipeli2.glyph) !== null && _initialValues$pipeli !== void 0 ? _initialValues$pipeli : vtkCircleSource.newInstance({
-        resolution: (_initialValues$glyphR = initialValues.glyphResolution) !== null && _initialValues$glyphR !== void 0 ? _initialValues$glyphR : 32,
+    drawFace: true,
+    ...initialValues,
+    _pipeline: {
+      glyph: initialValues?.pipeline?.glyph ?? vtkCircleSource.newInstance({
+        resolution: initialValues.glyphResolution ?? 32,
         radius: 1,
-        lines: (_initialValues$drawBo = initialValues.drawBorder) !== null && _initialValues$drawBo !== void 0 ? _initialValues$drawBo : false,
-        face: (_initialValues$drawFa = initialValues.drawFace) !== null && _initialValues$drawFa !== void 0 ? _initialValues$drawFa : true,
+        lines: initialValues.drawBorder ?? false,
+        face: initialValues.drawFace ?? true,
         direction: [0, 0, 1]
-      })
-    }, initialValues === null || initialValues === void 0 ? void 0 : initialValues.pipeline)
-  });
-} // ----------------------------------------------------------------------------
+      }),
+      ...initialValues?.pipeline
+    }
+  };
+}
 
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   vtkGlyphRepresentation.extend(publicAPI, model, defaultValues(initialValues));
   macro.setGet(publicAPI, model, ['glyphResolution', 'drawFace', 'drawBorder']);
-  macro.get(publicAPI, model._pipeline, ['glyph', 'mapper', 'actor']); // Object specific methods
+  macro.get(publicAPI, model._pipeline, ['glyph', 'mapper', 'actor']);
 
+  // Object specific methods
   vtkCircleContextRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkCircleContextRepresentation'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkCircleContextRepresentation');
+
+// ----------------------------------------------------------------------------
 
 var vtkCircleContextRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkCircleContextRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations/ContextRepresentation.js

@@ -1,37 +1,40 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import vtkWidgetRepresentation from './WidgetRepresentation.js';
 import { Behavior } from './WidgetRepresentation/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; }
+// ----------------------------------------------------------------------------
 // vtkWidgetRepresentation
 // ----------------------------------------------------------------------------
 
 function vtkContextRepresentation(publicAPI, model) {
   model.classHierarchy.push('vtkContextRepresentation');
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   behavior: Behavior.CONTEXT,
   pickable: false,
   dragable: true
-}; // ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+};
 
-  var newDefault = _objectSpread(_objectSpread({}, DEFAULT_VALUES), initialValues);
+// ----------------------------------------------------------------------------
 
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const newDefault = {
+    ...DEFAULT_VALUES,
+    ...initialValues
+  };
   vtkWidgetRepresentation.extend(publicAPI, model, newDefault);
   vtkContextRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
 var vtkContextRepresentation$1 = {
-  extend: extend
+  extend
 };
 
 export { vtkContextRepresentation$1 as default, extend };