@kitware/vtk.js 34.16.3 → 34.16.6

package/Proxy/Core/ProxyManager/state.js

@@ -14,202 +14,191 @@ function getProperties(proxy) {
 // ----------------------------------------------------------------------------
 
 function addStateAPI(publicAPI, model) {
-  publicAPI.loadState = function (state) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    return new Promise((resolve, reject) => {
-      const proxyMapping = {};
-      const $oldToNewIdMapping = {};
-      const cameras = {};
-      const datasetHandler = options.datasetHandler || vtk;
-      const sourcePromises = [];
-      state.sources.forEach(_ref => {
-        let {
-          id,
-          group,
-          name,
-          props
-        } = _ref;
-        sourcePromises.push(Promise.resolve(datasetHandler(props.dataset)).then(dataset => {
-          if (dataset) {
-            const proxy = publicAPI.createProxy(group, name);
-            proxy.setName(props.name);
-            proxy.setInputData(dataset, props.type);
-            proxyMapping[id] = proxy;
-            return proxy;
-          }
-          return null;
-        }));
-      });
-      Promise.all(sourcePromises).then(() => {
-        const views = publicAPI.getViews();
-        state.views.forEach(_ref2 => {
-          let {
-            id,
-            group,
-            name,
-            props,
-            camera
-          } = _ref2;
-          let proxy = null;
-          if (state.options.recycleViews) {
-            proxy = views.find(v => v.getProxyGroup() === group && v.getProxyName() === name && v.getName() === props.name);
-          }
-          if (!proxy) {
-            proxy = publicAPI.createProxy(group, name, {
-              disableAnimation: true
-            });
-          } else {
-            proxy.setDisableAnimation(true);
-          }
-          proxy.set(props, true);
+  publicAPI.loadState = (state, options = {}) => new Promise((resolve, reject) => {
+    const proxyMapping = {};
+    const $oldToNewIdMapping = {};
+    const cameras = {};
+    const datasetHandler = options.datasetHandler || vtk;
+    const sourcePromises = [];
+    state.sources.forEach(({
+      id,
+      group,
+      name,
+      props
+    }) => {
+      sourcePromises.push(Promise.resolve(datasetHandler(props.dataset)).then(dataset => {
+        if (dataset) {
+          const proxy = publicAPI.createProxy(group, name);
+          proxy.setName(props.name);
+          proxy.setInputData(dataset, props.type);
           proxyMapping[id] = proxy;
-          cameras[id] = camera;
-        });
-        function updateView(view) {
-          if (!proxyMapping[view] || !cameras[view]) {
-            return;
-          }
-          proxyMapping[view].resetOrientation().then(() => {
-            proxyMapping[view].getCamera().set(cameras[view]);
-            proxyMapping[view].getRenderer().updateLightsGeometryToFollowCamera();
-            proxyMapping[view].renderLater();
+          return proxy;
+        }
+        return null;
+      }));
+    });
+    Promise.all(sourcePromises).then(() => {
+      const views = publicAPI.getViews();
+      state.views.forEach(({
+        id,
+        group,
+        name,
+        props,
+        camera
+      }) => {
+        let proxy = null;
+        if (state.options.recycleViews) {
+          proxy = views.find(v => v.getProxyGroup() === group && v.getProxyName() === name && v.getName() === props.name);
+        }
+        if (!proxy) {
+          proxy = publicAPI.createProxy(group, name, {
+            disableAnimation: true
           });
+        } else {
+          proxy.setDisableAnimation(true);
         }
-        state.representations.forEach(_ref3 => {
-          let {
-            source,
-            view,
-            props
-          } = _ref3;
-          const proxy = publicAPI.getRepresentation(proxyMapping[source], proxyMapping[view]);
-          proxy.set(props, true);
-          updateView(view);
-        });
-
-        // restore luts and pwfs after restoring reps to avoid
-        // rep initialization from resetting restored luts/pwfs
-        Object.keys(state.fields).forEach(fieldName => {
-          const {
-            lookupTable,
-            piecewiseFunction
-          } = state.fields[fieldName];
-          const lutProxy = publicAPI.getLookupTable(fieldName, lookupTable);
-          lutProxy.setPresetName(lookupTable.presetName);
-          lutProxy.setDataRange(...lookupTable.dataRange);
-          const pwfProxy = publicAPI.getPiecewiseFunction(fieldName, piecewiseFunction);
-          switch (piecewiseFunction.mode) {
-            case vtkPiecewiseFunctionProxy.Mode.Gaussians:
-              pwfProxy.setGaussians(piecewiseFunction.gaussians);
-              break;
-            case vtkPiecewiseFunctionProxy.Mode.Points:
-              pwfProxy.setPoints(piecewiseFunction.points);
-              break;
-            case vtkPiecewiseFunctionProxy.Mode.Nodes:
-              pwfProxy.setNodes(piecewiseFunction.nodes);
-              break;
-          }
-          pwfProxy.setMode(piecewiseFunction.mode);
-          pwfProxy.setDataRange(...piecewiseFunction.dataRange);
+        proxy.set(props, true);
+        proxyMapping[id] = proxy;
+        cameras[id] = camera;
+      });
+      function updateView(view) {
+        if (!proxyMapping[view] || !cameras[view]) {
+          return;
+        }
+        proxyMapping[view].resetOrientation().then(() => {
+          proxyMapping[view].getCamera().set(cameras[view]);
+          proxyMapping[view].getRenderer().updateLightsGeometryToFollowCamera();
+          proxyMapping[view].renderLater();
         });
+      }
+      state.representations.forEach(({
+        source,
+        view,
+        props
+      }) => {
+        const proxy = publicAPI.getRepresentation(proxyMapping[source], proxyMapping[view]);
+        proxy.set(props, true);
+        updateView(view);
+      });
 
-        // Apply camera no matter what
-        Object.keys(cameras).forEach(updateView);
-
-        // Create id mapping
-        Object.keys(proxyMapping).forEach(originalId => {
-          const newId = proxyMapping[originalId].getProxyId();
-          $oldToNewIdMapping[originalId] = newId;
-        });
+      // restore luts and pwfs after restoring reps to avoid
+      // rep initialization from resetting restored luts/pwfs
+      Object.keys(state.fields).forEach(fieldName => {
+        const {
+          lookupTable,
+          piecewiseFunction
+        } = state.fields[fieldName];
+        const lutProxy = publicAPI.getLookupTable(fieldName, lookupTable);
+        lutProxy.setPresetName(lookupTable.presetName);
+        lutProxy.setDataRange(...lookupTable.dataRange);
+        const pwfProxy = publicAPI.getPiecewiseFunction(fieldName, piecewiseFunction);
+        switch (piecewiseFunction.mode) {
+          case vtkPiecewiseFunctionProxy.Mode.Gaussians:
+            pwfProxy.setGaussians(piecewiseFunction.gaussians);
+            break;
+          case vtkPiecewiseFunctionProxy.Mode.Points:
+            pwfProxy.setPoints(piecewiseFunction.points);
+            break;
+          case vtkPiecewiseFunctionProxy.Mode.Nodes:
+            pwfProxy.setNodes(piecewiseFunction.nodes);
+            break;
+        }
+        pwfProxy.setMode(piecewiseFunction.mode);
+        pwfProxy.setDataRange(...piecewiseFunction.dataRange);
+      });
 
-        // Re-enable animation on views
-        state.views.forEach(_ref4 => {
-          let {
-            id
-          } = _ref4;
-          proxyMapping[id].setDisableAnimation(false);
-        });
-        resolve({
-          ...state.userData,
-          $oldToNewIdMapping
-        });
-      }).catch(reject);
-    });
-  };
-  publicAPI.saveState = function () {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    let userData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    return new Promise((resolve, reject) => {
-      const sources = publicAPI.getSources();
-      // const representations = publicAPI.getRepresentations();
-      const views = publicAPI.getViews();
+      // Apply camera no matter what
+      Object.keys(cameras).forEach(updateView);
 
-      // Extract handlers
-      const datasetHandler = options.datasetHandler || (d => d.getState());
-      delete options.datasetHandler;
-      const datasets = [];
-      const fieldNames = new Set();
-      const state = {
-        userData,
-        options,
-        sources: [],
-        views: [],
-        representations: [],
-        fields: {}
-      };
-      sources.forEach(source => {
-        const dataset = Promise.resolve(datasetHandler(source.getDataset(), source));
-        datasets.push(dataset);
-        state.sources.push({
-          id: source.getProxyId(),
-          group: source.getProxyGroup(),
-          name: source.getProxyName(),
-          props: {
-            name: source.getName(),
-            type: source.getType(),
-            dataset
-          }
-        });
+      // Create id mapping
+      Object.keys(proxyMapping).forEach(originalId => {
+        const newId = proxyMapping[originalId].getProxyId();
+        $oldToNewIdMapping[originalId] = newId;
       });
-      views.forEach(view => {
-        const camera = view.getCamera().get('position', 'viewUp', 'focalPoint');
-        state.views.push({
-          id: view.getProxyId(),
-          group: view.getProxyGroup(),
-          name: view.getProxyName(),
-          props: Object.assign(getProperties(view), view.get('axis', 'orientation', 'viewUp')),
-          camera
-        });
 
-        // Loop over view representations
-        const representations = view.getRepresentations();
-        representations.forEach(representation => {
-          state.representations.push({
-            source: representation.getInput().getProxyId(),
-            view: view.getProxyId(),
-            props: getProperties(representation)
-          });
-          fieldNames.add(representation.getColorBy()[0]);
-        });
+      // Re-enable animation on views
+      state.views.forEach(({
+        id
+      }) => {
+        proxyMapping[id].setDisableAnimation(false);
       });
-      fieldNames.forEach(fieldName => {
-        state.fields[fieldName] = {
-          lookupTable: publicAPI.getLookupTable(fieldName).get('mode', 'presetName', 'rgbPoints', 'hsvPoints', 'nodes', 'arrayName', 'arrayLocation', 'dataRange'),
-          piecewiseFunction: publicAPI.getPiecewiseFunction(fieldName).get('mode', 'gaussians', 'points', 'nodes', 'arrayName', 'arrayLocation', 'dataRange')
-        };
+      resolve({
+        ...state.userData,
+        $oldToNewIdMapping
       });
-      Promise.all(datasets).then(() => {
-        // Patch datasets in state to the result of the promises
-        for (let i = 0; i < state.sources.length; i++) {
-          state.sources[i].props.dataset.then(value => {
-            state.sources[i].props.dataset = value;
-          });
+    }).catch(reject);
+  });
+  publicAPI.saveState = (options = {}, userData = {}) => new Promise((resolve, reject) => {
+    const sources = publicAPI.getSources();
+    // const representations = publicAPI.getRepresentations();
+    const views = publicAPI.getViews();
+
+    // Extract handlers
+    const datasetHandler = options.datasetHandler || (d => d.getState());
+    delete options.datasetHandler;
+    const datasets = [];
+    const fieldNames = new Set();
+    const state = {
+      userData,
+      options,
+      sources: [],
+      views: [],
+      representations: [],
+      fields: {}
+    };
+    sources.forEach(source => {
+      const dataset = Promise.resolve(datasetHandler(source.getDataset(), source));
+      datasets.push(dataset);
+      state.sources.push({
+        id: source.getProxyId(),
+        group: source.getProxyGroup(),
+        name: source.getProxyName(),
+        props: {
+          name: source.getName(),
+          type: source.getType(),
+          dataset
         }
+      });
+    });
+    views.forEach(view => {
+      const camera = view.getCamera().get('position', 'viewUp', 'focalPoint');
+      state.views.push({
+        id: view.getProxyId(),
+        group: view.getProxyGroup(),
+        name: view.getProxyName(),
+        props: Object.assign(getProperties(view), view.get('axis', 'orientation', 'viewUp')),
+        camera
+      });
 
-        // provide valide state
-        resolve(state);
-      }).catch(reject);
+      // Loop over view representations
+      const representations = view.getRepresentations();
+      representations.forEach(representation => {
+        state.representations.push({
+          source: representation.getInput().getProxyId(),
+          view: view.getProxyId(),
+          props: getProperties(representation)
+        });
+        fieldNames.add(representation.getColorBy()[0]);
+      });
     });
-  };
+    fieldNames.forEach(fieldName => {
+      state.fields[fieldName] = {
+        lookupTable: publicAPI.getLookupTable(fieldName).get('mode', 'presetName', 'rgbPoints', 'hsvPoints', 'nodes', 'arrayName', 'arrayLocation', 'dataRange'),
+        piecewiseFunction: publicAPI.getPiecewiseFunction(fieldName).get('mode', 'gaussians', 'points', 'nodes', 'arrayName', 'arrayLocation', 'dataRange')
+      };
+    });
+    Promise.all(datasets).then(() => {
+      // Patch datasets in state to the result of the promises
+      for (let i = 0; i < state.sources.length; i++) {
+        state.sources[i].props.dataset.then(value => {
+          state.sources[i].props.dataset = value;
+        });
+      }
+
+      // provide valide state
+      resolve(state);
+    }).catch(reject);
+  });
 }
 
 export { addStateAPI as default };

package/Proxy/Core/ProxyManager/view.js

@@ -18,8 +18,7 @@ function addViewHandlingAPI(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.renderAllViews = function () {
-    let blocking = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  publicAPI.renderAllViews = (blocking = false) => {
     const allViews = publicAPI.getViews();
     for (let i = 0; i < allViews.length; i++) {
       allViews[i].render(blocking);
@@ -28,8 +27,7 @@ function addViewHandlingAPI(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.setAnimationOnAllViews = function () {
-    let enable = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  publicAPI.setAnimationOnAllViews = (enable = false) => {
     const allViews = publicAPI.getViews().filter(v => !enable || v.getContainer());
     for (let i = 0; i < allViews.length; i++) {
       allViews[i].setAnimation(enable, publicAPI);
@@ -48,8 +46,7 @@ function addViewHandlingAPI(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.autoAnimateViews = function () {
-    let debouceTimout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 250;
+  publicAPI.autoAnimateViews = (debouceTimout = 250) => {
     if (!model.animating) {
       model.animating = true;
       const allViews = publicAPI.getViews().filter(v => v.getContainer());

package/Proxy/Core/ProxyManager.js

@@ -6,8 +6,7 @@ import addVPropertyHandlingAPI from './ProxyManager/properties.js';
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, {
     proxyIdMapping: {},
     proxyByGroup: {},

package/Proxy/Core/SourceProxy.js

@@ -19,7 +19,6 @@ function vtkSourceProxy(publicAPI, model) {
     if (model.inputProxy) {
       model.inputSubscription = source.onModified(publicAPI.update, -1).unsubscribe; // Trigger at next cycle
     }
-
     publicAPI.update();
   };
 
@@ -36,8 +35,7 @@ function vtkSourceProxy(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.setInputAlgorithm = function (algo, type) {
-    let autoUpdate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  publicAPI.setInputAlgorithm = (algo, type, autoUpdate = true) => {
     model.type = type;
     if (model.algo !== algo) {
       model.algo = algo;
@@ -91,7 +89,6 @@ function vtkSourceProxy(publicAPI, model) {
       publicAPI.update();
     }, -1).unsubscribe; // Trigger at next cycle
   }
-
   if (model.algoFactory) {
     publicAPI.setInputAlgorithm(model.algoFactory.newInstance(), null, model.autoUpdate);
   }
@@ -108,8 +105,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['name', 'type', 'dataset', 'algo', 'inputProxy']);

package/Proxy/Core/View2DProxy.js

@@ -143,8 +143,7 @@ function vtkView2DProxy(publicAPI, model) {
    * Exact fitting requires useParallelRendering, and an active camera
    * Otherwise, the default renderer.resetCamera is used and it uses a larger bounding box
    */
-  model._resetCamera = function () {
-    let bounds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+  model._resetCamera = (bounds = null) => {
     // Always reset camera first to set physicalScale, physicalTranslation and trigger events
     const initialReset = superInternalResetCamera(bounds);
     if (!model.fitProps || !model.useParallelRendering || !initialReset) {
@@ -331,8 +330,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
   vtkViewProxy.extend(publicAPI, model, initialValues);
   macro.get(publicAPI, model, ['axis']);

package/Proxy/Core/ViewProxy.js

@@ -46,10 +46,7 @@ function vtkViewProxy(publicAPI, model) {
   /**
    * Internal function used by publicAPI.resetCamera()
    */
-  model._resetCamera = function () {
-    let bounds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-    return model.renderer.resetCamera(bounds);
-  };
+  model._resetCamera = (bounds = null) => model.renderer.resetCamera(bounds);
 
   // Apply default interaction styles
   InteractionPresets.applyPreset('3D', model.interactorStyle3D);
@@ -190,8 +187,7 @@ function vtkViewProxy(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.render = function () {
-    let blocking = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  publicAPI.render = (blocking = true) => {
     if (model.representations.length > 0 && model.resetCameraOnFirstRender) {
       model.resetCameraOnFirstRender = false;
       publicAPI.resetCamera();
@@ -234,14 +230,13 @@ function vtkViewProxy(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.setCameraParameters = _ref => {
-    let {
-      position,
-      focalPoint,
-      bounds,
-      parallelScale,
-      viewAngle
-    } = _ref;
+  publicAPI.setCameraParameters = ({
+    position,
+    focalPoint,
+    bounds,
+    parallelScale,
+    viewAngle
+  }) => {
     if (position != null) {
       model.camera.setPosition(...position);
     }
@@ -272,18 +267,14 @@ function vtkViewProxy(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.captureImage = function () {
-    let {
-      format = 'image/png',
-      ...opts
-    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    return model.renderWindow.captureImages(format, opts)[0];
-  };
+  publicAPI.captureImage = ({
+    format = 'image/png',
+    ...opts
+  } = {}) => model.renderWindow.captureImages(format, opts)[0];
 
   // --------------------------------------------------------------------------
 
-  publicAPI.openCaptureImage = function () {
-    let target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '_blank';
+  publicAPI.openCaptureImage = (target = '_blank') => {
     const image = new Image();
     return publicAPI.captureImage().then(imageURL => {
       image.src = imageURL;
@@ -304,8 +295,7 @@ function vtkViewProxy(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.setCornerAnnotations = function (annotations) {
-    let useTemplateString = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  publicAPI.setCornerAnnotations = (annotations, useTemplateString = false) => {
     if (useTemplateString) {
       Object.keys(annotations).forEach(key => {
         publicAPI.setCornerAnnotation(key, annotations[key]);
@@ -339,8 +329,7 @@ function vtkViewProxy(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.setAnimation = function (enable) {
-    let requester = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : publicAPI;
+  publicAPI.setAnimation = (enable, requester = publicAPI) => {
     if (model.disableAnimation && enable) {
       return;
     }
@@ -354,8 +343,7 @@ function vtkViewProxy(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.updateOrientation = function (axisIndex, orientation, viewUp) {
-    let animateSteps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  publicAPI.updateOrientation = (axisIndex, orientation, viewUp, animateSteps = 0) => {
     if (axisIndex === undefined) {
       return Promise.resolve();
     }
@@ -383,8 +371,7 @@ function vtkViewProxy(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.moveCamera = function (focalPoint, position, viewUp) {
-    let animateSteps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  publicAPI.moveCamera = (focalPoint, position, viewUp, animateSteps = 0) => {
     const originalFocalPoint = model.camera.getFocalPoint();
     const originalPosition = model.camera.getPosition();
     const originalViewUp = model.camera.getViewUp();
@@ -466,10 +453,7 @@ function vtkViewProxy(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.resetOrientation = function () {
-    let animateSteps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    return publicAPI.updateOrientation(model.axis, model.orientation, model.viewUp, animateSteps);
-  };
+  publicAPI.resetOrientation = (animateSteps = 0) => publicAPI.updateOrientation(model.axis, model.orientation, model.viewUp, animateSteps);
 
   // --------------------------------------------------------------------------
 
@@ -536,8 +520,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
   obj(publicAPI, model);
   setGet(publicAPI, model, ['name', 'disableAnimation', 'resetCameraOnFirstRender']);

package/Proxy/Representations/GeometryRepresentationProxy.js

@@ -69,8 +69,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods

package/Proxy/Representations/GlyphRepresentationProxy.js

@@ -107,8 +107,7 @@ const DEFAULT_VALUES = {};
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods

package/Proxy/Representations/MoleculeRepresentationProxy.js

@@ -51,8 +51,7 @@ const DEFAULT_VALUES = {};
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods

package/Proxy/Representations/ResliceRepresentationProxy.js

@@ -17,10 +17,7 @@ function sum(a, b) {
 
 // ----------------------------------------------------------------------------
 
-function mean() {
-  for (var _len = arguments.length, array = new Array(_len), _key = 0; _key < _len; _key++) {
-    array[_key] = arguments[_key];
-  }
+function mean(...array) {
   return array.reduce(sum, 0) / array.length;
 }
 
@@ -104,8 +101,7 @@ function vtkResliceRepresentationProxy(publicAPI, model) {
   // API ----------------------------------------------------------------------
 
   const parentSetColorBy = publicAPI.setColorBy;
-  publicAPI.setColorBy = function (arrayName, arrayLocation) {
-    let componentIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+  publicAPI.setColorBy = (arrayName, arrayLocation, componentIndex = -1) => {
     if (arrayName === null) {
       model.property.setRGBTransferFunction(null);
       model.property.setPiecewiseFunction(null);
@@ -127,8 +123,7 @@ const DEFAULT_VALUES = {};
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods