@kitware/vtk.js 21.1.4 → 21.2.2

package/_virtual/rollup-plugin-worker-loader__module_Sources/Interaction/Widgets/PiecewiseGaussianWidget/ComputeHistogram.worker.js

@@ -1,6 +1,278 @@
-import { c as createBase64WorkerFactory } from '../../../../rollup-plugin-web-worker-loader__helper__browser__createBase64WorkerFactory.js';
+import { c as createInlineWorkerFactory } from '../../../../rollup-plugin-web-worker-loader__helper__browser__createInlineWorkerFactory.js';
 
-var WorkerFactory = createBase64WorkerFactory('Lyogcm9sbHVwLXBsdWdpbi13ZWItd29ya2VyLWxvYWRlciAqLwooZnVuY3Rpb24gKHJlZ2lzdGVyV2Vid29ya2VyKSB7CiAgJ3VzZSBzdHJpY3QnOwoKICBmdW5jdGlvbiBfaW50ZXJvcERlZmF1bHRMZWdhY3kgKGUpIHsgcmV0dXJuIGUgJiYgdHlwZW9mIGUgPT09ICdvYmplY3QnICYmICdkZWZhdWx0JyBpbiBlID8gZSA6IHsgJ2RlZmF1bHQnOiBlIH07IH0KCiAgdmFyIHJlZ2lzdGVyV2Vid29ya2VyX19kZWZhdWx0ID0gLyojX19QVVJFX18qL19pbnRlcm9wRGVmYXVsdExlZ2FjeShyZWdpc3RlcldlYndvcmtlcik7CgogIC8qIGVzbGludC1kaXNhYmxlICovCiAgLy8gcHJldHRpZXItaWdub3JlCgogIHJlZ2lzdGVyV2Vid29ya2VyX19kZWZhdWx0WydkZWZhdWx0J10oZnVuY3Rpb24gKG1lc3NhZ2UsIGVtaXQpIHsKICAgIHZhciBhcnJheSA9IG1lc3NhZ2UuYXJyYXk7CiAgICB2YXIgbWluID0gbWVzc2FnZS5taW47CiAgICB2YXIgbWF4ID0gbWVzc2FnZS5tYXg7CiAgICB2YXIgb2Zmc2V0ID0gbWVzc2FnZS5jb21wb25lbnQgfHwgMDsKICAgIHZhciBzdGVwID0gbWVzc2FnZS5udW1iZXJPZkNvbXBvbmVudHMgfHwgMTsKICAgIHZhciBudW1iZXJPZkJpbnMgPSBtZXNzYWdlLm51bWJlck9mQmluczsKICAgIHZhciBkZWx0YSA9IG1heCAtIG1pbjsKICAgIHZhciBoaXN0b2dyYW0gPSBuZXcgRmxvYXQzMkFycmF5KG51bWJlck9mQmlucyk7CiAgICBoaXN0b2dyYW0uZmlsbCgwKTsKICAgIHZhciBsZW4gPSBhcnJheS5sZW5ndGg7CgogICAgZm9yICh2YXIgaSA9IG9mZnNldDsgaSA8IGxlbjsgaSArPSBzdGVwKSB7CiAgICAgIHZhciBpZHggPSBNYXRoLmZsb29yKChudW1iZXJPZkJpbnMgLSAxKSAqIChOdW1iZXIoYXJyYXlbaV0pIC0gbWluKSAvIGRlbHRhKTsKICAgICAgaGlzdG9ncmFtW2lkeF0gKz0gMTsKICAgIH0KCiAgICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKG5ldyByZWdpc3RlcldlYndvcmtlcl9fZGVmYXVsdFsnZGVmYXVsdCddLlRyYW5zZmVyYWJsZVJlc3BvbnNlKGhpc3RvZ3JhbSwgW2hpc3RvZ3JhbS5idWZmZXJdKSk7CiAgfSk7Cgp9KHJlZ2lzdGVyV2Vid29ya2VyKSk7Cgo=', null, false);
+var WorkerFactory = createInlineWorkerFactory(/* rollup-plugin-web-worker-loader */function () {
+(function () {
+  '__worker_loader_strict__';
+
+  var register = {exports: {}};
+
+  var _createClass$1 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+  function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  var TinyEmitter$1 = function () {
+    function TinyEmitter() {
+      _classCallCheck$1(this, TinyEmitter);
+
+      Object.defineProperty(this, '__listeners', {
+        value: {},
+        enumerable: false,
+        writable: false
+      });
+    }
+
+    _createClass$1(TinyEmitter, [{
+      key: 'emit',
+      value: function emit(eventName) {
+        if (!this.__listeners[eventName]) return this;
+
+        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+
+        var _iteratorNormalCompletion = true;
+        var _didIteratorError = false;
+        var _iteratorError = undefined;
+
+        try {
+          for (var _iterator = this.__listeners[eventName][Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var handler = _step.value;
+
+            handler.apply(undefined, args);
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+
+        return this;
+      }
+    }, {
+      key: 'once',
+      value: function once(eventName, handler) {
+        var _this = this;
+
+        var once = function once() {
+          _this.off(eventName, once);
+          handler.apply(undefined, arguments);
+        };
+
+        return this.on(eventName, once);
+      }
+    }, {
+      key: 'on',
+      value: function on(eventName, handler) {
+        if (!this.__listeners[eventName]) this.__listeners[eventName] = [];
+
+        this.__listeners[eventName].push(handler);
+
+        return this;
+      }
+    }, {
+      key: 'off',
+      value: function off(eventName, handler) {
+        if (handler) this.__listeners[eventName] = this.__listeners[eventName].filter(function (h) {
+          return h !== handler;
+        });else this.__listeners[eventName] = [];
+
+        return this;
+      }
+    }]);
+
+    return TinyEmitter;
+  }();
+
+  var tinyEmitter = TinyEmitter$1;
+
+  var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+  var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+  function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+  var TinyEmitter = tinyEmitter;
+
+  var MESSAGE_RESULT = 0;
+  var MESSAGE_EVENT = 1;
+
+  var RESULT_ERROR = 0;
+  var RESULT_SUCCESS = 1;
+
+  var DEFAULT_HANDLER = 'main';
+
+  var isPromise = function isPromise(o) {
+    return (typeof o === 'undefined' ? 'undefined' : _typeof(o)) === 'object' && o !== null && typeof o.then === 'function' && typeof o.catch === 'function';
+  };
+
+  function RegisterPromise(fn) {
+    var handlers = _defineProperty({}, DEFAULT_HANDLER, fn);
+    var sendPostMessage = self.postMessage.bind(self);
+
+    var server = new (function (_TinyEmitter) {
+      _inherits(WorkerRegister, _TinyEmitter);
+
+      function WorkerRegister() {
+        _classCallCheck(this, WorkerRegister);
+
+        return _possibleConstructorReturn(this, (WorkerRegister.__proto__ || Object.getPrototypeOf(WorkerRegister)).apply(this, arguments));
+      }
+
+      _createClass(WorkerRegister, [{
+        key: 'emit',
+        value: function emit(eventName) {
+          for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+            args[_key - 1] = arguments[_key];
+          }
+
+          if (args.length == 1 && args[0] instanceof TransferableResponse) {
+            sendPostMessage({ eventName: eventName, args: args }, args[0].transferable);
+          } else {
+            sendPostMessage({ eventName: eventName, args: args });
+          }
+          return this;
+        }
+      }, {
+        key: 'emitLocally',
+        value: function emitLocally(eventName) {
+          var _get2;
+
+          for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+            args[_key2 - 1] = arguments[_key2];
+          }
+
+          (_get2 = _get(WorkerRegister.prototype.__proto__ || Object.getPrototypeOf(WorkerRegister.prototype), 'emit', this)).call.apply(_get2, [this, eventName].concat(args));
+        }
+      }, {
+        key: 'operation',
+        value: function operation(name, handler) {
+          handlers[name] = handler;
+          return this;
+        }
+      }]);
+
+      return WorkerRegister;
+    }(TinyEmitter))();
+
+    var run = function run(messageId, payload, handlerName) {
+
+      var onSuccess = function onSuccess(result) {
+        if (result && result instanceof TransferableResponse) {
+          sendResult(messageId, RESULT_SUCCESS, result.payload, result.transferable);
+        } else {
+          sendResult(messageId, RESULT_SUCCESS, result);
+        }
+      };
+
+      var onError = function onError(e) {
+        sendResult(messageId, RESULT_ERROR, {
+          message: e.message,
+          stack: e.stack
+        });
+      };
+
+      try {
+        var result = runFn(messageId, payload, handlerName);
+        if (isPromise(result)) {
+          result.then(onSuccess).catch(onError);
+        } else {
+          onSuccess(result);
+        }
+      } catch (e) {
+        onError(e);
+      }
+    };
+
+    var runFn = function runFn(messageId, payload, handlerName) {
+      var handler = handlers[handlerName || DEFAULT_HANDLER];
+      if (!handler) throw new Error('Not found handler for this request');
+
+      return handler(payload, sendEvent.bind(null, messageId));
+    };
+
+    var sendResult = function sendResult(messageId, success, payload) {
+      var transferable = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+
+      sendPostMessage([MESSAGE_RESULT, messageId, success, payload], transferable);
+    };
+
+    var sendEvent = function sendEvent(messageId, eventName, payload) {
+      if (!eventName) throw new Error('eventName is required');
+
+      if (typeof eventName !== 'string') throw new Error('eventName should be string');
+
+      sendPostMessage([MESSAGE_EVENT, messageId, eventName, payload]);
+    };
+
+    self.addEventListener('message', function (_ref) {
+      var data = _ref.data;
+
+      if (Array.isArray(data)) {
+        run.apply(undefined, _toConsumableArray(data));
+      } else if (data && data.eventName) {
+        server.emitLocally.apply(server, [data.eventName].concat(_toConsumableArray(data.args)));
+      }
+    });
+
+    return server;
+  }
+
+  var TransferableResponse = function TransferableResponse(payload, transferable) {
+    _classCallCheck(this, TransferableResponse);
+
+    this.payload = payload;
+    this.transferable = transferable;
+  };
+
+  register.exports = RegisterPromise;
+  register.exports.TransferableResponse = TransferableResponse;
+
+  var registerWebworker = register.exports;
+
+  /* eslint-disable */
+  // prettier-ignore
+
+  registerWebworker(function (message, emit) {
+    var array = message.array;
+    var min = message.min;
+    var max = message.max;
+    var offset = message.component || 0;
+    var step = message.numberOfComponents || 1;
+    var numberOfBins = message.numberOfBins;
+    var delta = max - min;
+    var histogram = new Float32Array(numberOfBins);
+    histogram.fill(0);
+    var len = array.length;
+
+    for (var i = offset; i < len; i += step) {
+      var idx = Math.floor((numberOfBins - 1) * (Number(array[i]) - min) / delta);
+      histogram[idx] += 1;
+    }
+
+    return Promise.resolve(new registerWebworker.TransferableResponse(histogram, [histogram.buffer]));
+  });
+
+}());
+}, null);
 /* eslint-enable */
 
 export { WorkerFactory as W };

package/interfaces.d.ts

@@ -1,4 +1,6 @@
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
 import { vtkPipelineConnection } from '@kitware/vtk.js/types';
 
 /**
@@ -32,48 +34,88 @@ export interface vtkOutputPort {
  * vtkAlgorithm API
  */
 export interface vtkAlgorithm {
+
 	/**
-	 * @param dataset
-	 * @param port (default 0)
+	 * Assign a data object as input.
+	 * @param {vtkPolyData} dataset 
+	 * @param {Number} [port] The port number (default 0).
 	 */
-	setInputData(dataset: any, port?: number): void;
+	setInputData(dataset: vtkPolyData, port?: number): void;
+
 	/**
-	 * @param port (default 0)
+	 * @param {Number} [port] The port number (default 0).
 	 */
 	getInputData(port?: number): any;
+
 	/**
 	 * @param outputPort
-	 * @param port (default 0)
+	 * @param {Number} [port] The port number (default 0).
 	 */
 	setInputConnection(outputPort: vtkPipelineConnection, port?: number): void;
+
 	/**
-	 * @param port (default 0)
+	 * @param {Number} [port] The port number (default 0).
 	 */
 	getInputConnection(port?: number): vtkPipelineConnection;
+
+	/**
+	 * Add a connection to the given input port index.
+	 * @param {vtkPipelineConnection} outputPort 
+	 */
 	addInputConnection(outputPort: vtkPipelineConnection): void;
+
+	/**
+	 * 
+	 * @param dataset 
+	 */
 	addInputData(dataset: any): void;
+
 	/**
-	 * @param port (default 0)
+	 * Get the data object that will contain the algorithm output for the given
+	 * port.
+	 * @param {Number} [port] The port number (default 0).
+	 */
+	getOutputData(port?: number): vtkImageData | vtkPolyData;
+
+	/**
+	 * 
 	 */
-	getOutputData(port?: number): any;
 	shouldUpdate(): boolean;
+
 	/**
-	 * @param port (default 0)
+	 * Get a proxy object corresponding to the given output port of this
+	 * algorithm. 
+	 * @param {Number} [port] The port number (default 0).
 	 */
 	getOutputPort(port?: number): vtkPipelineConnection;
+
+	/**
+	 * Bring this algorithm's outputs up-to-date.
+	 */
 	update(): void;
+
+	/**
+	 * Get the number of input ports used by the algorithm.
+	 */
 	getNumberOfInputPorts(): number;
+
+	/**
+	 * Get the number of output ports provided by the algorithm.
+	 */
 	getNumberOfOutputPorts(): number;
+
 	/**
-	 * @param port (default 0)
+	 * Get the actual data array for the input array sepcified by idx.
+	 * @param {Number} port (default 0)
 	 */
 	getInputArrayToProcess(inputPort?: number): vtkDataArray;
+
 	/**
-	 *
-	 * @param inputPort
-	 * @param arrayName
-	 * @param fieldAssociation
-	 * @param attributeType (default 'Scalars')
+	 * Set the input data arrays that this algorithm will process. 
+	 * @param {Number} inputPort The port number.
+	 * @param {String} arrayName The name of the array.
+	 * @param {String} fieldAssociation The name of the association field.
+	 * @param {String} attributeType (default 'Scalars')
 	 */
 	setInputArrayToProcess(
 		inputPort: number,
@@ -87,9 +129,9 @@ export interface vtkAlgorithm {
 * Base vtkClass which provides MTime tracking and class infrastructure
 */
 export interface vtkObject {
+	
 	/**
 	 * Allow to check if that object was deleted (.delete() was called before).
-	 *
 	 * @returns true if delete() was previously called
 	 */
 	isDeleted(): boolean;
@@ -137,14 +179,14 @@ export interface vtkObject {
 	 * Generic method to set many fields at one.
 	 *
 	 * For example calling the following function
-	 * ```
+	 * ```js
 	 * changeDetected = sphereSourceInstance.set({
 	 *    phiResolution: 10,
 	 *    thetaResolution: 20,
 	 * });
 	 * ```
 	 * will be equivalent of calling
-	 * ```
+	 * ```js
 	 * changeDetected += sphereSourceInstance.setPhiResolution(10);
 	 * changeDetected += sphereSourceInstance.setThetaResolution(20);
 	 * changeDetected = !!changeDetected;
@@ -157,9 +199,9 @@ export interface vtkObject {
 	 * If `noFunction` is set to true, the field will be set directly on the model
 	 * without calling the `set${FieldName}()` method.
 	 *
-	 * @param map (default: {}) Object capturing the set of fieldNames and associated values to set.
-	 * @param noWarning (default: false) Boolean to disable any warning.
-	 * @param noFunctions (default: false) Boolean to skip any function execution and rely on only setting the fields on the model.
+	 * @param [map] (default: {}) Object capturing the set of fieldNames and associated values to set.
+	 * @param [noWarning] (default: false) Boolean to disable any warning.
+	 * @param [noFunctions] (default: false) Boolean to skip any function execution and rely on only setting the fields on the model.
 	 * @return true if a change was actually performed. False otherwise when the value provided were equal to the ones already set inside the instance.
 	 */
 	set(map?: object, noWarning?: boolean, noFunction?: boolean): boolean;
@@ -215,15 +257,15 @@ export interface vtkObject {
 	/**
 	 * Try to copy the state of the other to ourselves by just using references.
 	 *
-	 * @param other instance to copy the reference from
-	 * @param debug (default: false) if true feedback will be provided when mismatch happen
+	 * @param {vtkObject} other instance to copy the reference from
+	 * @param {Boolean} [debug] (default: false) if true feedback will be provided when mismatch happen
 	 */
 	shallowCopy(other: vtkObject, debug?: boolean): void;
 }
 
 export interface vtkProperty {
 	name: string;
-	children?: Array<vtkProperty>;
+	children?: vtkProperty[];
 }
 
 export interface vtkPropertyDomain {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "21.1.4",
+  "version": "21.2.2",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",
@@ -131,7 +131,7 @@
     "xml2js": "0.4.23"
   },
   "peerDependencies": {
-    "wslink": "1.0.7"
+    "wslink": "^1.1.0"
   },
   "scripts": {
     "validate": "prettier --config ./prettier.config.js --list-different \"Sources/**/*.js\" \"Examples/**/*.js\"",

package/types.d.ts

@@ -17,9 +17,12 @@ declare type Extent = [number, number, number, number, number, number];
 declare type Placement = 'top' | 'left' | 'right' | 'bottom';
 declare type Size = [number, number];
 declare type Range = [number, number];
-declare type Point = [number, number, number];
 declare type Vector2 = [number, number];
 declare type Vector3 = [number, number, number];
+/**
+ * @deprecated The `Point` type is depracted, please use `Vector3` instead.
+ */
+declare type Point = Vector3;
 declare type HSLColor = [number, number, number];
 declare type HSVColor = [number, number, number];
 declare type RGBColor = [number, number, number];

package/_virtual/rollup-plugin-web-worker-loader__helper__browser__createBase64WorkerFactory.js

@@ -1,31 +0,0 @@
-function decodeBase64(base64, enableUnicode) {
-    var binaryString = atob(base64);
-    if (enableUnicode) {
-        var binaryView = new Uint8Array(binaryString.length);
-        for (var i = 0, n = binaryString.length; i < n; ++i) {
-            binaryView[i] = binaryString.charCodeAt(i);
-        }
-        return String.fromCharCode.apply(null, new Uint16Array(binaryView.buffer));
-    }
-    return binaryString;
-}
-
-function createURL(base64, sourcemapArg, enableUnicodeArg) {
-    var sourcemap = sourcemapArg === undefined ? null : sourcemapArg;
-    var enableUnicode = enableUnicodeArg === undefined ? false : enableUnicodeArg;
-    var source = decodeBase64(base64, enableUnicode);
-    var start = source.indexOf('\n', 10) + 1;
-    var body = source.substring(start) + (sourcemap ? '\/\/# sourceMappingURL=' + sourcemap : '');
-    var blob = new Blob([body], { type: 'application/javascript' });
-    return URL.createObjectURL(blob);
-}
-
-function createBase64WorkerFactory(base64, sourcemapArg, enableUnicodeArg) {
-    var url;
-    return function WorkerFactory(options) {
-        url = url || createURL(base64, sourcemapArg, enableUnicodeArg);
-        return new Worker(url, options);
-    };
-}
-
-export { createBase64WorkerFactory as c };