@kitware/vtk.js 28.10.1 → 28.11.0

package/Proxy/Core.js

@@ -7,13 +7,13 @@ import vtkView2DProxy from './Core/View2DProxy.js';
 import vtkViewProxy from './Core/ViewProxy.js';
 
 var Core = {
-  vtkAbstractRepresentationProxy: vtkAbstractRepresentationProxy,
-  vtkLookupTableProxy: vtkLookupTableProxy,
-  vtkPiecewiseFunctionProxy: vtkPiecewiseFunctionProxy,
-  vtkProxyManager: vtkProxyManager,
-  vtkSourceProxy: vtkSourceProxy,
-  vtkView2DProxy: vtkView2DProxy,
-  vtkViewProxy: vtkViewProxy
+  vtkAbstractRepresentationProxy,
+  vtkLookupTableProxy,
+  vtkPiecewiseFunctionProxy,
+  vtkProxyManager,
+  vtkSourceProxy,
+  vtkView2DProxy,
+  vtkViewProxy
 };
 
 export { Core as default };

package/Proxy/Representations/GeometryRepresentationProxy.js

@@ -1,9 +1,9 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkMapper from '../../Rendering/Core/Mapper.js';
 import vtkAbstractRepresentationProxy from '../Core/AbstractRepresentationProxy.js';
 
