@kitware/vtk.js 28.10.2 → 28.11.1

package/IO/Legacy/LegacyAsciiParser.js

@@ -1,8 +1,7 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
-var METHOD_MAPPING = {
+const METHOD_MAPPING = {
   POINTS: 'getPoints',
   VERTICES: 'getVerts',
   LINES: 'getLines',
@@ -12,7 +11,7 @@ var METHOD_MAPPING = {
   CELL_DATA: 'getCellData',
   FIELD: 'getFieldData'
 };
-var DATATYPES = {
+const DATATYPES = {
   bit: Uint8Array,
   unsigned_char: Uint8Array,
   char: Int8Array,
@@ -25,7 +24,7 @@ var DATATYPES = {
   float: Float32Array,
   double: Float64Array
 };
-var REGISTER_MAPPING = {
+const REGISTER_MAPPING = {
   SCALARS: 'addArray',
   COLOR_SCALARS: 'addArray',
   VECTORS: 'setVectors',
@@ -34,91 +33,71 @@ var REGISTER_MAPPING = {
   TENSORS: 'setTensors',
   FIELD: 'addArray'
 };
-
 function createArrayHandler(array, setData, nbComponents) {
-  var offset = 0;
-
+  let offset = 0;
   function fillWith(line) {
-    line.split(' ').forEach(function (token) {
+    line.split(' ').forEach(token => {
       if (token.length) {
         array[offset++] = Number(token);
       }
     });
-
     if (offset < array.length) {
       return true;
     }
-
     setData(array, nbComponents);
     return false;
   }
-
   return fillWith;
 }
-
-var GENERIC_CELL_HANDLER = {
-  init: function init(line, dataModel) {
-    var _line$split = line.split(' '),
-        _line$split2 = _slicedToArray(_line$split, 3),
-        name = _line$split2[0],
-        nbCells = _line$split2[1],
-        nbValues = _line$split2[2];
-
-    var cellArray = dataModel.dataset[METHOD_MAPPING[name]]();
+const GENERIC_CELL_HANDLER = {
+  init(line, dataModel) {
+    const [name, nbCells, nbValues] = line.split(' ');
+    const cellArray = dataModel.dataset[METHOD_MAPPING[name]]();
     cellArray.set({
       numberOfCells: Number(nbCells)
     }, true); // Force numberOfCells update
-
     dataModel.arrayHandler = createArrayHandler(new Uint32Array(Number(nbValues)), cellArray.setData, 1);
     return true;
   },
-  parse: function parse(line, dataModel) {
+  parse(line, dataModel) {
     return dataModel.arrayHandler(line);
   }
 };
-var TYPE_PARSER = {
+const TYPE_PARSER = {
   DATASET: {
-    init: function init(line, datamodel) {
-      var type = line.split(' ')[1];
-
+    init(line, datamodel) {
+      const type = line.split(' ')[1];
       switch (type) {
         case 'POLYDATA':
           datamodel.dataset = vtkPolyData.newInstance();
           break;
-
         default:
-          console.error("Dataset of type ".concat(type, " not supported"));
+          console.error(`Dataset of type ${type} not supported`);
       }
-
       return false;
     },
-    parse: function parse(line, datamodel) {
+    parse(line, datamodel) {
       return false;
     }
   },
   POINTS: {
-    init: function init(line, dataModel) {
-      var _line$split3 = line.split(' '),
-          _line$split4 = _slicedToArray(_line$split3, 3),
-          name = _line$split4[0],
-          size = _line$split4[1],
-          type = _line$split4[2];
-
-      var array = type === 'float' ? new Float32Array(3 * Number(size)) : new Float64Array(3 * Number(size));
-      var dataArray = dataModel.dataset.getPoints();
+    init(line, dataModel) {
+      const [name, size, type] = line.split(' ');
+      const array = type === 'float' ? new Float32Array(3 * Number(size)) : new Float64Array(3 * Number(size));
+      const dataArray = dataModel.dataset.getPoints();
       dataArray.setName(name);
       dataModel.arrayHandler = createArrayHandler(array, dataArray.setData, 3);
       return true;
     },
-    parse: function parse(line, dataModel) {
+    parse(line, dataModel) {
       return dataModel.arrayHandler(line);
     }
   },
   METADATA: {
-    init: function init(line, dataModel) {
+    init(line, dataModel) {
       return true;
     },
-    parse: function parse(line, dataModel) {
+    parse(line, dataModel) {
       return !!line.length;
     }
   },
@@ -127,206 +106,166 @@ var TYPE_PARSER = {
   TRIANGLE_STRIPS: GENERIC_CELL_HANDLER,
   POLYGONS: GENERIC_CELL_HANDLER,
   POINT_DATA: {
-    init: function init(line, dataModel) {
+    init(line, dataModel) {
       dataModel.POINT_DATA = Number(line.split(' ')[1]);
       dataModel.activeFieldLocation = 'POINT_DATA';
       return false;
     },
-    parse: function parse(line, dataModel) {
+    parse(line, dataModel) {
       return false;
     }
   },
   CELL_DATA: {
-    init: function init(line, dataModel) {
+    init(line, dataModel) {
       dataModel.CELL_DATA = Number(line.split(' ')[1]);
       dataModel.activeFieldLocation = 'CELL_DATA';
       return false;
     },
-    parse: function parse(line, dataModel) {
+    parse(line, dataModel) {
       return false;
     }
   },
   SCALARS: {
-    init: function init(line, dataModel) {
-      var _line$split5 = line.split(' '),
-          _line$split6 = _slicedToArray(_line$split5, 4),
-          type = _line$split6[0],
-          name = _line$split6[1],
-          dataType = _line$split6[2],
-          numComp = _line$split6[3];
-
-      var numOfComp = Number(numComp) > 0 ? Number(numComp) : 1;
-      var size = dataModel[dataModel.activeFieldLocation] * numOfComp;
-      var array = new DATATYPES[dataType](size);
-      var dataArray = vtkDataArray.newInstance({
-        name: name,
+    init(line, dataModel) {
+      const [type, name, dataType, numComp] = line.split(' ');
+      const numOfComp = Number(numComp) > 0 ? Number(numComp) : 1;
+      const size = dataModel[dataModel.activeFieldLocation] * numOfComp;
+      const array = new DATATYPES[dataType](size);
+      const dataArray = vtkDataArray.newInstance({
+        name,
         empty: true
       });
       dataModel.dataset[METHOD_MAPPING[dataModel.activeFieldLocation]]()[REGISTER_MAPPING[type]](dataArray);
       dataModel.arrayHandler = createArrayHandler(array, dataArray.setData, numOfComp);
       return true;
     },
-    parse: function parse(line, dataModel) {
+    parse(line, dataModel) {
       if (line.split(' ')[0] === 'LOOKUP_TABLE') {
         return true;
       }
-
       return dataModel.arrayHandler(line);
     }
   },
   COLOR_SCALARS: {
-    init: function init(line, dataModel) {
-      var _line$split7 = line.split(' '),
-          _line$split8 = _slicedToArray(_line$split7, 3),
-          type = _line$split8[0],
-          name = _line$split8[1],
-          numComp = _line$split8[2];
-
-      var numOfComp = Number(numComp) > 0 ? Number(numComp) : 1;
-      var size = dataModel[dataModel.activeFieldLocation] * numOfComp;
-      var array = new Uint8Array(size);
-      var dataArray = vtkDataArray.newInstance({
-        name: name,
+    init(line, dataModel) {
+      const [type, name, numComp] = line.split(' ');
+      const numOfComp = Number(numComp) > 0 ? Number(numComp) : 1;
+      const size = dataModel[dataModel.activeFieldLocation] * numOfComp;
+      const array = new Uint8Array(size);
+      const dataArray = vtkDataArray.newInstance({
+        name,
         empty: true
       });
       dataModel.dataset[METHOD_MAPPING[dataModel.activeFieldLocation]]()[REGISTER_MAPPING[type]](dataArray);
       dataModel.arrayHandler = createArrayHandler(array, dataArray.setData, numOfComp);
       return true;
     },
-    parse: function parse(line, dataModel) {
+    parse(line, dataModel) {
       if (line.split(' ')[0] === 'LOOKUP_TABLE') {
         return true;
       }
-
       return dataModel.arrayHandler(line);
     }
   },
   VECTORS: {
-    init: function init(line, dataModel) {
-      var _line$split9 = line.split(' '),
-          _line$split10 = _slicedToArray(_line$split9, 3),
-          type = _line$split10[0],
-          name = _line$split10[1],
-          dataType = _line$split10[2];
-
-      var size = dataModel[dataModel.activeFieldLocation] * 3;
-      var array = new DATATYPES[dataType](size);
-      var dataArray = vtkDataArray.newInstance({
-        name: name,
+    init(line, dataModel) {
+      const [type, name, dataType] = line.split(' ');
+      const size = dataModel[dataModel.activeFieldLocation] * 3;
+      const array = new DATATYPES[dataType](size);
+      const dataArray = vtkDataArray.newInstance({
+        name,
         empty: true
       });
       dataModel.dataset[METHOD_MAPPING[dataModel.activeFieldLocation]]()[REGISTER_MAPPING[type]](dataArray);
       dataModel.arrayHandler = createArrayHandler(array, dataArray.setData, 3);
       return true;
     },
-    parse: function parse(line, dataModel) {
+    parse(line, dataModel) {
       return dataModel.arrayHandler(line);
     }
   },
   NORMALS: {
-    init: function init(line, dataModel) {
-      var _line$split11 = line.split(' '),
-          _line$split12 = _slicedToArray(_line$split11, 2),
-          type = _line$split12[0],
-          name = _line$split12[1];
-
-      var size = dataModel[dataModel.activeFieldLocation] * 3;
-      var array = new Float32Array(size);
-      var dataArray = vtkDataArray.newInstance({
-        name: name,
+    init(line, dataModel) {
+      const [type, name] = line.split(' ');
+      const size = dataModel[dataModel.activeFieldLocation] * 3;
+      const array = new Float32Array(size);
+      const dataArray = vtkDataArray.newInstance({
+        name,
         empty: true
       });
       dataModel.dataset[METHOD_MAPPING[dataModel.activeFieldLocation]]()[REGISTER_MAPPING[type]](dataArray);
       dataModel.arrayHandler = createArrayHandler(array, dataArray.setData, 3);
       return true;
     },
-    parse: function parse(line, dataModel) {
+    parse(line, dataModel) {
       return dataModel.arrayHandler(line);
     }
   },
   TEXTURE_COORDINATES: {
-    init: function init(line, dataModel) {
-      var _line$split13 = line.split(' '),
-          _line$split14 = _slicedToArray(_line$split13, 4),
-          type = _line$split14[0],
-          name = _line$split14[1],
-          numberOfComponents = _line$split14[2],
-          dataType = _line$split14[3];
-
-      var size = dataModel[dataModel.activeFieldLocation] * Number(numberOfComponents);
-      var array = new DATATYPES[dataType](size);
-      var dataArray = vtkDataArray.newInstance({
-        name: name,
+    init(line, dataModel) {
+      const [type, name, numberOfComponents, dataType] = line.split(' ');
+      const size = dataModel[dataModel.activeFieldLocation] * Number(numberOfComponents);
+      const array = new DATATYPES[dataType](size);
+      const dataArray = vtkDataArray.newInstance({
+        name,
         empty: true
       });
       dataModel.dataset[METHOD_MAPPING[dataModel.activeFieldLocation]]()[REGISTER_MAPPING[type]](dataArray);
       dataModel.arrayHandler = createArrayHandler(array, dataArray.setData, 3);
       return true;
     },
-    parse: function parse(line, dataModel) {
+    parse(line, dataModel) {
       return dataModel.arrayHandler(line);
     }
   },
   TENSORS: {
-    init: function init(line, dataModel) {
-      var _line$split15 = line.split(' '),
-          _line$split16 = _slicedToArray(_line$split15, 3),
-          type = _line$split16[0],
-          name = _line$split16[1],
-          dataType = _line$split16[2];
-
-      var size = dataModel[dataModel.activeFieldLocation] * 9;
-      var array = new DATATYPES[dataType](size);
-      var dataArray = vtkDataArray.newInstance({
-        name: name,
+    init(line, dataModel) {
+      const [type, name, dataType] = line.split(' ');
+      const size = dataModel[dataModel.activeFieldLocation] * 9;
+      const array = new DATATYPES[dataType](size);
+      const dataArray = vtkDataArray.newInstance({
+        name,
         empty: true
       });
       dataModel.dataset[METHOD_MAPPING[dataModel.activeFieldLocation]]()[REGISTER_MAPPING[type]](dataArray);
       dataModel.arrayHandler = createArrayHandler(array, dataArray.setData, 9);
       return true;
     },
-    parse: function parse(line, dataModel) {
+    parse(line, dataModel) {
       return dataModel.arrayHandler(line);
     }
   }
 };
-
 function getParser(line, dataModel) {
-  var tokens = line.split(' ');
+  const tokens = line.split(' ');
   return TYPE_PARSER[tokens[0]];
 }
-
 function parseLegacyASCII(content) {
-  var dataModel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var parser = null;
-  var separatorRegExp = /\r?\n/;
-  var separatorRes = separatorRegExp.exec(content);
-  var separator = separatorRes !== null ? separatorRes[0] : null;
-  content.split(separator).forEach(function (line, index) {
+  let dataModel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let parser = null;
+  const separatorRegExp = /\r?\n/;
+  const separatorRes = separatorRegExp.exec(content);
+  const separator = separatorRes !== null ? separatorRes[0] : null;
+  content.split(separator).forEach((line, index) => {
     if (index < 2) {
       return;
     }
-
     if (!parser) {
       parser = getParser(line);
-
       if (!parser) {
         return;
       }
-
       parser = parser.init(line, dataModel) ? parser : null;
       return;
     }
-
     if (parser && !parser.parse(line, dataModel)) {
       parser = null;
     }
   });
   return dataModel;
 }
-
 var vtkLegacyAsciiParser = {
-  parseLegacyASCII: parseLegacyASCII
+  parseLegacyASCII
 };
 
 export { vtkLegacyAsciiParser as default };

package/IO/Legacy/PolyDataReader.js

@@ -1,4 +1,4 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import DataAccessHelper from '../Core/DataAccessHelper.js';
 import vtkLegacyAsciiParser from './LegacyAsciiParser.js';
 import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
@@ -6,103 +6,115 @@ import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HttpDataAccessHelper'; // HTTP + zip
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HtmlDataAccessHelper'; // html + base64 + zip
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/JSZipDataAccessHelper'; // zip
+
 // ----------------------------------------------------------------------------
 // vtkPolyDataReader methods
 // ----------------------------------------------------------------------------
 
 function vtkPolyDataReader(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkPolyDataReader'); // Create default dataAccessHelper if not available
+  model.classHierarchy.push('vtkPolyDataReader');
 
+  // Create default dataAccessHelper if not available
   if (!model.dataAccessHelper) {
     model.dataAccessHelper = DataAccessHelper.get('http');
-  } // Internal method to fetch Array
-
+  }
 
+  // Internal method to fetch Array
   function fetchData(url) {
-    var compression = model.compression,
-        progressCallback = model.progressCallback;
+    const {
+      compression,
+      progressCallback
+    } = model;
     return model.dataAccessHelper.fetchText(publicAPI, url, {
-      compression: compression,
-      progressCallback: progressCallback
+      compression,
+      progressCallback
     });
-  } // Set DataSet url
-
+  }
 
+  // Set DataSet url
   publicAPI.setUrl = function (url) {
-    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    model.url = url; // Remove the file in the URL
+    let option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    model.url = url;
 
-    var path = url.split('/');
+    // Remove the file in the URL
+    const path = url.split('/');
     path.pop();
     model.baseURL = path.join('/');
-    model.compression = option.compression; // Fetch metadata
+    model.compression = option.compression;
 
+    // Fetch metadata
     return publicAPI.loadData({
       progressCallback: option.progressCallback
     });
-  }; // Fetch the actual data arrays
-
+  };
 
+  // Fetch the actual data arrays
   publicAPI.loadData = function () {
-    var promise = fetchData(model.url);
+    const promise = fetchData(model.url);
     promise.then(publicAPI.parseAsText);
     return promise;
   };
-
-  publicAPI.parseAsText = function (content) {
+  publicAPI.parseAsText = content => {
     if (!content) {
       return;
     }
-
     if (content !== model.parseData) {
       publicAPI.modified();
     } else {
       return;
     }
-
     model.parseData = content;
     model.output[0] = vtkLegacyAsciiParser.parseLegacyASCII(model.parseData).dataset;
   };
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     publicAPI.parseAsText(model.parseData);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {// baseURL: null,
+const DEFAULT_VALUES = {
+  // baseURL: null,
   // dataAccessHelper: null,
   // url: null,
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['url', 'baseURL']);
   macro.setGet(publicAPI, model, ['dataAccessHelper']);
-  macro.algo(publicAPI, model, 0, 1); // vtkPolyDataReader methods
+  macro.algo(publicAPI, model, 0, 1);
 
-  vtkPolyDataReader(publicAPI, model); // To support destructuring
+  // vtkPolyDataReader methods
+  vtkPolyDataReader(publicAPI, model);
 
+  // To support destructuring
   if (!model.compression) {
     model.compression = null;
   }
-
   if (!model.progressCallback) {
     model.progressCallback = null;
   }
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkPolyDataReader'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkPolyDataReader');
+
+// ----------------------------------------------------------------------------
 
 var vtkPolyDataReader$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkPolyDataReader$1 as default, extend, newInstance };

package/IO/Legacy.js

@@ -2,8 +2,8 @@ import vtkLegacyAsciiParser from './Legacy/LegacyAsciiParser.js';
 import vtkPolyDataReader from './Legacy/PolyDataReader.js';
 
 var Legacy = {
-  vtkLegacyAsciiParser: vtkLegacyAsciiParser,
-  vtkPolyDataReader: vtkPolyDataReader
+  vtkLegacyAsciiParser,
+  vtkPolyDataReader
 };
 
 export { Legacy as default };