@pirireis/webglobeplugins 0.9.6 → 0.9.8

package/dist/util/index.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.heatwavedatamanager = exports.programs = exports.webglobe = exports.geometry = exports.shaderfunctions = exports.webglobjectbuilders = void 0;
+const webglobjectbuilders = __importStar(require("./webglobjectbuilders"));
+exports.webglobjectbuilders = webglobjectbuilders;
+const shaderfunctions = __importStar(require("./shaderfunctions"));
+exports.shaderfunctions = shaderfunctions;
+const geometry = __importStar(require("./geometry"));
+exports.geometry = geometry;
+const webglobe = __importStar(require("./webglobe"));
+exports.webglobe = webglobe;
+const programs = __importStar(require("./programs"));
+exports.programs = programs;
+const heatwavedatamanager = __importStar(require("./heatwavedatamanager"));
+exports.heatwavedatamanager = heatwavedatamanager;
+__exportStar(require("./webglobe"), exports);
+__exportStar(require("./webglobjectbuilders"), exports);
+__exportStar(require("./shaderfunctions"), exports);
+__exportStar(require("./geometry"), exports);
+__exportStar(require("./programs"), exports);
+__exportStar(require("./heatwavedatamanager"), exports);

package/dist/util/interpolation/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/util/interpolation/timetrack/index.js

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

package/{util → dist/util}/interpolation/timetrack/timetrack-interpolator.js

@@ -1,88 +1,79 @@
-import { findFirstIndexInRange } from '../../algorithms/search-binary';
-import {
-    sphericalLinearInterpolation_Cartesian3d,
-    sphericalLinearInterpolation_Mercator,
-} from '../../../Math/methods';
-
-
-/**
- * @typedef {Array<number>} vec3 [x, y, z]
- * @typedef {Array<number>} vec2 [x, y]
- * @typedef {Array<number>} vec4 [x, y, z, w]
- * @typedef {number} fraction a number between 0 and 1
- * @typedef {Array<number>} wgs84 [long, lat]
- */
-
-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]);
-    }
-
-
-}
-
-
-export { TimeTrackInterpolator, GEOMETRY };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEOMETRY = exports.TimeTrackInterpolator = void 0;
+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]
+ * @typedef {Array<number>} vec4 [x, y, z, w]
+ * @typedef {number} fraction a number between 0 and 1
+ * @typedef {Array<number>} wgs84 [long, lat]
+ */
+const GEOMETRY = Object.freeze({
+    CARTESIAN3D: 0,
+    MERCATOR: 1,
+});
+exports.GEOMETRY = GEOMETRY;
+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 = (0, search_binary_1.findFirstIndexInRange)(times, time);
+            if (timeIndex === null) {
+                info.outOfRange++;
+                continue;
+            }
+            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(...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]);
+    }
+}
+exports.TimeTrackInterpolator = TimeTrackInterpolator;

package/{util → dist/util}/interpolation/timetrack/web-worker-str.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webworkerStr = void 0;
 const webworkerStr = `
 
 const WORLD_RADIUS_3D = 6378.137;
@@ -176,5 +179,5 @@ self.onmessage = function (e) {
     /* eslint-disable-next-line no-restricted-globals */
     self.postMessage(true);
 }
-    `;
-export { webworkerStr };
+    `;
+exports.webworkerStr = webworkerStr;

package/{util → dist/util}/interpolation/timetrack/web-worker.js

@@ -1,51 +1,48 @@
-import { TimeTrackInterpolator, GEOMETRY } from './timetrack-interpolator';
-
-
-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);
-}
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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) {
+    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);
+};

package/{util → dist/util}/jshelpers/data-filler.js

@@ -1,19 +1,20 @@
-const populateFloat32Array = Object.freeze({
-    fillFloat32Array: (length, data) => {
-        const result = new Float32Array(length);
-        result.fill(data);
-        return result;
-    },
-
-    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;
-        }
-        return result
-    }
-});
-
-export { populateFloat32Array };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.populateFloat32Array = void 0;
+const populateFloat32Array = Object.freeze({
+    fillFloat32Array: (length, data) => {
+        const result = new Float32Array(length);
+        result.fill(data);
+        return result;
+    },
+    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;
+        }
+        return result;
+    }
+});
+exports.populateFloat32Array = populateFloat32Array;

package/{util → dist/util}/jshelpers/equality.js

@@ -1,17 +1,20 @@
-function arraysEqual(a, b) {
-    if (a === b) return true;
-    if (a == null || b == null) return false;
-    if (a.length !== b.length) return false;
-
-    // If you don't care about the order of the elements inside
-    // the array, you should sort both arrays here.
-    // Please note that calling sort on an array will modify that array.
-    // you might want to clone your array first.
-
-    for (var i = 0; i < a.length; ++i) {
-        if (a[i] !== b[i]) return false;
-    }
-    return true;
-}
-
-export { arraysEqual };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arraysEqual = arraysEqual;
+function arraysEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    // If you don't care about the order of the elements inside
+    // the array, you should sort both arrays here.
+    // Please note that calling sort on an array will modify that array.
+    // you might want to clone your array first.
+    for (var i = 0; i < a.length; ++i) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}

package/dist/util/jshelpers/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timefilters = void 0;
+exports.timefilters = __importStar(require("./timefilters"));

package/{util → dist/util}/jshelpers/timefilters.js

@@ -1,32 +1,32 @@
-// TODO: fix logic error in instantDebounce
-function instantDebounce(func, delay) {
-    let timeout = null;
-    let lastArgs = null;
-    let runAtEnd = false;
-
-    const timeoutMethod = () => {
-        setTimeout(() => {
-            if (runAtEnd) {
-                func(...lastArgs);
-                lastArgs = null;
-                // console.log("processed with delay")
-                runAtEnd = false;
-            }
-            timeout = null;
-        }, delay);
-    }
-
-    return function () {
-        if (timeout) {
-            lastArgs = arguments;
-            runAtEnd = true;
-            return;
-        } else {
-            func(...args);
-            // console.log("processed instantly")
-            timeout = timeoutMethod();
-        }
-    }
-}
-
-export { instantDebounce };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instantDebounce = instantDebounce;
+// TODO: fix logic error in instantDebounce
+function instantDebounce(func, delay) {
+    let timeout = null;
+    let lastArgs = null;
+    let runAtEnd = false;
+    const timeoutMethod = () => {
+        setTimeout(() => {
+            if (runAtEnd) {
+                func(...lastArgs);
+                lastArgs = null;
+                // console.log("processed with delay")
+                runAtEnd = false;
+            }
+            timeout = null;
+        }, delay);
+    };
+    return function () {
+        if (timeout) {
+            lastArgs = arguments;
+            runAtEnd = true;
+            return;
+        }
+        else {
+            func(...args);
+            // console.log("processed instantly")
+            timeout = timeoutMethod();
+        }
+    };
+}

package/{util → dist/util}/picking/fence.js

@@ -1,46 +1,46 @@
-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.
-    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()
-    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)
-        // c. WAIT_FAILED (there was an error)
-        if (status === gl.TIMEOUT_EXPIRED) {
-            setTimeout(checkStatus_v1, 1);
-        } else if (status === gl.ALREADY_SIGNALED || status === gl.CONDITION_SATISFIED) {
-            gl.deleteSync(sync);
-            resolve();
-        } else {
-            gl.deleteSync(sync);
-            reject(new Error('Fence did not resolve normally for some reason'));
-        }
-    };
-
-    // 2. This will check with getSyncParameter(s, 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) {
-            gl.deleteSync(sync);
-            resolve();
-        } else {
-            setTimeout(checkStatus_v2, 1);
-        }
-    };
-    setTimeout(checkStatus_v2, 1);
-});
-
-export { fence };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fence = void 0;
+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.
+    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()
+    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)
+        // c. WAIT_FAILED (there was an error)
+        if (status === gl.TIMEOUT_EXPIRED) {
+            setTimeout(checkStatus_v1, 1);
+        }
+        else if (status === gl.ALREADY_SIGNALED || status === gl.CONDITION_SATISFIED) {
+            gl.deleteSync(sync);
+            resolve();
+        }
+        else {
+            gl.deleteSync(sync);
+            reject(new Error('Fence did not resolve normally for some reason'));
+        }
+    };
+    // 2. This will check with getSyncParameter(s, 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) {
+            gl.deleteSync(sync);
+            resolve();
+        }
+        else {
+            setTimeout(checkStatus_v2, 1);
+        }
+    };
+    setTimeout(checkStatus_v2, 1);
+});
+exports.fence = fence;