@pirireis/webglobeplugins 0.9.10 → 0.9.11

package/util/gl-util/buffer/attribute-loader.js

@@ -1,4 +1,13 @@
 "use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBufferAndReadInfo = exports.attributeLoader = void 0;
 require("./types");
@@ -22,7 +31,8 @@ require("./types");
  * @param {Array<number>} options.escapeValues
  * @returns
  */
-const attributeLoader = (gl, bufferAndReadInfo, index, size, { divisor = null, type = null, escapeValues = null, normalized = false } = {}) => {
+var attributeLoader = function (gl, bufferAndReadInfo, index, size, _a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.divisor, divisor = _c === void 0 ? null : _c, _d = _b.type, type = _d === void 0 ? null : _d, _e = _b.escapeValues, escapeValues = _e === void 0 ? null : _e, _f = _b.normalized, normalized = _f === void 0 ? false : _f;
     if (size < 1 || size > 4)
         throw new Error("Size must be between 1 and 4");
     if (bufferAndReadInfo == null) {
@@ -30,7 +40,7 @@ const attributeLoader = (gl, bufferAndReadInfo, index, size, { divisor = null, t
             constantFunction(gl, index, size, escapeValues);
         return;
     }
-    const { buffer, stride, offset } = bufferAndReadInfo;
+    var buffer = bufferAndReadInfo.buffer, stride = bufferAndReadInfo.stride, offset = bufferAndReadInfo.offset;
     if (!gl || !buffer) {
         throw new Error("Invalid WebGL context or buffer");
     }
@@ -40,7 +50,7 @@ const attributeLoader = (gl, bufferAndReadInfo, index, size, { divisor = null, t
     if (stride < 0 || offset < 0) {
         throw new Error("Stride and offset must be non-negative");
     }
-    const attribType = type === null ? gl.FLOAT : type;
+    var attribType = type === null ? gl.FLOAT : type;
     gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
     gl.enableVertexAttribArray(index);
     gl.vertexAttribPointer(index, size, attribType, normalized, stride, offset);
@@ -56,14 +66,16 @@ exports.attributeLoader = attributeLoader;
  * @param {number} offset
  * @returns {BufferAndReadInfo}
  */
-const createBufferAndReadInfo = (buffer, stride = 0, offset = 0) => {
+var createBufferAndReadInfo = function (buffer, stride, offset) {
+    if (stride === void 0) { stride = 0; }
+    if (offset === void 0) { offset = 0; }
     if (buffer == null)
         return null;
-    return { buffer, stride, offset };
+    return { buffer: buffer, stride: stride, offset: offset };
 };
 exports.createBufferAndReadInfo = createBufferAndReadInfo;
-const constantFunction = (gl, index, size, escapeValues) => {
-    const func = `vertexAttrib${size}f`;
+var constantFunction = function (gl, index, size, escapeValues) {
+    var func = "vertexAttrib".concat(size, "f");
     // @ts-ignore
-    gl[func](index, ...escapeValues);
+    gl[func].apply(gl, __spreadArray([index], escapeValues, false));
 };

package/util/gl-util/buffer/index.js

@@ -2,5 +2,5 @@
 // import './types';
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.attributeLoader = void 0;
-const attribute_loader_1 = require("./attribute-loader");
+var attribute_loader_1 = require("./attribute-loader");
 Object.defineProperty(exports, "attributeLoader", { enumerable: true, get: function () { return attribute_loader_1.attributeLoader; } });

package/util/gl-util/draw-options/methods.js

@@ -5,10 +5,10 @@ require("./types");
 /**
  * Draws instanced geometry using WebGL2.
  */
-const drawInstanced = (gl, mode, drawOptions, vertexCount) => {
+var drawInstanced = function (gl, mode, drawOptions, vertexCount) {
     var _a;
-    const { drawRange, elementBufferIndexType = gl.UNSIGNED_INT } = drawOptions;
-    const { first = 0, count: instanceCount = 1 } = drawRange;
+    var drawRange = drawOptions.drawRange, _b = drawOptions.elementBufferIndexType, elementBufferIndexType = _b === void 0 ? gl.UNSIGNED_INT : _b;
+    var _c = drawRange.first, first = _c === void 0 ? 0 : _c, _d = drawRange.count, instanceCount = _d === void 0 ? 1 : _d;
     if (first > 0 || drawOptions.elementBuffer) {
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, (_a = drawOptions.elementBuffer) !== null && _a !== void 0 ? _a : null);
         gl.drawElementsInstanced(mode, vertexCount, elementBufferIndexType, first, instanceCount);
@@ -22,10 +22,10 @@ exports.drawInstanced = drawInstanced;
 /**
  * Draws geometry using WebGL2.
  */
-const drawArrays = (gl, defaultMode, drawOptions) => {
-    const { drawRange, elementBuffer, elementBufferIndexType = gl.UNSIGNED_INT, drawMode = null } = drawOptions;
-    const { first = 0, count } = drawRange;
-    const mode = drawMode !== null && drawMode !== void 0 ? drawMode : defaultMode;
+var drawArrays = function (gl, defaultMode, drawOptions) {
+    var drawRange = drawOptions.drawRange, elementBuffer = drawOptions.elementBuffer, _a = drawOptions.elementBufferIndexType, elementBufferIndexType = _a === void 0 ? gl.UNSIGNED_INT : _a, _b = drawOptions.drawMode, drawMode = _b === void 0 ? null : _b;
+    var _c = drawRange.first, first = _c === void 0 ? 0 : _c, count = drawRange.count;
+    var mode = drawMode !== null && drawMode !== void 0 ? drawMode : defaultMode;
     if (elementBuffer) {
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementBuffer);
         gl.drawElements(mode, count, elementBufferIndexType, first);

package/util/gl-util/uniform-block/manager.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniformBlockManager = void 0;
 require("./types");
-const typeSizes = {
+var typeSizes = {
     'float': 4,
     'vec2': 8,
     'vec3': 16, // vec3 takes up same space as vec4 due to alignment
@@ -16,7 +16,7 @@ const typeSizes = {
     'ivec4': 16,
     'bool': 4
 };
-const typeAlignments = {
+var typeAlignments = {
     'float': 4,
     'vec2': 8,
     'vec3': 16,
@@ -30,7 +30,7 @@ const typeAlignments = {
     'ivec4': 16,
     'bool': 4
 };
-const typeArrayConstructors = {
+var typeArrayConstructors = {
     'float': Float32Array,
     'vec2': Float32Array,
     'vec3': Float32Array,
@@ -44,8 +44,9 @@ const typeArrayConstructors = {
     'ivec4': Int32Array,
     'bool': Float32Array
 };
-class UniformBlockManager {
-    constructor(blockName, blockMembers, bindingPoint, prefix = "") {
+var UniformBlockManager = /** @class */ (function () {
+    function UniformBlockManager(blockName, blockMembers, bindingPoint, prefix) {
+        if (prefix === void 0) { prefix = ""; }
         this.blockName = blockName;
         this.blockMembers = blockMembers;
         this.bindingPoint = bindingPoint;
@@ -53,52 +54,56 @@ class UniformBlockManager {
         this.offsetMap = this.__create_LayoutSTD140_OffsetMap();
         this.size = this.__calculateSize();
     }
-    glslCode() {
-        let code = `layout(std140) uniform ${this.blockName} {`;
-        for (const member of this.blockMembers) {
-            const { name, type } = member;
-            code += `${type} ${this.prefix}${name};`;
+    UniformBlockManager.prototype.glslCode = function () {
+        var code = "layout(std140) uniform ".concat(this.blockName, " {");
+        for (var _i = 0, _a = this.blockMembers; _i < _a.length; _i++) {
+            var member = _a[_i];
+            var name_1 = member.name, type = member.type;
+            code += "".concat(type, " ").concat(this.prefix).concat(name_1, ";");
         }
         if (this.prefix) {
-            code += `} ${this.prefix};`;
+            code += "} ".concat(this.prefix, ";");
         }
         else {
-            code += `};`;
+            code += "};";
         }
         return code;
-    }
-    createUBO(gl, bufferWriteType = "STATIC_DRAW") {
-        const ubo = gl.createBuffer();
+    };
+    UniformBlockManager.prototype.createUBO = function (gl, bufferWriteType) {
+        var _this = this;
+        if (bufferWriteType === void 0) { bufferWriteType = "STATIC_DRAW"; }
+        var ubo = gl.createBuffer();
         gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
         // @ts-ignore
         gl.bufferData(gl.UNIFORM_BUFFER, this.size, gl[bufferWriteType]);
         gl.bindBufferBase(gl.UNIFORM_BUFFER, 0, ubo);
-        for (const member of this.blockMembers) {
-            const { name, type, value = null } = member;
+        for (var _i = 0, _a = this.blockMembers; _i < _a.length; _i++) {
+            var member = _a[_i];
+            var name_2 = member.name, type = member.type, _b = member.value, value = _b === void 0 ? null : _b;
             ;
-            const offset = this.offsetMap.get(name);
-            const data = (value === null) ? new typeArrayConstructors[type](typeSizes[type] / 4).fill(NaN) : value;
+            var offset = this.offsetMap.get(name_2);
+            var data = (value === null) ? new typeArrayConstructors[type](typeSizes[type] / 4).fill(NaN) : value;
             gl.bufferSubData(gl.UNIFORM_BUFFER, offset, data);
         }
         gl.bindBuffer(gl.UNIFORM_BUFFER, null);
         return {
-            ubo,
-            update: (nameValueMap) => this.updateUBO(gl, ubo, nameValueMap),
-            bind: () => this.bind(gl, ubo),
-            unbind: () => this.unbind(gl),
-            free: () => gl.deleteBuffer(ubo),
+            ubo: ubo,
+            update: function (nameValueMap) { return _this.updateUBO(gl, ubo, nameValueMap); },
+            bind: function () { return _this.bind(gl, ubo); },
+            unbind: function () { return _this.unbind(gl); },
+            free: function () { return gl.deleteBuffer(ubo); },
         };
-    }
-    updateUBO(gl, ubo, nameValueMap) {
+    };
+    UniformBlockManager.prototype.updateUBO = function (gl, ubo, nameValueMap) {
         gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
-        for (const [name, value] of nameValueMap.entries()) {
-            const offset = this.offsetMap.get(name);
+        var _loop_1 = function (name_3, value) {
+            var offset = this_1.offsetMap.get(name_3);
             if (offset === undefined) {
-                throw new Error(`Uniform block member ${name} not found in offset map.`);
+                throw new Error("Uniform block member ".concat(name_3, " not found in offset map."));
             }
             // @ts-ignore
-            const type = this.blockMembers.find(member => member.name === name).type;
-            let data;
+            var type = this_1.blockMembers.find(function (member) { return member.name === name_3; }).type;
+            var data = void 0;
             if (Array.isArray(value)) {
                 data = new typeArrayConstructors[type](value);
             }
@@ -111,46 +116,53 @@ class UniformBlockManager {
             else if (ArrayBuffer.isView(value) && !(value instanceof DataView))
                 data = (typeof value === 'number') ? new typeArrayConstructors[type]([value]) : new typeArrayConstructors[type](value);
             else {
-                throw new Error(`Unsupported value type for ${name}: ${typeof value}`);
+                throw new Error("Unsupported value type for ".concat(name_3, ": ").concat(typeof value));
             }
             console.log("Data to be uploaded:", data);
             gl.bufferSubData(gl.UNIFORM_BUFFER, offset, data);
+        };
+        var this_1 = this;
+        for (var _i = 0, _a = nameValueMap.entries(); _i < _a.length; _i++) {
+            var _b = _a[_i], name_3 = _b[0], value = _b[1];
+            _loop_1(name_3, value);
         }
         gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
+    };
     // call this after linking the program
-    assignBindingPoint(gl, program) {
-        const blockIndex = gl.getUniformBlockIndex(program, this.blockName);
+    UniformBlockManager.prototype.assignBindingPoint = function (gl, program) {
+        var blockIndex = gl.getUniformBlockIndex(program, this.blockName);
         gl.uniformBlockBinding(program, blockIndex, this.bindingPoint);
-    }
+    };
     // call this before drawing
-    bind(gl, ubo) {
+    UniformBlockManager.prototype.bind = function (gl, ubo) {
         gl.bindBufferBase(gl.UNIFORM_BUFFER, this.bindingPoint, ubo);
-    }
+    };
     // call this right after drawing
-    unbind(gl) {
+    UniformBlockManager.prototype.unbind = function (gl) {
         gl.bindBufferBase(gl.UNIFORM_BUFFER, this.bindingPoint, null);
-    }
+    };
     // implicit methods
-    __create_LayoutSTD140_OffsetMap() {
-        let offset = 0;
-        const offsetMap = new Map();
-        for (const member of this.blockMembers) {
-            const { name, type } = member;
-            const size = typeSizes[type];
-            const alignment = typeAlignments[type];
-            const padding = (alignment - (offset % alignment)) % alignment;
+    UniformBlockManager.prototype.__create_LayoutSTD140_OffsetMap = function () {
+        var offset = 0;
+        var offsetMap = new Map();
+        for (var _i = 0, _a = this.blockMembers; _i < _a.length; _i++) {
+            var member = _a[_i];
+            var name_4 = member.name, type = member.type;
+            var size = typeSizes[type];
+            var alignment = typeAlignments[type];
+            var padding = (alignment - (offset % alignment)) % alignment;
             offset += padding;
-            offsetMap.set(name, offset);
+            offsetMap.set(name_4, offset);
             offset += size;
         }
         return offsetMap;
-    }
+    };
     // __create_LayoutSTD140_OffsetMap() should be called before this
-    __calculateSize() {
-        const lastOffset = Array.from(this.offsetMap.values()).pop() || 0;
-        const lastItemAlignment = typeAlignments[this.blockMembers[this.blockMembers.length - 1].type];
+    UniformBlockManager.prototype.__calculateSize = function () {
+        var lastOffset = Array.from(this.offsetMap.values()).pop() || 0;
+        var lastItemAlignment = typeAlignments[this.blockMembers[this.blockMembers.length - 1].type];
         return lastOffset + lastItemAlignment;
-    }
-}
+    };
+    return UniformBlockManager;
+}());
 exports.UniformBlockManager = UniformBlockManager;

package/util/heatwavedatamanager/datamanager.js

@@ -3,16 +3,62 @@
  * todo:
  * data must be processed before being set to the cache
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-class DataManager {
+var DataManager = /** @class */ (function () {
     /**
      *
      * @param {Array<number>} timeEpocs | array of time epocs
      * @param {Function} fetchMethod | fetchMethod(time) => Promise<data>
      * @param {boolean} autoDownload | auto download data or not
     */
-    constructor(timeEpocs, fetchMethod, { autoDownload = true } = {}) {
-        this._timeEpocs = timeEpocs.sort((a, b) => a - b);
+    function DataManager(timeEpocs, fetchMethod, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.autoDownload, autoDownload = _c === void 0 ? true : _c;
+        this._timeEpocs = timeEpocs.sort(function (a, b) { return a - b; });
         this._datas = [];
         this._datas.length = timeEpocs.length;
         // in construction
@@ -25,12 +71,13 @@ class DataManager {
         this._lastIndex = -1;
         this.autoDownload(autoDownload);
     }
-    autoDownload(bool, time) {
+    DataManager.prototype.autoDownload = function (bool, time) {
+        var _this = this;
         if (!bool) {
             this._autoDownload = false;
             return;
         }
-        let index = this._lastIndex === -1 ? 0 : this._lastIndex;
+        var index = this._lastIndex === -1 ? 0 : this._lastIndex;
         if (time !== undefined) {
             if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
                 this._autoDownload = bool;
@@ -42,11 +89,11 @@ class DataManager {
             return;
         this._downloadStartIndex = index;
         this._autoDownload = bool;
-        const recursion = (startId, currentDownloadId) => {
-            if (startId !== this._downloadStartIndex)
+        var recursion = function (startId, currentDownloadId) {
+            if (startId !== _this._downloadStartIndex)
                 return;
-            if (currentDownloadId < this._timeEpocs.length && this._autoDownload) {
-                this._getData(currentDownloadId).then(() => {
+            if (currentDownloadId < _this._timeEpocs.length && _this._autoDownload) {
+                _this._getData(currentDownloadId).then(function () {
                     recursion(startId, currentDownloadId + 1);
                 });
             }
@@ -55,28 +102,29 @@ class DataManager {
         // save index as start index
         //start recursive download
         // use started id as a flag to stop the download
-    }
+    };
     /**
      * @param {number} time
      * It looks like async function is not needed here. changes just overwrites the previous changes.
      */
-    updateTime(time) {
+    DataManager.prototype.updateTime = function (time) {
+        var _this = this;
         if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
             this._dontRender();
             return;
         }
         this._lastTime = time;
-        const index = this._findIndex(time);
-        const ratio = this._getRatio(time, index);
-        Promise.all([this._getData(index - 1), this._getData(index)]).then((datas) => {
-            if (this._lastTime === time) {
-                this._lastIndex = index;
-                this._ratio = ratio;
-                this._pushCallback(ratio, datas);
+        var index = this._findIndex(time);
+        var ratio = this._getRatio(time, index);
+        Promise.all([this._getData(index - 1), this._getData(index)]).then(function (datas) {
+            if (_this._lastTime === time) {
+                _this._lastIndex = index;
+                _this._ratio = ratio;
+                _this._pushCallback(ratio, datas);
             }
         });
-    }
-    register(key, callback) {
+    };
+    DataManager.prototype.register = function (key, callback) {
         if (this._callbackmethodOwners.indexOf(key) !== -1) {
             console.warn("key already registered, old one is unregistered");
             this.unregister(key);
@@ -85,12 +133,12 @@ class DataManager {
         this._callbackmethodOwners.push(key);
         if (this._lastIndex !== -1)
             callback(this._ratio, this._datas[this._lastIndex - 1], this._datas[this._lastIndex]);
-    }
+    };
     /**
      * @param {*} key | id of the owner of the callback
      */
-    unregister(key) {
-        let index = this._callbackmethodOwners.indexOf(key);
+    DataManager.prototype.unregister = function (key) {
+        var index = this._callbackmethodOwners.indexOf(key);
         if (index !== -1) {
             this._callbackmethods.splice(index, 1);
             this._callbackmethodOwners.splice(index, 1);
@@ -98,15 +146,15 @@ class DataManager {
         if (this._callbackmethods.length === 0) {
             this.free();
         }
-    }
-    free() {
+    };
+    DataManager.prototype.free = function () {
         this._callbackmethods = [];
         this._callbackmethodOwners = [];
         this._autoDownload = false;
-    }
-    _findIndex(time) {
-        const { _timeEpocs } = this;
-        let index = this._lastIndex === -1 ? 1 : this._lastIndex;
+    };
+    DataManager.prototype._findIndex = function (time) {
+        var _timeEpocs = this._timeEpocs;
+        var index = this._lastIndex === -1 ? 1 : this._lastIndex;
         if (this)
             if (time < _timeEpocs[index - 1]) {
                 while (index > 1 && time < _timeEpocs[index - 1]) {
@@ -119,34 +167,46 @@ class DataManager {
                 }
             }
         return index;
-    }
-    _getRatio(time, index) {
+    };
+    DataManager.prototype._getRatio = function (time, index) {
         return (time - this._timeEpocs[index - 1]) / (this._timeEpocs[index] - this._timeEpocs[index - 1]);
-    }
-    _pushCallback(ratio, datas) {
-        for (let i = 0; i < this._callbackmethods.length; i++) {
-            this._callbackmethods[i](ratio, ...datas);
-        }
-    }
-    async _getData(index) {
-        if (index < 0 || index >= this._timeEpocs.length) {
-            throw new Error("Index out of range");
-        }
-        if (!this._datas[index]) {
-            if (!this._dataPromises[index])
-                this._dataPromises[index] = this._fetchMethod(this._timeEpocs[index]).then((data) => {
-                    this._datas[index] = data;
-                }, (error) => {
-                    console.error("error", error);
-                }).finally(() => {
-                    this._dataPromises[index] = null;
-                });
+    };
+    DataManager.prototype._pushCallback = function (ratio, datas) {
+        var _a;
+        for (var i = 0; i < this._callbackmethods.length; i++) {
+            (_a = this._callbackmethods)[i].apply(_a, __spreadArray([ratio], datas, false));
         }
-        await this._dataPromises[index];
-        return this._datas[index];
-    }
-    _dontRender() {
+    };
+    DataManager.prototype._getData = function (index) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (index < 0 || index >= this._timeEpocs.length) {
+                            throw new Error("Index out of range");
+                        }
+                        if (!this._datas[index]) {
+                            if (!this._dataPromises[index])
+                                this._dataPromises[index] = this._fetchMethod(this._timeEpocs[index]).then(function (data) {
+                                    _this._datas[index] = data;
+                                }, function (error) {
+                                    console.error("error", error);
+                                }).finally(function () {
+                                    _this._dataPromises[index] = null;
+                                });
+                        }
+                        return [4 /*yield*/, this._dataPromises[index]];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, this._datas[index]];
+                }
+            });
+        });
+    };
+    DataManager.prototype._dontRender = function () {
         this._pushCallback(0, [null, null]);
-    }
-}
+    };
+    return DataManager;
+}());
 exports.default = DataManager;

package/util/heatwavedatamanager/index.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PointCoordinatesDataCalculator = exports.HeatWaveDataManager = void 0;
-const pointcoordinatesdatacalculator_1 = __importDefault(require("./pointcoordinatesdatacalculator"));
+var pointcoordinatesdatacalculator_1 = __importDefault(require("./pointcoordinatesdatacalculator"));
 exports.PointCoordinatesDataCalculator = pointcoordinatesdatacalculator_1.default;
-const datamanager_1 = __importDefault(require("./datamanager"));
+var datamanager_1 = __importDefault(require("./datamanager"));
 exports.HeatWaveDataManager = datamanager_1.default;