@kitware/vtk.js 28.10.2 → 28.11.0

package/IO/Core/HttpDataSetSeriesReader.js

@@ -1,7 +1,7 @@
 import '../../Common/DataModel/ImageData.js';
 import '../../Common/DataModel/PolyData.js';
 import vtk from '../../vtk.js';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import DataAccessHelper from './DataAccessHelper.js';
 import vtkHttpDataSetReader from './HttpDataSetReader.js';
 import './DataAccessHelper/LiteHttpDataAccessHelper.js';
@@ -11,69 +11,69 @@ import './DataAccessHelper/LiteHttpDataAccessHelper.js';
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HtmlDataAccessHelper'; // html + base64 + zip
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/JSZipDataAccessHelper'; // zip
 
-var HTTP_DATA_ACCESS = DataAccessHelper.get('http'); // ----------------------------------------------------------------------------
+const HTTP_DATA_ACCESS = DataAccessHelper.get('http');
+
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
 function processDataSet(publicAPI, model, dataset, resolve, reject, loadData) {
   model.readers = [];
-  var pendingPromises = [];
-  dataset.series.forEach(function (timeStep) {
-    var newReader = vtkHttpDataSetReader.newInstance({
+  const pendingPromises = [];
+  dataset.series.forEach(timeStep => {
+    const newReader = vtkHttpDataSetReader.newInstance({
       fetchGzip: model.fetchGzip,
       dataAccessHelper: model.dataAccessHelper
     });
-    pendingPromises.push(newReader.setUrl("".concat(model.baseURL, "/").concat(timeStep.url), {
-      loadData: loadData
+    pendingPromises.push(newReader.setUrl(`${model.baseURL}/${timeStep.url}`, {
+      loadData
     }));
     model.readers.push({
       timeStep: timeStep.timeStep,
       reader: newReader
     });
   });
-  return Promise.all(pendingPromises).then(function () {
-    var range = publicAPI.getTimeRange();
-
+  return Promise.all(pendingPromises).then(() => {
+    const range = publicAPI.getTimeRange();
     if (range && range.length !== 0) {
       publicAPI.setUpdateTimeStep(range[0]);
     }
-
     resolve(publicAPI);
-  }, function (error) {
+  }, error => {
     reject(error);
   });
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkHttpDataSetSeriesReader methods
 // ----------------------------------------------------------------------------
 
-
 function vtkHttpDataSetSeriesReader(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkHttpDataSetSeriesReader'); // Empty output by default
+  model.classHierarchy.push('vtkHttpDataSetSeriesReader');
 
+  // Empty output by default
   model.output[0] = vtk({
     vtkClass: 'vtkPolyData'
-  }); // Create default dataAccessHelper if not available
+  });
 
+  // Create default dataAccessHelper if not available
   if (!model.dataAccessHelper) {
     model.dataAccessHelper = HTTP_DATA_ACCESS;
   }
-
   model.currentReader = null;
-
   publicAPI.updateMetaData = function () {
-    var loadData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-
+    let loadData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     if (model.compression === 'zip') {
-      return new Promise(function (resolve, reject) {
-        HTTP_DATA_ACCESS.fetchBinary(model.baseURL).then(function (zipContent) {
+      return new Promise((resolve, reject) => {
+        HTTP_DATA_ACCESS.fetchBinary(model.baseURL).then(zipContent => {
           model.dataAccessHelper = DataAccessHelper.get('zip', {
-            zipContent: zipContent,
-            callback: function callback(zip) {
+            zipContent,
+            callback: zip => {
               model.baseURL = '';
-              model.dataAccessHelper.fetchJSON(publicAPI, 'index.json').then(function (dataset) {
+              model.dataAccessHelper.fetchJSON(publicAPI, 'index.json').then(dataset => {
                 processDataSet(publicAPI, model, dataset, resolve, reject, loadData);
-              }, function (error) {
+              }, error => {
                 reject(error);
               });
             }
@@ -81,119 +81,108 @@ function vtkHttpDataSetSeriesReader(publicAPI, model) {
         });
       });
     }
-
-    return new Promise(function (resolve, reject) {
-      model.dataAccessHelper.fetchJSON(publicAPI, model.url).then(function (dataset) {
-        return processDataSet(publicAPI, model, dataset, resolve, reject, loadData);
-      }, function (error) {
+    return new Promise((resolve, reject) => {
+      model.dataAccessHelper.fetchJSON(publicAPI, model.url).then(dataset => processDataSet(publicAPI, model, dataset, resolve, reject, loadData), error => {
         reject(error);
       });
     });
   };
-
   publicAPI.setUrl = function (url) {
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     if (!url.endsWith('index.json') && !options.fullpath) {
       model.baseURL = url;
-      model.url = "".concat(url, "/index.json");
+      model.url = `${url}/index.json`;
     } else {
-      model.url = url; // Remove the file in the URL
+      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 = options.compression;
     return publicAPI.updateMetaData(options.loadData);
   };
-
-  publicAPI.getTimeSteps = function () {
-    return model.readers.map(function (reader) {
-      return reader.timeStep;
-    }).sort();
-  };
-
-  publicAPI.getTimeRange = function () {
-    var timeSteps = publicAPI.getTimeSteps();
-    var length = timeSteps.length;
-
+  publicAPI.getTimeSteps = () => model.readers.map(reader => reader.timeStep).sort();
+  publicAPI.getTimeRange = () => {
+    const timeSteps = publicAPI.getTimeSteps();
+    const length = timeSteps.length;
     if (length >= 1) {
       return [timeSteps[0], timeSteps[length - 1]];
     }
-
     return [];
   };
-
-  publicAPI.setUpdateTimeStep = function (timeStep) {
-    var reader = model.readers.reduce(function (newReader, currentReader) {
+  publicAPI.setUpdateTimeStep = timeStep => {
+    const reader = model.readers.reduce((newReader, currentReader) => {
       if (currentReader.timeStep <= timeStep) {
         return currentReader;
       }
-
       return newReader;
     });
-
     if (reader === undefined) {
       return;
     }
-
     model.currentReader = reader.reader;
     model.output[0] = model.currentReader.getOutputData();
     model.output[0].modified();
     publicAPI.modified();
   };
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     if (model.currentReader) {
       outData[0] = model.currentReader.getOutputData();
     }
-  }; // Toggle arrays to load
-
+  };
 
+  // Toggle arrays to load
   publicAPI.enableArray = function (location, name) {
-    var enable = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-
+    let enable = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     if (model.currentReader) {
       model.currentReader.reader.enableArray(location, name, enable);
     }
   };
-
-  publicAPI.loadData = function () {
+  publicAPI.loadData = () => {
     if (model.currentReader) {
       model.currentReader.reader.loadData();
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   fetchGzip: false,
   url: null,
   baseURL: null,
   dataAccessHelper: 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.set(publicAPI, model, ['dataAccessHelper']);
-  macro.algo(publicAPI, model, 0, 1); // Object methods
+  macro.algo(publicAPI, model, 0, 1);
 
+  // Object methods
   vtkHttpDataSetSeriesReader(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkHttpDataSetSeriesReader'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkHttpDataSetSeriesReader');
+
+// ----------------------------------------------------------------------------
 
 var vtkHttpDataSetSeriesReader$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkHttpDataSetSeriesReader$1 as default, extend, newInstance };