@pirireis/webglobeplugins 0.9.11 → 0.9.12

package/util/heatwavedatamanager/pointcoordinatesdatacalculator.js

@@ -3,12 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var pointcoordsmeta_1 = __importDefault(require("./pointcoordsmeta"));
-var pointObject = function (long, lat, posIndex, callback) {
-    return { long: long, lat: lat, posIndex: posIndex, callback: callback };
+const pointcoordsmeta_1 = __importDefault(require("./pointcoordsmeta"));
+const pointObject = (long, lat, posIndex, callback) => {
+    return { long, lat, posIndex, callback };
 };
-var PointCoordinatesDataCalculator = /** @class */ (function () {
-    function PointCoordinatesDataCalculator(bbox, width, height) {
+class PointCoordinatesDataCalculator {
+    constructor(bbox, width, height) {
         this._pointObjects = {};
         this._ratio = 0.0;
         this._bbox = bbox;
@@ -25,51 +25,49 @@ var PointCoordinatesDataCalculator = /** @class */ (function () {
      * @param {*} long
      * @param {*} callback | callback(data0, data1, interpolated)
      */
-    PointCoordinatesDataCalculator.prototype.registerPoint = function (key, long, lat, callback) {
+    registerPoint(key, long, lat, callback) {
         if (key in this._pointObjects) {
             console.warn("key already registered, old one is unregistered");
             this.unregisterPoint(key);
         }
         if (!this._isInBBox(long, lat))
             return false;
-        var meta = this._metaCalculater.getFlooredMeta(long, lat);
+        const meta = this._metaCalculater.getFlooredMeta(long, lat);
         this._pointObjects[key] = pointObject(long, lat, meta.index, callback);
         if (this._texture0 && this._texture1) {
-            var _a = this._findAPoint(meta.index), data0 = _a.data0, data1 = _a.data1, interpolated = _a.interpolated;
+            const { data0, data1, interpolated } = this._findAPoint(meta.index);
             callback(data0, data1, interpolated);
         }
         return true;
-    };
-    PointCoordinatesDataCalculator.prototype._isInBBox = function (long, lat) {
+    }
+    _isInBBox(long, lat) {
         return lat >= this._bbox[1] && lat <= this._bbox[3] && long >= this._bbox[0] && long <= this._bbox[2];
-    };
-    PointCoordinatesDataCalculator.prototype.unregisterPoint = function (key) {
+    }
+    unregisterPoint(key) {
         if (!(key in this._pointObjects))
             return false;
         delete this._pointObjects[key];
         return true;
-    };
-    PointCoordinatesDataCalculator.prototype.updatePoint = function (key, long, lat) {
+    }
+    updatePoint(key, long, lat) {
         if (!(key in this._pointObjects))
             return false;
         if (!this._isInBBox(long, lat))
             return false;
         this._pointObjects[key].long = long;
         this._pointObjects[key].lat = lat;
-        var meta = this._metaCalculater.getFlooredMeta(long, lat);
+        const meta = this._metaCalculater.getFlooredMeta(long, lat);
         this._pointObjects[key].posIndex = meta.index;
-        var _a = this._findAPoint(meta.index), data0 = _a.data0, data1 = _a.data1, interpolated = _a.interpolated;
+        const { data0, data1, interpolated } = this._findAPoint(meta.index);
         this._pointObjects[key].callback(data0, data1, interpolated);
         return true;
-    };
+    }
     /**
      * @param {Number} ratio 0-1
      * @param {} textureData0
      * @param {*} textureData1
      */
-    PointCoordinatesDataCalculator.prototype.updateData = function (ratio, textureData0, textureData1) {
-        if (textureData0 === void 0) { textureData0 = null; }
-        if (textureData1 === void 0) { textureData1 = null; }
+    updateData(ratio, textureData0 = null, textureData1 = null) {
         if (!textureData0 && !textureData1) {
             this._pushPointCallBackEmpty();
             return;
@@ -80,31 +78,30 @@ var PointCoordinatesDataCalculator = /** @class */ (function () {
         }
         this._ratio = ratio;
         this._pushPointCallbackAll();
-    };
-    PointCoordinatesDataCalculator.prototype._findAPoint = function (posIndex) {
-        var data0 = this._texture0[posIndex];
-        var data1 = this._texture1[posIndex];
-        var interpolated = data0 * (1 - this._ratio) + data1 * this._ratio;
-        return { data0: data0, data1: data1, interpolated: interpolated };
-    };
-    PointCoordinatesDataCalculator.prototype._pushPointCallbackAll = function () {
-        for (var key in this._pointObjects) {
-            var _a = this._pointObjects[key], posIndex = _a.posIndex, callback = _a.callback;
-            var _b = this._findAPoint(posIndex), data0 = _b.data0, data1 = _b.data1, interpolated = _b.interpolated;
+    }
+    _findAPoint(posIndex) {
+        const data0 = this._texture0[posIndex];
+        const data1 = this._texture1[posIndex];
+        const interpolated = data0 * (1 - this._ratio) + data1 * this._ratio;
+        return { data0, data1, interpolated };
+    }
+    _pushPointCallbackAll() {
+        for (const key in this._pointObjects) {
+            const { posIndex, callback } = this._pointObjects[key];
+            const { data0, data1, interpolated } = this._findAPoint(posIndex);
             callback(data0, data1, interpolated);
         }
-    };
-    PointCoordinatesDataCalculator.prototype._pushPointCallBackEmpty = function () {
-        for (var key in this._pointObjects) {
-            var callback = this._pointObjects[key].callback;
+    }
+    _pushPointCallBackEmpty() {
+        for (const key in this._pointObjects) {
+            const { callback } = this._pointObjects[key];
             callback(null, null, null);
         }
-    };
-    PointCoordinatesDataCalculator.prototype.flush = function () {
+    }
+    flush() {
         this._pointObjects = {};
-    };
-    return PointCoordinatesDataCalculator;
-}());
+    }
+}
 exports.default = PointCoordinatesDataCalculator;
 // function test() {
 //     const cp = window.plugin.getPointCoordinatesDataCalculator();

package/util/heatwavedatamanager/pointcoordsmeta.js

@@ -1,21 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var PointCoordsMeta = /** @class */ (function () {
-    function PointCoordsMeta(bbox, width, height) {
+class PointCoordsMeta {
+    constructor(bbox, width, height) {
         this._bbox = bbox;
         this._width = width;
         this._height = height;
         this._xRatio = this._width / (this._bbox[2] - this._bbox[0]);
         this._yRatio = this._height / (this._bbox[3] - this._bbox[1]);
     }
-    PointCoordsMeta.prototype.getFlooredMeta = function (long, lat) {
-        var x = (long - this._bbox[0]) * this._xRatio;
-        var y = (this._bbox[3] - lat) * this._yRatio;
+    getFlooredMeta(long, lat) {
+        let x = (long - this._bbox[0]) * this._xRatio;
+        let y = (this._bbox[3] - lat) * this._yRatio;
         x = x > 0 ? x - 1 : 0;
         y = y > 0 ? y - 1 : 0;
-        var index = Math.floor(y) * this._width + Math.floor(x);
-        return { index: index };
-    };
-    return PointCoordsMeta;
-}());
+        const index = Math.floor(y) * this._width + Math.floor(x);
+        return { index };
+    }
+}
 exports.default = PointCoordsMeta;

package/util/index.js

@@ -37,17 +37,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.heatwavedatamanager = exports.programs = exports.webglobe = exports.geometry = exports.shaderfunctions = exports.webglobjectbuilders = void 0;
-var webglobjectbuilders = __importStar(require("./webglobjectbuilders"));
+const webglobjectbuilders = __importStar(require("./webglobjectbuilders"));
 exports.webglobjectbuilders = webglobjectbuilders;
-var shaderfunctions = __importStar(require("./shaderfunctions"));
+const shaderfunctions = __importStar(require("./shaderfunctions"));
 exports.shaderfunctions = shaderfunctions;
-var geometry = __importStar(require("./geometry"));
+const geometry = __importStar(require("./geometry"));
 exports.geometry = geometry;
-var webglobe = __importStar(require("./webglobe"));
+const webglobe = __importStar(require("./webglobe"));
 exports.webglobe = webglobe;
-var programs = __importStar(require("./programs"));
+const programs = __importStar(require("./programs"));
 exports.programs = programs;
-var heatwavedatamanager = __importStar(require("./heatwavedatamanager"));
+const heatwavedatamanager = __importStar(require("./heatwavedatamanager"));
 exports.heatwavedatamanager = heatwavedatamanager;
 __exportStar(require("./webglobe"), exports);
 __exportStar(require("./webglobjectbuilders"), exports);

package/util/interpolation/timetrack/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createWorker = void 0;
-var createWorker = function () { return new Worker(new URL('./web-worker.js', import.meta.url), { type: 'module' }); };
+const createWorker = () => new Worker(new URL('./web-worker.js', import.meta.url), { type: 'module' });
 exports.createWorker = createWorker;

package/util/interpolation/timetrack/timetrack-interpolator.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GEOMETRY = exports.TimeTrackInterpolator = void 0;
-var search_binary_1 = require("../../algorithms/search-binary");
-var methods_1 = require("../../../Math/methods");
+const search_binary_1 = require("../../algorithms/search-binary");
+const methods_1 = require("../../../Math/methods");
 /**
  * @typedef {Array<number>} vec3 [x, y, z]
  * @typedef {Array<number>} vec2 [x, y]
@@ -10,20 +10,19 @@ var methods_1 = require("../../../Math/methods");
  * @typedef {number} fraction a number between 0 and 1
  * @typedef {Array<number>} wgs84 [long, lat]
  */
-var GEOMETRY = Object.freeze({
+const GEOMETRY = Object.freeze({
     CARTESIAN3D: 0,
     MERCATOR: 1,
 });
 exports.GEOMETRY = GEOMETRY;
-var TimeTrackInterpolator = /** @class */ (function () {
+class TimeTrackInterpolator {
     /**
      * @typedef Timetrack
      * @property {Array<vec4>}} coordinates [x,y,z, length]
      * @property {Array<Number>} times
      * @param {Array<Timetrack>} timeTracks
      */
-    function TimeTrackInterpolator(_a) {
-        var _b = _a === void 0 ? {} : _a, timeTracks = _b.timeTracks, _c = _b.bbox, bbox = _c === void 0 ? null : _c, _d = _b.geometry, geometry = _d === void 0 ? GEOMETRY.CARTESIAN3D : _d;
+    constructor({ timeTracks, bbox = null, geometry = GEOMETRY.CARTESIAN3D } = {}) {
         this.timeTracks = null;
         this.timeTracksStartTimes = null;
         this.geometry = geometry;
@@ -32,50 +31,49 @@ var TimeTrackInterpolator = /** @class */ (function () {
         if (bbox)
             this.setBbox(bbox);
     }
-    TimeTrackInterpolator.prototype.setGeometry = function (geometry) {
+    setGeometry(geometry) {
         if (geometry !== GEOMETRY.CARTESIAN3D && geometry !== GEOMETRY.MERCATOR) {
             throw new Error('Invalid geometry');
         }
         this.geometry = geometry;
-    };
-    TimeTrackInterpolator.prototype.setTimetracks = function (timeTracks) {
+    }
+    setTimetracks(timeTracks) {
         this.timeTracks = timeTracks;
-    };
-    TimeTrackInterpolator.prototype.interpolate = function (time) {
-        var _a = this, timeTracks = _a.timeTracks, geometry = _a.geometry;
+    }
+    interpolate(time) {
+        const { timeTracks, geometry } = this;
         if (!timeTracks) {
             return null;
         }
-        var resultArray = [];
-        var info = {
+        const resultArray = [];
+        const info = {
             outOfRange: 0,
             processed: 0,
         };
-        for (var i = 0; i < timeTracks.length; i++) {
-            var _b = timeTracks[i], times = _b.times, coordinates = _b.coordinates;
+        for (let i = 0; i < timeTracks.length; i++) {
+            const { times, coordinates } = timeTracks[i];
             if (times[times.length - 1] < time)
                 continue;
             info.processed++;
-            var timeIndex = (0, search_binary_1.findFirstIndexInRange)(times, time);
+            const timeIndex = (0, search_binary_1.findFirstIndexInRange)(times, time);
             if (timeIndex === null) {
                 info.outOfRange++;
                 continue;
             }
-            var timeFraction = (time - times[timeIndex]) / (times[timeIndex + 1] - times[timeIndex]);
-            var interpolated = (geometry === GEOMETRY.CARTESIAN3D) ?
+            const timeFraction = (time - times[timeIndex]) / (times[timeIndex + 1] - times[timeIndex]);
+            const interpolated = (geometry === GEOMETRY.CARTESIAN3D) ?
                 (0, methods_1.sphericalLinearInterpolation_Cartesian3d)(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction) :
                 (0, methods_1.sphericalLinearInterpolation_Mercator)(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
-            resultArray.push.apply(resultArray, interpolated);
+            resultArray.push(...interpolated);
         }
         return new Float32Array(resultArray);
-    };
+    }
     // implicit methods
-    TimeTrackInterpolator.prototype._orderTimeTracks = function () {
-        this.timeTracks.sort(function (a, b) { return a.times[0] - b.times[0]; });
-    };
-    TimeTrackInterpolator.prototype._setStartTimes = function () {
-        this.timeTracksStartTimes = this.timeTracks.map(function (tt) { return tt.times[0]; });
-    };
-    return TimeTrackInterpolator;
-}());
+    _orderTimeTracks() {
+        this.timeTracks.sort((a, b) => a.times[0] - b.times[0]);
+    }
+    _setStartTimes() {
+        this.timeTracksStartTimes = this.timeTracks.map(tt => tt.times[0]);
+    }
+}
 exports.TimeTrackInterpolator = TimeTrackInterpolator;

package/util/interpolation/timetrack/web-worker-str.js

@@ -1,5 +1,183 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webworkerStr = void 0;
-var webworkerStr = "\n\nconst WORLD_RADIUS_3D = 6378.137;\nconst WORLD_RADIUS_MERCATOR = 6378136.99911;\n\nconst dot3 = (a, b) => {\n    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\n}\n\nconst sphericalLinearInterpolation_UnitVector = (normalizedA, normalizedB, ratio) => {\n    const theta = Math.acos(dot3(normalizedA, normalizedB));\n    if (theta < 0.000001) return normalizedA; // CALIBRATE?\n    const sinTheta = Math.sin(theta);\n    const result = [\n        (Math.sin((1.0 - ratio) * theta) * normalizedA[0] + Math.sin(ratio * theta) * normalizedB[0]) / sinTheta,\n        (Math.sin((1.0 - ratio) * theta) * normalizedA[1] + Math.sin(ratio * theta) * normalizedB[1]) / sinTheta,\n        (Math.sin((1.0 - ratio) * theta) * normalizedA[2] + Math.sin(ratio * theta) * normalizedB[2]) / sinTheta\n    ];\n    return result;\n}\n\nconst radianToMercator = (xy) => {\n    return [WORLD_RADIUS_MERCATOR * xy[0], WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))];\n}\n\n\nconst cartesian3dToRadian = (cartesian) => {\n    const x = cartesian[0];\n    const y = cartesian[1];\n    const z = cartesian[2];\n    // const length = Math.sqrt(x * x + y * y + z * z);\n    const long = Math.atan2(y, x);\n    const lat = Math.asin(z)// length);\n    return [long, lat];\n}\n\n\nconst sphericalLinearInterpolation_Mercator = (normalizedA, normalizedB, ratio) => {\n    const unitVector = sphericalLinearInterpolation_UnitVector(normalizedA, normalizedB, ratio);\n    const angles = cartesian3dToRadian(unitVector);\n    return radianToMercator(angles);\n}\n\nconst sphericalLinearInterpolation_Cartesian3d = (a, b, ratio) => {\n    const unitVector = sphericalLinearInterpolation_UnitVector(a, b, ratio);\n    const height = a[3] + (b[3] - a[3]) * ratio;\n    return [unitVector[0] * height, unitVector[1] * height, unitVector[2] * height];\n}\n\nconst findFirstIndexInRange = (container, value) => {\n    let start = 0;\n    let end = container.length - 1;\n    let mid = 0;\n    while (start <= end) {\n        mid = Math.floor((start + end) / 2);\n        if (container[mid] <= value && value <= container[mid + 1]) return mid;\n        if (container[mid] < value) start = mid + 1;\n        else end = mid - 1;\n    }\n    return null;\n}\n\nconst GEOMETRY = Object.freeze({\n    CARTESIAN3D: 0,\n    MERCATOR: 1,\n});\n\nclass TimeTrackInterpolator {\n    /**\n     * @typedef Timetrack\n     * @property {Array<vec4>}} coordinates [x,y,z, length]\n     * @property {Array<Number>} times\n     * @param {Array<Timetrack>} timeTracks\n     */\n    constructor({ timeTracks, bbox = null, geometry = GEOMETRY.CARTESIAN3D } = {}) {\n        this.timeTracks = null;\n        this.timeTracksStartTimes = null;\n        this.geometry = geometry;\n        if (timeTracks) this.setTimetracks(timeTracks);\n        if (bbox) this.setBbox(bbox);\n    }\n\n\n    setGeometry(geometry) {\n        if (geometry !== GEOMETRY.CARTESIAN3D && geometry !== GEOMETRY.MERCATOR) {\n            throw new Error('Invalid geometry');\n        }\n        this.geometry = geometry;\n    }\n\n    setTimetracks(timeTracks) {\n        this.timeTracks = timeTracks;\n    }\n\n\n    interpolate(time) {\n        const { timeTracks, geometry } = this;\n        if (!timeTracks) { return null; }\n        const resultArray = [];\n        const info = {\n            outOfRange: 0,\n            processed: 0,\n        }\n        for (let i = 0; i < timeTracks.length; i++) {\n            const { times, coordinates } = timeTracks[i];\n\n            if (times[times.length - 1] < time) continue;\n            info.processed++;\n            const timeIndex = findFirstIndexInRange(times, time);\n            if (timeIndex === null) { info.outOfRange++; continue; }\n            const timeFraction = (time - times[timeIndex]) / (times[timeIndex + 1] - times[timeIndex]);\n            const interpolated = (geometry === GEOMETRY.CARTESIAN3D) ?\n                sphericalLinearInterpolation_Cartesian3d(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction) :\n                sphericalLinearInterpolation_Mercator(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);\n            resultArray.push(...interpolated);\n        }\n        return new Float32Array(resultArray);\n    }\n\n\n    // implicit methods\n\n    _orderTimeTracks() {\n        this.timeTracks.sort((a, b) => a.times[0] - b.times[0]);\n    }\n\n    _setStartTimes() {\n        this.timeTracksStartTimes = this.timeTracks.map(tt => tt.times[0]);\n    }\n}\n\nconst interpolator = new TimeTrackInterpolator({ geometry: GEOMETRY.CARTESIAN3D });\n\n/* eslint-disable-next-line no-restricted-globals */\nself.onmessage = function (e) {\n\n    const { geometry = null, timeTracks = null, time = null } = e.data;\n\n    if (geometry !== null) {\n        try {\n            interpolator.setGeometry(geometry);\n        } catch (error) {\n            /* eslint-disable-next-line no-restricted-globals */\n            self.postMessage({ error: error.message });\n            return;\n        }\n    }\n\n    if (timeTracks !== null) {\n        try {\n            interpolator.setTimetracks(timeTracks);\n        } catch (error) {\n            /* eslint-disable-next-line no-restricted-globals */\n            self.postMessage({ error: error.message });\n            return;\n        }\n    }\n\n    if (time !== null) {\n        try {\n            const result = interpolator.interpolate(time);\n            if(result === null) {\n                /* eslint-disable-next-line no-restricted-globals */\n                self.postMessage({ error: 'No TimeTracks Data' });\n                return;\n            }\n            /* eslint-disable-next-line no-restricted-globals */\n            self.postMessage(result, [result.buffer]);\n            return;\n        } catch (error) {\n            /* eslint-disable-next-line no-restricted-globals */\n            self.postMessage({ error: error.message });\n            return;\n        }\n    }\n    /* eslint-disable-next-line no-restricted-globals */\n    self.postMessage(true);\n}\n    ";
+const webworkerStr = `
+
+const WORLD_RADIUS_3D = 6378.137;
+const WORLD_RADIUS_MERCATOR = 6378136.99911;
+
+const dot3 = (a, b) => {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+
+const sphericalLinearInterpolation_UnitVector = (normalizedA, normalizedB, ratio) => {
+    const theta = Math.acos(dot3(normalizedA, normalizedB));
+    if (theta < 0.000001) return normalizedA; // CALIBRATE?
+    const sinTheta = Math.sin(theta);
+    const result = [
+        (Math.sin((1.0 - ratio) * theta) * normalizedA[0] + Math.sin(ratio * theta) * normalizedB[0]) / sinTheta,
+        (Math.sin((1.0 - ratio) * theta) * normalizedA[1] + Math.sin(ratio * theta) * normalizedB[1]) / sinTheta,
+        (Math.sin((1.0 - ratio) * theta) * normalizedA[2] + Math.sin(ratio * theta) * normalizedB[2]) / sinTheta
+    ];
+    return result;
+}
+
+const radianToMercator = (xy) => {
+    return [WORLD_RADIUS_MERCATOR * xy[0], WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))];
+}
+
+
+const cartesian3dToRadian = (cartesian) => {
+    const x = cartesian[0];
+    const y = cartesian[1];
+    const z = cartesian[2];
+    // const length = Math.sqrt(x * x + y * y + z * z);
+    const long = Math.atan2(y, x);
+    const lat = Math.asin(z)// length);
+    return [long, lat];
+}
+
+
+const sphericalLinearInterpolation_Mercator = (normalizedA, normalizedB, ratio) => {
+    const unitVector = sphericalLinearInterpolation_UnitVector(normalizedA, normalizedB, ratio);
+    const angles = cartesian3dToRadian(unitVector);
+    return radianToMercator(angles);
+}
+
+const sphericalLinearInterpolation_Cartesian3d = (a, b, ratio) => {
+    const unitVector = sphericalLinearInterpolation_UnitVector(a, b, ratio);
+    const height = a[3] + (b[3] - a[3]) * ratio;
+    return [unitVector[0] * height, unitVector[1] * height, unitVector[2] * height];
+}
+
+const findFirstIndexInRange = (container, value) => {
+    let start = 0;
+    let end = container.length - 1;
+    let mid = 0;
+    while (start <= end) {
+        mid = Math.floor((start + end) / 2);
+        if (container[mid] <= value && value <= container[mid + 1]) return mid;
+        if (container[mid] < value) start = mid + 1;
+        else end = mid - 1;
+    }
+    return null;
+}
+
+const GEOMETRY = Object.freeze({
+    CARTESIAN3D: 0,
+    MERCATOR: 1,
+});
+
+class TimeTrackInterpolator {
+    /**
+     * @typedef Timetrack
+     * @property {Array<vec4>}} coordinates [x,y,z, length]
+     * @property {Array<Number>} times
+     * @param {Array<Timetrack>} timeTracks
+     */
+    constructor({ timeTracks, bbox = null, geometry = GEOMETRY.CARTESIAN3D } = {}) {
+        this.timeTracks = null;
+        this.timeTracksStartTimes = null;
+        this.geometry = geometry;
+        if (timeTracks) this.setTimetracks(timeTracks);
+        if (bbox) this.setBbox(bbox);
+    }
+
+
+    setGeometry(geometry) {
+        if (geometry !== GEOMETRY.CARTESIAN3D && geometry !== GEOMETRY.MERCATOR) {
+            throw new Error('Invalid geometry');
+        }
+        this.geometry = geometry;
+    }
+
+    setTimetracks(timeTracks) {
+        this.timeTracks = timeTracks;
+    }
+
+
+    interpolate(time) {
+        const { timeTracks, geometry } = this;
+        if (!timeTracks) { return null; }
+        const resultArray = [];
+        const info = {
+            outOfRange: 0,
+            processed: 0,
+        }
+        for (let i = 0; i < timeTracks.length; i++) {
+            const { times, coordinates } = timeTracks[i];
+
+            if (times[times.length - 1] < time) continue;
+            info.processed++;
+            const timeIndex = findFirstIndexInRange(times, time);
+            if (timeIndex === null) { info.outOfRange++; continue; }
+            const timeFraction = (time - times[timeIndex]) / (times[timeIndex + 1] - times[timeIndex]);
+            const interpolated = (geometry === GEOMETRY.CARTESIAN3D) ?
+                sphericalLinearInterpolation_Cartesian3d(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction) :
+                sphericalLinearInterpolation_Mercator(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
+            resultArray.push(...interpolated);
+        }
+        return new Float32Array(resultArray);
+    }
+
+
+    // implicit methods
+
+    _orderTimeTracks() {
+        this.timeTracks.sort((a, b) => a.times[0] - b.times[0]);
+    }
+
+    _setStartTimes() {
+        this.timeTracksStartTimes = this.timeTracks.map(tt => tt.times[0]);
+    }
+}
+
+const interpolator = new TimeTrackInterpolator({ geometry: GEOMETRY.CARTESIAN3D });
+
+/* eslint-disable-next-line no-restricted-globals */
+self.onmessage = function (e) {
+
+    const { geometry = null, timeTracks = null, time = null } = e.data;
+
+    if (geometry !== null) {
+        try {
+            interpolator.setGeometry(geometry);
+        } catch (error) {
+            /* eslint-disable-next-line no-restricted-globals */
+            self.postMessage({ error: error.message });
+            return;
+        }
+    }
+
+    if (timeTracks !== null) {
+        try {
+            interpolator.setTimetracks(timeTracks);
+        } catch (error) {
+            /* eslint-disable-next-line no-restricted-globals */
+            self.postMessage({ error: error.message });
+            return;
+        }
+    }
+
+    if (time !== null) {
+        try {
+            const result = interpolator.interpolate(time);
+            if(result === null) {
+                /* eslint-disable-next-line no-restricted-globals */
+                self.postMessage({ error: 'No TimeTracks Data' });
+                return;
+            }
+            /* eslint-disable-next-line no-restricted-globals */
+            self.postMessage(result, [result.buffer]);
+            return;
+        } catch (error) {
+            /* eslint-disable-next-line no-restricted-globals */
+            self.postMessage({ error: error.message });
+            return;
+        }
+    }
+    /* eslint-disable-next-line no-restricted-globals */
+    self.postMessage(true);
+}
+    `;
 exports.webworkerStr = webworkerStr;

package/util/interpolation/timetrack/web-worker.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var timetrack_interpolator_1 = require("./timetrack-interpolator");
-var interpolator = new timetrack_interpolator_1.TimeTrackInterpolator({ geometry: timetrack_interpolator_1.GEOMETRY.CARTESIAN3D });
+const timetrack_interpolator_1 = require("./timetrack-interpolator");
+const interpolator = new timetrack_interpolator_1.TimeTrackInterpolator({ geometry: timetrack_interpolator_1.GEOMETRY.CARTESIAN3D });
 /* eslint-disable-next-line no-restricted-globals */
 self.onmessage = function (e) {
-    var _a = e.data, _b = _a.geometry, geometry = _b === void 0 ? null : _b, _c = _a.timeTracks, timeTracks = _c === void 0 ? null : _c, _d = _a.time, time = _d === void 0 ? null : _d;
+    const { geometry = null, timeTracks = null, time = null } = e.data;
     if (geometry !== null) {
         try {
             interpolator.setGeometry(geometry);
@@ -27,7 +27,7 @@ self.onmessage = function (e) {
     }
     if (time !== null) {
         try {
-            var result = interpolator.interpolate(time);
+            const result = interpolator.interpolate(time);
             if (result === null) {
                 /* eslint-disable-next-line no-restricted-globals */
                 self.postMessage({ error: 'No TimeTracks Data' });

package/util/jshelpers/data-filler.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.populateFloat32Array = void 0;
-var populateFloat32Array = Object.freeze({
-    fillFloat32Array: function (length, data) {
-        var result = new Float32Array(length);
+const populateFloat32Array = Object.freeze({
+    fillFloat32Array: (length, data) => {
+        const result = new Float32Array(length);
         result.fill(data);
         return result;
     },
-    fillWithListData: function (length, listdata) {
-        var result = new Float32Array(length * listdata.length);
-        var offset = 0;
-        for (var i = 0; i < length; i++) {
+    fillWithListData: (length, listdata) => {
+        const result = new Float32Array(length * listdata.length);
+        let offset = 0;
+        for (let i = 0; i < length; i++) {
             result.set(listdata, offset);
             offset += listdata.length;
         }

package/util/jshelpers/timefilters.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.instantDebounce = instantDebounce;
 // TODO: fix logic error in instantDebounce
 function instantDebounce(func, delay) {
-    var timeout = null;
-    var lastArgs = null;
-    var runAtEnd = false;
-    var timeoutMethod = function () {
-        setTimeout(function () {
+    let timeout = null;
+    let lastArgs = null;
+    let runAtEnd = false;
+    const timeoutMethod = () => {
+        setTimeout(() => {
             if (runAtEnd) {
-                func.apply(void 0, lastArgs);
+                func(...lastArgs);
                 lastArgs = null;
                 // console.log("processed with delay")
                 runAtEnd = false;
@@ -24,7 +24,7 @@ function instantDebounce(func, delay) {
             return;
         }
         else {
-            func.apply(void 0, args);
+            func(...args);
             // console.log("processed instantly")
             timeout = timeoutMethod();
         }

package/util/picking/fence.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fence = void 0;
-var fence = function (gl) { return new Promise(function (resolve, reject) {
+const fence = (gl) => new Promise((resolve, reject) => {
     // This will create a fence. If this follows a `readPixels()` call, then it
     // will signal to WebGL that the read instruction should be asynchronous. 
     // This means JS can continue to work on other tasks while the read instruction
     // completes.
-    var sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
+    const sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
     gl.flush();
     // There are TWO possible ways to check on the status of a WebGLSync object.
     // 1. This will check it using clientWaitSync()
-    var checkStatus_v1 = function () {
-        var status = gl.clientWaitSync(sync, 0, 0);
+    const checkStatus_v1 = () => {
+        const status = gl.clientWaitSync(sync, 0, 0);
         // There are four possible values for status:
         // a. ALREADY_SIGNALED and CONDITION_SATISFIED (done)
         // b. TIMEOUT_EXPIRED (check again later)
@@ -29,8 +29,8 @@ var fence = function (gl) { return new Promise(function (resolve, reject) {
         }
     };
     // 2. This will check with getSyncParameter(s, gl.SYNC_STATUS)
-    var checkStatus_v2 = function () {
-        var status = gl.getSyncParameter(sync, gl.SYNC_STATUS);
+    const checkStatus_v2 = () => {
+        const status = gl.getSyncParameter(sync, gl.SYNC_STATUS);
         // There are only two possible values for status: SIGNALED and UNSIGNALED
         // Note that there is no `error` signal, so there is no reason to use `reject()` here
         if (status === gl.SIGNALED) {
@@ -42,5 +42,5 @@ var fence = function (gl) { return new Promise(function (resolve, reject) {
         }
     };
     setTimeout(checkStatus_v2, 1);
-}); };
+});
 exports.fence = fence;