-var PROPERTIES_STATE = {
+const PROPERTIES_STATE = {
   representation: {
     'Surface with edges': {
       property: {
@@ -31,45 +31,55 @@ var PROPERTIES_STATE = {
     }
   }
 };
-var PROPERTIES_DEFAULT = {
+const PROPERTIES_DEFAULT = {
   representation: 'Surface'
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 // vtkGeometryRepresentationProxy methods
 // ----------------------------------------------------------------------------
 
 function vtkGeometryRepresentationProxy(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkGeometryRepresentationProxy'); // Internals
+  model.classHierarchy.push('vtkGeometryRepresentationProxy');
 
+  // Internals
   model.mapper = vtkMapper.newInstance({
     interpolateScalarsBeforeMapping: true,
     useLookupTableScalarRange: true,
     scalarVisibility: false
   });
   model.actor = vtkActor.newInstance();
-  model.property = model.actor.getProperty(); // Auto connect mappers
-
-  model.sourceDependencies.push(model.mapper); // connect rendering pipeline
+  model.property = model.actor.getProperty();
 
+  // Auto connect mappers
+  model.sourceDependencies.push(model.mapper);
+  // connect rendering pipeline
   model.actor.setMapper(model.mapper);
   model.actors.push(model.actor);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   representation: 'Surface'
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  vtkAbstractRepresentationProxy.extend(publicAPI, model, initialValues); // Object specific methods
+  // Object methods
+  vtkAbstractRepresentationProxy.extend(publicAPI, model, initialValues);
 
-  vtkGeometryRepresentationProxy(publicAPI, model); // Map proxy properties
+  // Object specific methods
+  vtkGeometryRepresentationProxy(publicAPI, model);
 
+  // Map proxy properties
   macro.proxyPropertyState(publicAPI, model, PROPERTIES_STATE, PROPERTIES_DEFAULT);
   macro.proxyPropertyMapping(publicAPI, model, {
     opacity: {
@@ -105,13 +115,17 @@ function extend(publicAPI, model) {
       property: 'useBounds'
     }
   });
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkGeometryRepresentationProxy'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkGeometryRepresentationProxy');
+
+// ----------------------------------------------------------------------------
 
 var vtkGeometryRepresentationProxy$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkGeometryRepresentationProxy$1 as default, extend, newInstance };

package/Proxy/Representations/GlyphRepresentationProxy.js

@@ -1,4 +1,4 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtk from '../../vtk.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkProperty from '../../Rendering/Core/Property.js';
@@ -22,6 +22,7 @@ import '../../Filters/Sources/RTAnalyticSource.js';
 import '../../Filters/Sources/SLICSource.js';
 import '../../Filters/Sources/SphereSource.js';
 
+// ----------------------------------------------------------------------------
 // vtkGlyphRepresentationProxy methods
 // ----------------------------------------------------------------------------
 
@@ -29,32 +30,30 @@ function vtkGlyphRepresentationProxy(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkGlyphRepresentationProxy');
   model.property = vtkProperty.newInstance();
-
   function processJSON(description) {
-    model.actors.length = 0; // Handle colors
+    model.actors.length = 0;
 
-    var lookupTable = vtkColorTransferFunction.newInstance();
+    // Handle colors
+    const lookupTable = vtkColorTransferFunction.newInstance();
     lookupTable.applyColorMap({
       RGBPoints: description.rgbPoints
-    }); // Handle glyph
+    });
 
+    // Handle glyph
     model.glyph = {};
-    var count = description.glyph.length;
-
+    let count = description.glyph.length;
     while (count--) {
-      var glyph = description.glyph[count];
+      const glyph = description.glyph[count];
       model.glyph[glyph.id] = vtk(glyph);
-    } // Handle mapping
-
+    }
 
+    // Handle mapping
     count = description.mapping.length;
-
     while (count--) {
-      var sourceDesc = description.mapping[count];
-      var _glyph = model.glyph[sourceDesc.glyphId];
-      var source = vtkPolyData.newInstance();
+      const sourceDesc = description.mapping[count];
+      const glyph = model.glyph[sourceDesc.glyphId];
+      const source = vtkPolyData.newInstance();
       source.getPoints().setData(Float32Array.from(sourceDesc.coordinates), 3);
-
       if (sourceDesc.scale) {
         source.getPointData().addArray(vtkDataArray.newInstance({
           name: 'scaling',
@@ -62,57 +61,55 @@ function vtkGlyphRepresentationProxy(publicAPI, model) {
           numberOfComponents: 3
         }));
       }
-
-      var mapper = vtkGlyph3DMapper.newInstance({
+      const mapper = vtkGlyph3DMapper.newInstance({
         useLookupTableScalarRange: true,
-        lookupTable: lookupTable,
+        lookupTable,
         orient: false,
         scaling: !!sourceDesc.scale,
         scaleArray: 'scaling',
         scaleMode: vtkGlyph3DMapper.ScaleModes.SCALE_BY_COMPONENTS
       });
-      var actor = vtkActor.newInstance();
-
+      const actor = vtkActor.newInstance();
       if (model.property) {
         actor.setProperty(model.property);
       }
-
       actor.setMapper(mapper);
       mapper.setInputData(source, 0);
-      mapper.setInputConnection(_glyph.getOutputPort(), 1);
+      mapper.setInputConnection(glyph.getOutputPort(), 1);
       model.actors.push(actor);
     }
   }
-
   model.sourceDependencies.push({
     setInputData: processJSON
-  }); // Add actors
+  });
+
+  // Add actors
   // model.actors.push(model.sphereActor);
   // model.actors.push(model.stickActor);
-  // API ----------------------------------------------------------------------
 
-  publicAPI.setColorBy = function () {};
+  // API ----------------------------------------------------------------------
 
-  publicAPI.getColorBy = function () {
-    return [];
-  };
+  publicAPI.setColorBy = () => {};
+  publicAPI.getColorBy = () => [];
+  publicAPI.listDataArrays = () => [];
+}
 
-  publicAPI.listDataArrays = function () {
-    return [];
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  vtkAbstractRepresentationProxy.extend(publicAPI, model, initialValues); // Object specific methods
+  // Object methods
+  vtkAbstractRepresentationProxy.extend(publicAPI, model, initialValues);
 
+  // Object specific methods
   vtkGlyphRepresentationProxy(publicAPI, model);
   macro.proxyPropertyMapping(publicAPI, model, {
     edgeVisibility: {
@@ -120,13 +117,17 @@ function extend(publicAPI, model) {
       property: 'edgeVisibility'
     }
   });
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkGlyphRepresentationProxy'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkGlyphRepresentationProxy');
+
+// ----------------------------------------------------------------------------
 
 var vtkGlyphRepresentationProxy$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkGlyphRepresentationProxy$1 as default, extend, newInstance };

package/Proxy/Representations/MoleculeRepresentationProxy.js

@@ -1,58 +1,64 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkSphereMapper from '../../Rendering/Core/SphereMapper.js';
 import vtkStickMapper from '../../Rendering/Core/StickMapper.js';
 import vtkMoleculeToRepresentation from '../../Filters/General/MoleculeToRepresentation.js';
 import vtkAbstractRepresentationProxy from '../Core/AbstractRepresentationProxy.js';
 
+// ----------------------------------------------------------------------------
 // vtkMoleculeRepresentationProxy methods
 // ----------------------------------------------------------------------------
 
 function vtkMoleculeRepresentationProxy(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkMoleculeRepresentationProxy'); // Internals
+  model.classHierarchy.push('vtkMoleculeRepresentationProxy');
 
+  // Internals
   model.filter = vtkMoleculeToRepresentation.newInstance();
   model.sphereMapper = vtkSphereMapper.newInstance();
   model.stickMapper = vtkStickMapper.newInstance();
   model.sphereActor = vtkActor.newInstance();
   model.stickActor = vtkActor.newInstance();
-  model.sourceDependencies.push(model.filter); // render sphere
+  model.sourceDependencies.push(model.filter);
 
+  // render sphere
   model.sphereMapper.setInputConnection(model.filter.getOutputPort(0));
   model.sphereMapper.setScaleArray(model.filter.getSphereScaleArrayName());
-  model.sphereActor.setMapper(model.sphereMapper); // render sticks
+  model.sphereActor.setMapper(model.sphereMapper);
 
+  // render sticks
   model.stickMapper.setInputConnection(model.filter.getOutputPort(1));
   model.stickMapper.setScaleArray('stickScales');
   model.stickMapper.setOrientationArray('orientation');
-  model.stickActor.setMapper(model.stickMapper); // Add actors
+  model.stickActor.setMapper(model.stickMapper);
 
+  // Add actors
   model.actors.push(model.sphereActor);
-  model.actors.push(model.stickActor); // API ----------------------------------------------------------------------
+  model.actors.push(model.stickActor);
 
-  publicAPI.setColorBy = function () {};
+  // API ----------------------------------------------------------------------
 
-  publicAPI.getColorBy = function () {
-    return [];
-  };
+  publicAPI.setColorBy = () => {};
+  publicAPI.getColorBy = () => [];
+  publicAPI.listDataArrays = () => [];
+}
 
-  publicAPI.listDataArrays = function () {
-    return [];
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  vtkAbstractRepresentationProxy.extend(publicAPI, model, initialValues); // Object specific methods
+  // Object methods
+  vtkAbstractRepresentationProxy.extend(publicAPI, model, initialValues);
 
+  // Object specific methods
   vtkMoleculeRepresentationProxy(publicAPI, model);
   macro.proxyPropertyMapping(publicAPI, model, {
     tolerance: {
@@ -80,13 +86,17 @@ function extend(publicAPI, model) {
       property: 'hideElements'
     }
   });
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkMoleculeRepresentationProxy'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkMoleculeRepresentationProxy');
+
+// ----------------------------------------------------------------------------
 
 var vtkMoleculeRepresentationProxy$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkMoleculeRepresentationProxy$1 as default, extend, newInstance };

package/Proxy/Representations/ResliceRepresentationProxy.js

@@ -1,4 +1,4 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkCutter from '../../Filters/Core/Cutter.js';
 import vtkImageDataOutlineFilter from '../../Filters/General/ImageDataOutlineFilter.js';
@@ -9,23 +9,26 @@ import { SlabTypes } from '../../Rendering/Core/ImageResliceMapper/Constants.js'
 import vtkPlane from '../../Common/DataModel/Plane.js';
 import vtkAbstractRepresentationProxy from '../Core/AbstractRepresentationProxy.js';
 
+// ----------------------------------------------------------------------------
+
 function sum(a, b) {
   return a + b;
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function mean() {
   for (var _len = arguments.length, array = new Array(_len), _key = 0; _key < _len; _key++) {
     array[_key] = arguments[_key];
   }
-
   return array.reduce(sum, 0) / array.length;
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function updateDomains(dataset, dataArray, model, updateProp) {
-  var dataRange = dataArray.getRange();
-  var propToUpdate = {
+  const dataRange = dataArray.getRange();
+  const propToUpdate = {
     windowWidth: {
       domain: {
         min: 0,
@@ -47,23 +50,26 @@ function updateDomains(dataset, dataArray, model, updateProp) {
     windowWidth: propToUpdate.windowWidth.domain.max,
     windowLevel: Math.floor(mean(propToUpdate.windowLevel.domain.min, propToUpdate.windowLevel.domain.max))
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkResliceRepresentationProxy methods
 // ----------------------------------------------------------------------------
 
-
 function vtkResliceRepresentationProxy(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkResliceRepresentationProxy');
   model.mapper = vtkImageResliceMapper.newInstance();
   model.actor = vtkImageSlice.newInstance();
-  model.property = model.actor.getProperty(); // set slicing plane
+  model.property = model.actor.getProperty();
 
+  // set slicing plane
   model.slicePlane = vtkPlane.newInstance();
   model.slicePlane.setNormal(0, 1, 0);
   model.mapper.setSlicePlane(model.slicePlane);
-  model.mapper.setSlabType(SlabTypes.MAX); // for the slice polygon outline
+  model.mapper.setSlabType(SlabTypes.MAX);
 
+  // for the slice polygon outline
   model.outline = {
     iof: vtkImageDataOutlineFilter.newInstance(),
     sof: vtkCutter.newInstance({
@@ -75,58 +81,64 @@ function vtkResliceRepresentationProxy(publicAPI, model) {
     })
   };
   model.outline.sof.setInputConnection(model.outline.iof.getOutputPort());
-  model.outline.mapper.setInputConnection(model.outline.sof.getOutputPort()); // connect rendering pipeline
+  model.outline.mapper.setInputConnection(model.outline.sof.getOutputPort());
 
+  // connect rendering pipeline
   model.actor.setMapper(model.mapper);
   model.actors.push(model.actor);
   model.outline.actor.setMapper(model.outline.mapper);
   model.actors.push(model.outline.actor);
-
   function setInputData(inputDataset) {
-    var state = updateDomains(inputDataset, publicAPI.getDataArray(), model, publicAPI.updateProxyProperty);
+    const state = updateDomains(inputDataset, publicAPI.getDataArray(), model, publicAPI.updateProxyProperty);
     publicAPI.set(state);
     model.slicePlane.setOrigin(inputDataset.getCenter());
-  } // Keep things updated
-
+  }
 
+  // Keep things updated
   model.sourceDependencies.push(model.mapper);
   model.sourceDependencies.push({
-    setInputData: setInputData
+    setInputData
   });
-  model.sourceDependencies.push(model.outline.iof); // API ----------------------------------------------------------------------
+  model.sourceDependencies.push(model.outline.iof);
 
-  var parentSetColorBy = publicAPI.setColorBy;
+  // API ----------------------------------------------------------------------
 
+  const parentSetColorBy = publicAPI.setColorBy;
   publicAPI.setColorBy = function (arrayName, arrayLocation) {
-    var componentIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
-
+    let componentIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
     if (arrayName === null) {
       model.property.setRGBTransferFunction(null);
       model.property.setPiecewiseFunction(null);
     } else {
       parentSetColorBy(arrayName, arrayLocation, componentIndex);
-      var lutProxy = publicAPI.getLookupTableProxy(arrayName);
-      var pwfProxy = publicAPI.getPiecewiseFunctionProxy(arrayName);
+      const lutProxy = publicAPI.getLookupTableProxy(arrayName);
+      const pwfProxy = publicAPI.getPiecewiseFunctionProxy(arrayName);
       model.property.setRGBTransferFunction(lutProxy.getLookupTable());
       model.property.setPiecewiseFunction(pwfProxy.getPiecewiseFunction());
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Object methods
   vtkAbstractRepresentationProxy.extend(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['slicePlane']); // Object specific methods
+  macro.get(publicAPI, model, ['slicePlane']);
 
-  vtkResliceRepresentationProxy(publicAPI, model); // Proxyfy
+  // Object specific methods
+  vtkResliceRepresentationProxy(publicAPI, model);
 
+  // Proxyfy
   model.outlineActor = model.outline.actor;
   model.outlineProperty = model.outline.actor.getProperty();
   macro.proxyPropertyMapping(publicAPI, model, {
@@ -179,13 +191,17 @@ function extend(publicAPI, model) {
       property: 'lineWidth'
     }
   });
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkResliceRepresentationProxy'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkResliceRepresentationProxy');
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { index as default, extend, newInstance };

package/Proxy/Representations/SkyboxRepresentationProxy.js

@@ -1,7 +1,8 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkSkybox from '../../Rendering/Core/Skybox.js';
 import vtkAbstractRepresentationProxy from '../Core/AbstractRepresentationProxy.js';
 
+// ----------------------------------------------------------------------------
 // vtkSkyboxRepresentationProxy methods
 // ----------------------------------------------------------------------------
 
@@ -10,59 +11,59 @@ function vtkSkyboxRepresentationProxy(publicAPI, model) {
   model.classHierarchy.push('vtkSkyboxRepresentationProxy');
   model.actor = vtkSkybox.newInstance();
   model.actors.push(model.actor);
-
   function updateTexture(texture) {
     model.actor.removeAllTextures();
-    model.actor.addTexture(texture); // Update domain
+    model.actor.addTexture(texture);
 
-    var values = model.input.getAlgo().getPositions();
+    // Update domain
+    const values = model.input.getAlgo().getPositions();
     publicAPI.updateProxyProperty('position', {
-      values: values
+      values
     });
   }
-
   model.sourceDependencies.push({
     setInputData: updateTexture
-  }); // API ----------------------------------------------------------------------
-
-  publicAPI.setColorBy = function () {};
+  });
 
-  publicAPI.getColorBy = function () {
-    return [];
-  };
-
-  publicAPI.listDataArrays = function () {
-    return [];
-  };
+  // API ----------------------------------------------------------------------
 
-  publicAPI.setPosition = function (value) {
+  publicAPI.setColorBy = () => {};
+  publicAPI.getColorBy = () => [];
+  publicAPI.listDataArrays = () => [];
+  publicAPI.setPosition = value => {
     model.input.getAlgo().setPosition(value);
   };
+  publicAPI.getPosition = () => model.input.getAlgo().getPosition();
+}
 
-  publicAPI.getPosition = function () {
-    return model.input.getAlgo().getPosition();
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  vtkAbstractRepresentationProxy.extend(publicAPI, model, initialValues); // Object specific methods
+  // Object methods
+  vtkAbstractRepresentationProxy.extend(publicAPI, model, initialValues);
 
+  // Object specific methods
   vtkSkyboxRepresentationProxy(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkSkyboxRepresentationProxy'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkSkyboxRepresentationProxy');
+
+// ----------------------------------------------------------------------------
 
 var vtkSkyboxRepresentationProxy$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkSkyboxRepresentationProxy$1 as default, extend, newInstance };