@kitware/vtk.js 28.10.2 → 28.11.1

package/Proxy/Core/PiecewiseFunctionProxy.js

@@ -1,143 +1,127 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkPiecewiseFunction from '../../Common/DataModel/PiecewiseFunction.js';
 import vtkPiecewiseGaussianWidget from '../../Interaction/Widgets/PiecewiseGaussianWidget.js';
 import Constants from './PiecewiseFunctionProxy/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; }
+const {
+  Mode,
+  Defaults
+} = 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 Mode = Constants.Mode,
-    Defaults = Constants.Defaults; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function applyPointsToPiecewiseFunction(points, range, pwf) {
-  var width = range[1] - range[0];
-  var rescaled = points.map(function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-        x = _ref2[0],
-        y = _ref2[1];
-
+  const width = range[1] - range[0];
+  const rescaled = points.map(_ref => {
+    let [x, y] = _ref;
     return [x * width + range[0], y];
   });
   pwf.removeAllPoints();
-  rescaled.forEach(function (_ref3) {
-    var _ref4 = _slicedToArray(_ref3, 2),
-        x = _ref4[0],
-        y = _ref4[1];
-
+  rescaled.forEach(_ref2 => {
+    let [x, y] = _ref2;
     return pwf.addPoint(x, y);
   });
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function applyNodesToPiecewiseFunction(nodes, range, pwf) {
-  var width = range[1] - range[0];
-  var rescaled = nodes.map(function (n) {
-    return _objectSpread(_objectSpread({}, n), {}, {
-      x: n.x * width + range[0]
-    });
-  });
+  const width = range[1] - range[0];
+  const rescaled = nodes.map(n => ({
+    ...n,
+    x: n.x * width + range[0]
+  }));
   pwf.setNodes(rescaled);
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function copyGaussians(gaussians) {
   // gaussians is assumed to be an array of gaussian objects
-  return gaussians.map(function (g) {
-    return _objectSpread({}, g);
-  });
-} // ----------------------------------------------------------------------------
+  return gaussians.map(g => ({
+    ...g
+  }));
+}
+
+// ----------------------------------------------------------------------------
 // vtkPiecewiseFunctionProxy methods
 // ----------------------------------------------------------------------------
 
-
 function vtkPiecewiseFunctionProxy(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPiecewiseFunctionProxy');
-  model.piecewiseFunction = model.piecewiseFunction || vtkPiecewiseFunction.newInstance(); // Takes an array of gaussians
+  model.piecewiseFunction = model.piecewiseFunction || vtkPiecewiseFunction.newInstance();
 
-  publicAPI.setGaussians = function (gaussians) {
+  // Takes an array of gaussians
+  publicAPI.setGaussians = gaussians => {
     model.gaussians = copyGaussians(gaussians || []);
-
     if (model.gaussians.length === 0) {
       model.gaussians = copyGaussians(Defaults.Gaussians);
     }
-
     publicAPI.applyMode();
-  }; // Takes an array of points [x, y]
-
+  };
 
-  publicAPI.setPoints = function (points) {
+  // Takes an array of points [x, y]
+  publicAPI.setPoints = points => {
     model.points = (points || []).slice();
-
     if (model.points.length === 0) {
       model.points = Defaults.Points.slice();
     }
-
     publicAPI.applyMode();
-  }; // Takes an array of PiecewiseFunction nodes
-
+  };
 
-  publicAPI.setNodes = function (nodes) {
+  // Takes an array of PiecewiseFunction nodes
+  publicAPI.setNodes = nodes => {
     model.nodes = (nodes || []).slice();
-
     if (model.nodes.length === 0) {
       model.nodes = Defaults.Nodes.slice();
     }
-
     publicAPI.applyMode();
   };
-
-  publicAPI.setMode = function (mode) {
+  publicAPI.setMode = mode => {
     if (model.mode === mode) {
       return;
     }
-
     model.mode = mode;
     publicAPI.applyMode();
   };
-
-  publicAPI.applyMode = function () {
+  publicAPI.applyMode = () => {
     switch (model.mode) {
       case Mode.Gaussians:
         vtkPiecewiseGaussianWidget.applyGaussianToPiecewiseFunction(model.gaussians, 255, model.dataRange, model.piecewiseFunction);
         publicAPI.modified();
         break;
-
       case Mode.Points:
         applyPointsToPiecewiseFunction(model.points, model.dataRange, model.piecewiseFunction);
         publicAPI.modified();
         break;
-
       case Mode.Nodes:
         applyNodesToPiecewiseFunction(model.nodes, model.dataRange, model.piecewiseFunction);
         publicAPI.modified();
         break;
-
+      // noop
     }
   };
 
-  publicAPI.getLookupTableProxy = function () {
-    return model.proxyManager.getLookupTable(model.arrayName);
-  };
-
-  publicAPI.setDataRange = function (min, max) {
+  publicAPI.getLookupTableProxy = () => model.proxyManager.getLookupTable(model.arrayName);
+  publicAPI.setDataRange = (min, max) => {
     if (model.dataRange[0] !== min || model.dataRange[1] !== max) {
       model.dataRange[0] = min;
       model.dataRange[1] = max;
       publicAPI.applyMode();
     }
-  }; // Initialization ------------------------------------------------------------
+  };
 
+  // Initialization ------------------------------------------------------------
 
   publicAPI.applyMode();
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   mode: Mode.Gaussians,
   gaussians: Defaults.Gaussians,
   points: Defaults.Points,
@@ -145,28 +129,35 @@ var DEFAULT_VALUES = {
   arrayName: 'No array associated',
   arrayLocation: 'pointData',
   dataRange: [0, 1]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['arrayName']);
-  macro.get(publicAPI, model, ['piecewiseFunction', 'gaussians', 'nodes', 'points', 'mode', 'dataRange']); // Object specific methods
+  macro.get(publicAPI, model, ['piecewiseFunction', 'gaussians', 'nodes', 'points', 'mode', 'dataRange']);
 
-  vtkPiecewiseFunctionProxy(publicAPI, model); // Proxy handling
+  // Object specific methods
+  vtkPiecewiseFunctionProxy(publicAPI, model);
 
+  // Proxy handling
   macro.proxy(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
+const newInstance = macro.newInstance(extend, 'vtkPiecewiseFunctionProxy');
 
-var newInstance = macro.newInstance(extend, 'vtkPiecewiseFunctionProxy'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkPiecewiseFunctionProxy$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  Mode: Mode,
-  Defaults: Defaults
+  newInstance,
+  extend,
+  Mode,
+  Defaults
 };
 
 export { vtkPiecewiseFunctionProxy$1 as default, newInstance };

package/Proxy/Core/ProxyManager/core.js

@@ -1,10 +1,10 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../../macros.js';
+import { m as macro } from '../../../macros2.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 {
+  vtkErrorMacro
+} = macro;
 
-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; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Proxy Registration Handling
 // ----------------------------------------------------------------------------
 
@@ -13,40 +13,38 @@ function addRegistrationAPI(publicAPI, model) {
     if (!proxy) {
       return;
     }
-
     model.proxyIdMapping[proxy.getProxyId()] = proxy;
-    var group = proxy.getProxyGroup();
-
+    const group = proxy.getProxyGroup();
     if (!model.proxyByGroup[group]) {
       model.proxyByGroup[group] = [];
     }
-
     if (model.proxyByGroup[group].indexOf(proxy) === -1) {
       model.proxyByGroup[group].push(proxy);
     }
+    proxy.setProxyManager(publicAPI);
 
-    proxy.setProxyManager(publicAPI); // Make sure we invoke event after the current execution path
-
-    macro.setImmediate(function () {
+    // Make sure we invoke event after the current execution path
+    macro.setImmediate(() => {
       publicAPI.invokeProxyRegistrationChange({
         action: 'register',
         proxyId: proxy.getProxyId(),
         proxyName: proxy.getProxyName(),
         proxyGroup: proxy.getProxyGroup(),
-        proxy: proxy
+        proxy
       });
     });
-  } // --------------------------------------------------------------------------
+  }
 
+  // --------------------------------------------------------------------------
 
   function unRegisterProxy(proxyOrId) {
-    var id = proxyOrId.getProxyId ? proxyOrId.getProxyId() : proxyOrId;
-    var proxy = model.proxyIdMapping[id]; // Unregister proxy in any group
-
-    Object.keys(model.proxyByGroup).forEach(function (groupName) {
-      var proxyList = model.proxyByGroup[groupName];
-      var index = proxyList.indexOf(proxy);
+    const id = proxyOrId.getProxyId ? proxyOrId.getProxyId() : proxyOrId;
+    const proxy = model.proxyIdMapping[id];
 
+    // Unregister proxy in any group
+    Object.keys(model.proxyByGroup).forEach(groupName => {
+      const proxyList = model.proxyByGroup[groupName];
+      const index = proxyList.indexOf(proxy);
       if (index !== -1) {
         proxyList.splice(index, 1);
       }
@@ -60,198 +58,177 @@ function addRegistrationAPI(publicAPI, model) {
       proxyId: id,
       proxyName: proxy.getProxyName(),
       proxyGroup: proxy.getProxyGroup(),
-      proxy: proxy
+      proxy
     });
     return proxy;
-  } // --------------------------------------------------------------------------
+  }
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.setActiveSource = function (source) {
+  publicAPI.setActiveSource = source => {
     if (model.activeSource !== source) {
       if (model.activeSourceSubscription) {
         model.activeSourceSubscription.unsubscribe();
         model.activeSourceSubscription = null;
       }
-
       model.activeSource = source;
-
       if (source) {
         model.activeSourceSubscription = source.onModified(publicAPI.modified);
       }
-
       publicAPI.modified();
       publicAPI.invokeActiveSourceChange(source);
     }
   };
-
-  publicAPI.setActiveView = function (view) {
+  publicAPI.setActiveView = view => {
     if (model.activeView !== view) {
       if (model.activeViewSubscription) {
         model.activeViewSubscription.unsubscribe();
         model.activeViewSubscription = null;
       }
-
       model.activeView = view;
-
       if (view) {
         model.activeViewSubscription = view.onModified(publicAPI.modified);
       }
-
       publicAPI.modified();
       publicAPI.invokeActiveViewChange(view);
     }
-  }; // --------------------------------------------------------------------------
-
-
-  publicAPI.getProxyById = function (id) {
-    return model.proxyIdMapping[id];
-  }; // --------------------------------------------------------------------------
-
+  };
 
-  publicAPI.getProxyGroups = function () {
-    return Object.keys(model.proxyByGroup);
-  }; // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
 
+  publicAPI.getProxyById = id => model.proxyIdMapping[id];
 
-  publicAPI.getProxyInGroup = function (name) {
-    return [].concat(model.proxyByGroup[name] || []);
-  }; // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
 
+  publicAPI.getProxyGroups = () => Object.keys(model.proxyByGroup);
 
-  publicAPI.getSources = function () {
-    return [].concat(model.proxyByGroup.Sources || []);
-  };
+  // --------------------------------------------------------------------------
 
-  publicAPI.getRepresentations = function () {
-    return [].concat(model.proxyByGroup.Representations || []);
-  };
+  publicAPI.getProxyInGroup = name => [].concat(model.proxyByGroup[name] || []);
 
-  publicAPI.getViews = function () {
-    return [].concat(model.proxyByGroup.Views || []);
-  }; // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
 
+  publicAPI.getSources = () => [].concat(model.proxyByGroup.Sources || []);
+  publicAPI.getRepresentations = () => [].concat(model.proxyByGroup.Representations || []);
+  publicAPI.getViews = () => [].concat(model.proxyByGroup.Views || []);
 
-  publicAPI.createProxy = function (group, name, options) {
-    var definitions = model.proxyConfiguration.definitions;
+  // --------------------------------------------------------------------------
 
+  publicAPI.createProxy = (group, name, options) => {
+    const {
+      definitions
+    } = model.proxyConfiguration;
     if (!definitions[group] || !definitions[group][name]) {
       return null;
     }
-
-    var definition = definitions[group][name];
-
-    var definitionOptions = _objectSpread(_objectSpread({}, definition.options), options);
-
-    var proxy = definition.class.newInstance(_objectSpread(_objectSpread({}, definitionOptions), {}, {
+    const definition = definitions[group][name];
+    const definitionOptions = {
+      ...definition.options,
+      ...options
+    };
+    const proxy = definition.class.newInstance({
+      ...definitionOptions,
       proxyGroup: group,
       proxyName: name,
       proxyManager: publicAPI
-    })); // Handle proxy property settings
+    });
 
+    // Handle proxy property settings
     if (definition.proxyProps) {
-      var proxyMap = {};
-      Object.keys(definition.proxyProps).forEach(function (key) {
-        var newProxyDef = definition.proxyProps[key];
+      const proxyMap = {};
+      Object.keys(definition.proxyProps).forEach(key => {
+        const newProxyDef = definition.proxyProps[key];
         proxyMap[key] = publicAPI.createProxy(newProxyDef.group, newProxyDef.name, newProxyDef.options);
       });
       proxy.set(proxyMap);
-    } // Handle property setting
-
+    }
 
+    // Handle property setting
     if (definition.props) {
       proxy.set(definition.props);
     }
-
     registerProxy(proxy);
-
     if (definitionOptions.activateOnCreate) {
       proxy.activate();
     }
-
     return proxy;
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.getRepresentation = function (source, view) {
-    var sourceToUse = source || publicAPI.getActiveSource();
-    var viewToUse = view || publicAPI.getActiveView(); // Can only get a representation for a source and a view
+  publicAPI.getRepresentation = (source, view) => {
+    const sourceToUse = source || publicAPI.getActiveSource();
+    const viewToUse = view || publicAPI.getActiveView();
 
+    // Can only get a representation for a source and a view
     if (!sourceToUse || !viewToUse || !sourceToUse.getType()) {
       return null;
     }
-
-    var sourceId = sourceToUse.getProxyId();
-    var viewId = viewToUse.getProxyId();
-    var viewRepMap = model.sv2rMapping[sourceId];
-
+    const sourceId = sourceToUse.getProxyId();
+    const viewId = viewToUse.getProxyId();
+    let viewRepMap = model.sv2rMapping[sourceId];
     if (!viewRepMap) {
       viewRepMap = {};
       model.sv2rMapping[sourceId] = viewRepMap;
     }
-
-    var rep = viewRepMap[viewId];
-
+    let rep = viewRepMap[viewId];
     if (!rep) {
-      var viewName = viewToUse.getProxyName();
-      var sourceType = sourceToUse.getType();
-      var definition = model.proxyConfiguration.representations[viewName][sourceType];
-
+      const viewName = viewToUse.getProxyName();
+      const sourceType = sourceToUse.getType();
+      const definition = model.proxyConfiguration.representations[viewName][sourceType];
       if (!definition) {
-        vtkErrorMacro("No definition for representation of ".concat(sourceType, " in view ").concat(viewName));
+        vtkErrorMacro(`No definition for representation of ${sourceType} in view ${viewName}`);
         return null;
       }
-
       rep = publicAPI.createProxy('Representations', definition.name, definition.options);
       model.r2svMapping[rep.getProxyId()] = {
-        sourceId: sourceId,
-        viewId: viewId
+        sourceId,
+        viewId
       };
       viewRepMap[viewId] = rep;
       rep.setInput(sourceToUse);
       viewToUse.addRepresentation(rep);
     }
-
     return rep;
-  }; // --------------------------------------------------------------------------
-
+  };
 
-  publicAPI.deleteProxy = function (proxy) {
-    var group = proxy.getProxyGroup().toLowerCase();
+  // --------------------------------------------------------------------------
 
+  publicAPI.deleteProxy = proxy => {
+    const group = proxy.getProxyGroup().toLowerCase();
     if (group === 'views') {
-      proxy.getRepresentations().forEach(function (repProxy) {
+      proxy.getRepresentations().forEach(repProxy => {
         publicAPI.deleteProxy(repProxy);
       });
       proxy.setContainer(null);
       unRegisterProxy(proxy);
-
       if (publicAPI.getActiveView() === proxy) {
         publicAPI.setActiveView(publicAPI.getViews()[0]);
       }
     } else if (group === 'representations') {
-      var _model$r2svMapping$pr = model.r2svMapping[proxy.getProxyId()],
-          sourceId = _model$r2svMapping$pr.sourceId,
-          viewId = _model$r2svMapping$pr.viewId;
-      var view = publicAPI.getProxyById(viewId);
+      const {
+        sourceId,
+        viewId
+      } = model.r2svMapping[proxy.getProxyId()];
+      const view = publicAPI.getProxyById(viewId);
       view.removeRepresentation(proxy);
       delete model.r2svMapping[proxy.getProxyId()];
       delete model.sv2rMapping[sourceId][viewId];
       unRegisterProxy(proxy);
     } else if (group === 'sources') {
-      var viewToRep = model.sv2rMapping[proxy.getProxyId()];
-      Object.keys(viewToRep).forEach(function (viewId) {
+      const viewToRep = model.sv2rMapping[proxy.getProxyId()];
+      Object.keys(viewToRep).forEach(viewId => {
         publicAPI.deleteProxy(viewToRep[viewId]);
       });
       unRegisterProxy(proxy);
-
       if (publicAPI.getActiveSource() === proxy) {
         publicAPI.setActiveSource(publicAPI.getSources()[0]);
       }
     } else {
       unRegisterProxy(proxy);
-    } // Delete the object itself
-
+    }
 
+    // Delete the object itself
     proxy.delete();
   };
 }