@kitware/vtk.js 28.10.1 → 28.11.0

package/Widgets/Representations/SplineContextRepresentation.js

@@ -1,5 +1,4 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkContextRepresentation from './ContextRepresentation.js';
 import vtkMapper from '../../Rendering/Core/Mapper.js';
@@ -9,12 +8,15 @@ import vtkTriangleFilter from '../../Filters/General/TriangleFilter.js';
 import vtkLineFilter from '../../Filters/General/LineFilter.js';
 import vtkWidgetRepresentation, { allocateArray } from './WidgetRepresentation.js';
 
+// ----------------------------------------------------------------------------
 // vtkSplineContextRepresentation methods
 // ----------------------------------------------------------------------------
 
 function vtkSplineContextRepresentation(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkSplineContextRepresentation'); // --------------------------------------------------------------------------
+  model.classHierarchy.push('vtkSplineContextRepresentation');
+
+  // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 
@@ -40,61 +42,40 @@ function vtkSplineContextRepresentation(publicAPI, model) {
     }
   };
   vtkWidgetRepresentation.connectPipeline(model._pipelines.area);
-
   model._pipelines.area.actor.getProperty().setOpacity(0.2);
-
   model._pipelines.area.actor.getProperty().setColor(0, 1, 0);
-
   publicAPI.addActor(model._pipelines.area.actor);
   vtkWidgetRepresentation.connectPipeline(model._pipelines.border);
-
   model._pipelines.border.actor.getProperty().setOpacity(1);
-
   model._pipelines.border.actor.getProperty().setColor(0.1, 1, 0.1);
-
   model._pipelines.border.actor.setVisibility(model.outputBorder);
+  publicAPI.addActor(model._pipelines.border.actor);
 
-  publicAPI.addActor(model._pipelines.border.actor); // --------------------------------------------------------------------------
-
-  var superGetRepresentationStates = publicAPI.getRepresentationStates;
-
+  // --------------------------------------------------------------------------
+  const superGetRepresentationStates = publicAPI.getRepresentationStates;
   publicAPI.getRepresentationStates = function () {
-    var input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : model.inputData[0];
-    return superGetRepresentationStates(input).filter(function (state) {
-      var _state$getOrigin, _state$isVisible;
-
-      return ((_state$getOrigin = state.getOrigin) === null || _state$getOrigin === void 0 ? void 0 : _state$getOrigin.call(state)) && ((_state$isVisible = state.isVisible) === null || _state$isVisible === void 0 ? void 0 : _state$isVisible.call(state));
-    });
+    let input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : model.inputData[0];
+    return superGetRepresentationStates(input).filter(state => state.getOrigin?.() && state.isVisible?.());
   };
-
-  publicAPI.requestData = function (inData, outData) {
-    var _model$_pipelines$bor;
-
+  publicAPI.requestData = (inData, outData) => {
     if (model.deleted) {
       return;
     }
-
-    var widgetState = inData[0];
-    var closed = widgetState.getSplineClosed();
-    var list = publicAPI.getRepresentationStates(widgetState);
-    var inPoints = list.map(function (state) {
-      return state.getOrigin();
-    });
-
+    const widgetState = inData[0];
+    const closed = widgetState.getSplineClosed();
+    const list = publicAPI.getRepresentationStates(widgetState);
+    const inPoints = list.map(state => state.getOrigin());
     if (inPoints.length <= 1) {
       outData[0] = model.internalPolyData;
       return;
     }
-
-    var numVertices = inPoints.length;
-
+    let numVertices = inPoints.length;
     if (!closed) {
       --numVertices;
     } else {
       inPoints.push(inPoints[0]);
     }
-
-    var spline = vtkSpline3D.newInstance({
+    const spline = vtkSpline3D.newInstance({
       close: widgetState.getSplineClosed(),
       kind: widgetState.getSplineKind(),
       tension: widgetState.getSplineTension(),
@@ -104,88 +85,83 @@ function vtkSplineContextRepresentation(publicAPI, model) {
       boundaryConditionValues: widgetState.getSplineBoundaryConditionValues()
     });
     spline.computeCoefficients(inPoints);
-    var outPoints = allocateArray(model.internalPolyData, 'points', (numVertices + !closed) * model.resolution).getData();
-    var outCells = new Uint32Array(numVertices * model.resolution + 2);
+    const outPoints = allocateArray(model.internalPolyData, 'points', (numVertices + !closed) * model.resolution).getData();
+    const outCells = new Uint32Array(numVertices * model.resolution + 2);
     outCells[0] = numVertices * model.resolution + 1;
     outCells[numVertices * model.resolution + 1] = 0;
-
-    for (var i = 0; i < numVertices; i++) {
-      for (var j = 0; j < model.resolution; j++) {
-        var t = j / model.resolution;
-        var point = spline.getPoint(i, t);
+    for (let i = 0; i < numVertices; i++) {
+      for (let j = 0; j < model.resolution; j++) {
+        const t = j / model.resolution;
+        const point = spline.getPoint(i, t);
         outPoints[3 * (i * model.resolution + j) + 0] = point[0];
         outPoints[3 * (i * model.resolution + j) + 1] = point[1];
         outPoints[3 * (i * model.resolution + j) + 2] = point[2];
         outCells[i * model.resolution + j + 1] = i * model.resolution + j;
       }
     }
-
     if (closed) {
       outCells[numVertices * model.resolution + 1] = 0;
     } else {
-      var lastPointIndex = numVertices * model.resolution + 1;
-      var lastPoint = spline.getPoint(numVertices, 0);
+      const lastPointIndex = numVertices * model.resolution + 1;
+      const lastPoint = spline.getPoint(numVertices, 0);
       outPoints[3 * lastPointIndex + 0] = lastPoint[0];
       outPoints[3 * lastPointIndex + 1] = lastPoint[1];
       outPoints[3 * lastPointIndex + 2] = lastPoint[2];
       outCells[numVertices * model.resolution + 1] = lastPointIndex;
     }
-
     if (model.fill) {
       model.internalPolyData.getPolys().setData(outCells);
     }
-
     model.internalPolyData.getLines().setData(model.outputBorder ? outCells : []);
     model.internalPolyData.modified();
     outData[0] = model.internalPolyData;
-
     model._pipelines.area.filter.update();
-
-    (_model$_pipelines$bor = model._pipelines.border.actor.getProperty()).setColor.apply(_model$_pipelines$bor, _toConsumableArray(inPoints.length <= 3 || model._pipelines.area.filter.getErrorCount() === 0 ? model.borderColor : model.errorBorderColor));
+    model._pipelines.border.actor.getProperty().setColor(...(inPoints.length <= 3 || model._pipelines.area.filter.getErrorCount() === 0 ? model.borderColor : model.errorBorderColor));
   };
-
-  publicAPI.getSelectedState = function (prop, compositeID) {
-    return model.state;
-  };
-
+  publicAPI.getSelectedState = (prop, compositeID) => model.state;
   function updateAreaVisibility() {
     model._pipelines.area.actor.setVisibility(model.fill);
   }
-
   publicAPI.setFill = macro.chain(publicAPI.setFill, updateAreaVisibility);
-  publicAPI.setOutputBorder = macro.chain(publicAPI.setOutputBorder, function (v) {
-    return model._pipelines.border.actor.setVisibility(v);
-  });
-} // ----------------------------------------------------------------------------
+  publicAPI.setOutputBorder = macro.chain(publicAPI.setOutputBorder, v => model._pipelines.border.actor.setVisibility(v));
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   resolution: 16,
   fill: true,
   // boundaryCondition : BoundaryCondition.DEFAULT
   outputBorder: false,
   borderColor: [0.1, 1, 0.1],
   errorBorderColor: [1, 0, 0]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, DEFAULT_VALUES, initialValues);
   vtkContextRepresentation.extend(publicAPI, model, initialValues);
   macro.get(publicAPI, model, ['mapper']);
   macro.setGet(publicAPI, model, ['resolution', 'boundaryCondition', 'fill', 'outputBorder']);
-  macro.setGetArray(publicAPI, model, ['borderColor', 'errorBorderColor'], 3); // Object specific methods
+  macro.setGetArray(publicAPI, model, ['borderColor', 'errorBorderColor'], 3);
 
+  // Object specific methods
   vtkSplineContextRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkSplineContextRepresentation'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkSplineContextRepresentation');
+
+// ----------------------------------------------------------------------------
 
 var vtkSplineContextRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkSplineContextRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations/WidgetRepresentation/Constants.js

@@ -1,9 +1,9 @@
-var Behavior = {
+const Behavior = {
   HANDLE: 0,
   CONTEXT: 1
 };
 var Constants = {
-  Behavior: Behavior
+  Behavior
 };
 
 export { Behavior, Constants as default };

package/Widgets/Representations/WidgetRepresentation.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 vtkProp from '../../Rendering/Core/Prop.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
@@ -9,97 +8,89 @@ import { RenderingTypes } from '../Core/WidgetManager/Constants.js';
 import { CATEGORIES } from '../../Rendering/Core/Mapper/CoincidentTopologyHelper.js';
 import { POLYDATA_FIELDS } from '../../Common/DataModel/PolyData/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; }
-var vtkErrorMacro = macro.vtkErrorMacro,
-    vtkWarningMacro = macro.vtkWarningMacro; // ----------------------------------------------------------------------------
-
-var STYLE_CATEGORIES = ['active', 'inactive', 'static'];
+const {
+  vtkErrorMacro,
+  vtkWarningMacro
+} = macro;
 
+// ----------------------------------------------------------------------------
+const STYLE_CATEGORIES = ['active', 'inactive', 'static'];
 function applyCoincidentTopologyParametersToMapper(mapper, parameters) {
   if (mapper && mapper.setResolveCoincidentTopologyToPolygonOffset) {
     mapper.setResolveCoincidentTopologyToPolygonOffset();
-    CATEGORIES.forEach(function (category) {
+    CATEGORIES.forEach(category => {
       if (parameters[category]) {
-        var methodName = "setRelativeCoincidentTopology".concat(category, "OffsetParameters");
-
+        const methodName = `setRelativeCoincidentTopology${category}OffsetParameters`;
         if (mapper[methodName]) {
-          var _parameters$category = parameters[category],
-              factor = _parameters$category.factor,
-              offset = _parameters$category.offset;
+          const {
+            factor,
+            offset
+          } = parameters[category];
           mapper[methodName](factor, offset);
         }
       }
     });
   }
 }
-
 function mergeStyles(elementNames) {
   for (var _len = arguments.length, stylesToMerge = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
     stylesToMerge[_key - 1] = arguments[_key];
   }
-
-  var newStyleObject = {
+  const newStyleObject = {
     active: {},
     inactive: {},
     static: {}
   };
-  STYLE_CATEGORIES.forEach(function (category) {
-    var cat = newStyleObject[category];
-    elementNames.forEach(function (name) {
+  STYLE_CATEGORIES.forEach(category => {
+    const cat = newStyleObject[category];
+    elementNames.forEach(name => {
       if (!cat[name]) {
         cat[name] = {};
       }
-
-      stylesToMerge.filter(function (s) {
-        return s && s[category] && s[category][name];
-      }).forEach(function (s) {
-        return Object.assign(cat[name], s[category][name]);
-      });
+      stylesToMerge.filter(s => s && s[category] && s[category][name]).forEach(s => Object.assign(cat[name], s[category][name]));
     });
   });
   return newStyleObject;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
 function applyStyles(pipelines, styles, activeActor) {
   if (!activeActor) {
     // static
-    Object.keys(styles.static).forEach(function (name) {
+    Object.keys(styles.static).forEach(name => {
       if (pipelines[name]) {
         pipelines[name].actor.getProperty().set(styles.static[name]);
       }
-    }); // inactive
-
-    Object.keys(styles.inactive).forEach(function (name) {
+    });
+    // inactive
+    Object.keys(styles.inactive).forEach(name => {
       if (pipelines[name]) {
         pipelines[name].actor.getProperty().set(styles.inactive[name]);
       }
     });
   } else {
-    Object.keys(pipelines).forEach(function (name) {
-      var style = pipelines[name].actor === activeActor ? styles.active[name] : styles.inactive[name];
-
+    Object.keys(pipelines).forEach(name => {
+      const style = pipelines[name].actor === activeActor ? styles.active[name] : styles.inactive[name];
       if (style) {
         pipelines[name].actor.getProperty().set(style);
       }
     });
   }
-} // ----------------------------------------------------------------------------
+}
 
-function connectPipeline(pipeline) {
-  var source = pipeline.source;
+// ----------------------------------------------------------------------------
 
+function connectPipeline(pipeline) {
+  let source = pipeline.source;
   if (pipeline.filter) {
     if (source.isA('vtkDataSet')) {
       pipeline.filter.setInputData(source);
     } else {
       pipeline.filter.setInputConnection(source.getOutputPort());
     }
-
     source = pipeline.filter;
   }
-
   if (source) {
     if (source.isA('vtkDataSet')) {
       pipeline.mapper.setInputData(source);
@@ -107,196 +98,165 @@ function connectPipeline(pipeline) {
       pipeline.mapper.setInputConnection(source.getOutputPort());
     }
   }
-
   if (pipeline.glyph) {
     pipeline.mapper.setInputConnection(pipeline.glyph.getOutputPort(), 1);
   }
-
   pipeline.actor.setMapper(pipeline.mapper);
-} // Internal convenient function to create a data array:
+}
 
+// Internal convenient function to create a data array:
 function allocateArray(polyData, name, numberOfTuples, dataType, numberOfComponents) {
-  var _polyData$;
-
   // Check first whether name is points, verts, lines, polys, otherwise it is a point data array.
-  var dataArray = ((_polyData$ = polyData["get".concat(macro.capitalize(name))]) === null || _polyData$ === void 0 ? void 0 : _polyData$.call(polyData)) || polyData.getPointData().getArrayByName(name);
-
+  let dataArray = polyData[`get${macro.capitalize(name)}`]?.() || polyData.getPointData().getArrayByName(name);
   if (!dataArray || dataType !== undefined && dataArray.getDataType() !== dataType || numberOfComponents !== undefined && dataArray.getNumberOfComponents() !== numberOfComponents) {
-    var arrayType = vtkDataArray;
-    var arrayDataType = dataType;
-    var arrayNumberOfComponents = numberOfComponents;
-
+    let arrayType = vtkDataArray;
+    let arrayDataType = dataType;
+    let arrayNumberOfComponents = numberOfComponents;
     if (name === 'points') {
-      var _arrayDataType;
-
       arrayType = vtkPoints;
-      arrayDataType = (_arrayDataType = arrayDataType) !== null && _arrayDataType !== void 0 ? _arrayDataType : 'Float32Array';
-      arrayNumberOfComponents = numberOfComponents !== null && numberOfComponents !== void 0 ? numberOfComponents : 3;
+      arrayDataType = arrayDataType ?? 'Float32Array';
+      arrayNumberOfComponents = numberOfComponents ?? 3;
     } else if (POLYDATA_FIELDS.includes(name)) {
-      var _arrayDataType2;
-
       arrayType = vtkCellArray;
-      arrayDataType = (_arrayDataType2 = arrayDataType) !== null && _arrayDataType2 !== void 0 ? _arrayDataType2 : 'Uint16Array';
-      arrayNumberOfComponents = numberOfComponents !== null && numberOfComponents !== void 0 ? numberOfComponents : 1;
+      arrayDataType = arrayDataType ?? 'Uint16Array';
+      arrayNumberOfComponents = numberOfComponents ?? 1;
     } else {
-      var _arrayDataType3;
-
       // data array
-      arrayDataType = (_arrayDataType3 = arrayDataType) !== null && _arrayDataType3 !== void 0 ? _arrayDataType3 : 'Float32Array';
-      arrayNumberOfComponents = numberOfComponents !== null && numberOfComponents !== void 0 ? numberOfComponents : 1;
+      arrayDataType = arrayDataType ?? 'Float32Array';
+      arrayNumberOfComponents = numberOfComponents ?? 1;
     }
-
     dataArray = arrayType.newInstance({
-      name: name,
+      name,
       dataType: arrayDataType,
       numberOfComponents: arrayNumberOfComponents,
       size: arrayNumberOfComponents * numberOfTuples,
       empty: numberOfTuples === 0
     });
-
     if (name === 'points' || POLYDATA_FIELDS.includes(name)) {
-      polyData["set".concat(macro.capitalize(name))](dataArray);
+      polyData[`set${macro.capitalize(name)}`](dataArray);
     } else {
       polyData.getPointData().addArray(dataArray);
     }
   } else if (dataArray.getNumberOfTuples() !== numberOfTuples) {
     dataArray.resize(numberOfTuples);
   }
-
   return dataArray;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkWidgetRepresentation
 // ----------------------------------------------------------------------------
 
 function vtkWidgetRepresentation(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkWidgetRepresentation'); // Internal cache
+  model.classHierarchy.push('vtkWidgetRepresentation');
 
-  var cache = {
+  // Internal cache
+  const cache = {
     mtimes: {},
     states: []
   };
-
-  model._onCoincidentTopologyParametersChanged = function () {
-    publicAPI.getActors().forEach(function (actor) {
+  model._onCoincidentTopologyParametersChanged = () => {
+    publicAPI.getActors().forEach(actor => {
       applyCoincidentTopologyParametersToMapper(actor.getMapper(), model.coincidentTopologyParameters);
     });
-  }; // --------------------------------------------------------------------------
-
-
-  publicAPI.getActors = function () {
-    return model.actors;
   };
 
-  publicAPI.getNestedProps = publicAPI.getActors; // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
+  publicAPI.getActors = () => model.actors;
+  publicAPI.getNestedProps = publicAPI.getActors;
+  // --------------------------------------------------------------------------
 
   publicAPI.setLabels = function () {
     for (var _len2 = arguments.length, labels = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
       labels[_key2] = arguments[_key2];
     }
-
     if (labels.length === 1) {
       model.labels = [].concat(labels[0]);
     } else {
       model.labels = labels;
     }
-
     publicAPI.modified();
   };
-
   publicAPI.getRepresentationStates = function () {
-    var input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : model.inputData[0];
-
+    let input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : model.inputData[0];
     if (cache.mtimes.representation === publicAPI.getMTime() && cache.mtimes.input === input.getMTime()) {
       return cache.states;
-    } // Reinitialize cache
-
+    }
 
+    // Reinitialize cache
     cache.mtimes.representation = publicAPI.getMTime();
     cache.mtimes.input = input.getMTime();
-    cache.states = []; // Fill states that are going to be used in the representation
+    cache.states = [];
 
-    model.labels.forEach(function (name) {
+    // Fill states that are going to be used in the representation
+    model.labels.forEach(name => {
       cache.states = cache.states.concat(input.getStatesWithLabel(name) || []);
     });
     return cache.states;
   };
-
-  publicAPI.getSelectedState = function (prop, compositeID) {
-    var representationStates = publicAPI.getRepresentationStates();
-
+  publicAPI.getSelectedState = (prop, compositeID) => {
+    const representationStates = publicAPI.getRepresentationStates();
     if (compositeID < representationStates.length) {
       return representationStates[compositeID];
     }
-
-    vtkErrorMacro("Representation ".concat(publicAPI.getClassName(), " should implement getSelectedState(prop, compositeID) method."));
+    vtkErrorMacro(`Representation ${publicAPI.getClassName()} should implement getSelectedState(prop, compositeID) method.`);
     return null;
   };
-
   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 otherFlag = true;
-
+    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;
+    let otherFlag = true;
     switch (model.behavior) {
       case Behavior.HANDLE:
         otherFlag = renderingType === RenderingTypes.PICKING_BUFFER || handleVisible;
         break;
-
       case Behavior.CONTEXT:
         otherFlag = ctxVisible;
         break;
-
       default:
         otherFlag = true;
         break;
     }
-
-    var visibilityFlag = otherFlag;
-
-    for (var i = 0; i < model.actors.length; i++) {
+    const visibilityFlag = otherFlag;
+    for (let i = 0; i < model.actors.length; i++) {
       if (model.visibilityFlagArray) {
         model.actors[i].setVisibility(visibilityFlag && model.visibilityFlagArray[i]);
       } else {
         model.actors[i].setVisibility(visibilityFlag);
       }
     }
-
     if (model.alwaysVisibleActors) {
-      for (var _i = 0; _i < model.alwaysVisibleActors.length; _i++) {
-        model.alwaysVisibleActors[_i].setVisibility(true);
+      for (let i = 0; i < model.alwaysVisibleActors.length; i++) {
+        model.alwaysVisibleActors[i].setVisibility(true);
       }
     }
-  }; // Add warning to model.actors.push
-
+  };
 
+  // Add warning to model.actors.push
   model.actors.push = function () {
     vtkWarningMacro('You should use publicAPI.addActor() to initialize the actor properly');
-
     for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
       args[_key3] = arguments[_key3];
     }
-
-    args.forEach(function (actor) {
-      return publicAPI.addActor(actor);
-    });
+    args.forEach(actor => publicAPI.addActor(actor));
   };
-
-  publicAPI.addActor = function (actor) {
+  publicAPI.addActor = actor => {
     applyCoincidentTopologyParametersToMapper(actor.getMapper(), model.coincidentTopologyParameters);
     Array.prototype.push.apply(model.actors, [actor]);
-  }; // Make sure setting the labels at build time works with string/array...
-
+  };
 
+  // Make sure setting the labels at build time works with string/array...
   publicAPI.setLabels(model.labels);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
 function defaultValues(initialValues) {
-  return _objectSpread({
+  return {
     activeScaleFactor: 1.2,
     activeColor: 1,
     useActiveColor: true,
@@ -325,13 +285,15 @@ function defaultValues(initialValues) {
       isParallel: false,
       rendererPixelDims: [1, 1]
     },
-    _internalArrays: {}
-  }, initialValues);
-} // ----------------------------------------------------------------------------
+    _internalArrays: {},
+    ...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 methods
   vtkProp.extend(publicAPI, model, defaultValues(initialValues));
   macro.algo(publicAPI, model, 1, 1);
@@ -343,16 +305,19 @@ function extend(publicAPI, model) {
     type: 'object',
     name: 'coincidentTopologyParameters'
   }]);
-  macro.setGet(publicAPI, model, ['scaleInPixels', 'activeScaleFactor', 'activeColor', 'useActiveColor']); // Object specific methods
+  macro.setGet(publicAPI, model, ['scaleInPixels', 'activeScaleFactor', 'activeColor', 'useActiveColor']);
 
+  // Object specific methods
   vtkWidgetRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
 var vtkWidgetRepresentation$1 = {
-  extend: extend,
-  mergeStyles: mergeStyles,
-  applyStyles: applyStyles,
-  connectPipeline: connectPipeline
+  extend,
+  mergeStyles,
+  applyStyles,
+  connectPipeline
 };
 
 export { allocateArray, applyStyles, connectPipeline, vtkWidgetRepresentation$1 as default, extend, mergeStyles };