@pirireis/webglobeplugins 0.9.11 → 0.9.12

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

@@ -1,13 +1,4 @@
 "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");
@@ -31,8 +22,7 @@ require("./types");
  * @param {Array<number>} options.escapeValues
  * @returns
  */
-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;
+const attributeLoader = (gl, bufferAndReadInfo, index, size, { divisor = null, type = null, escapeValues = null, normalized = false } = {}) => {
     if (size < 1 || size > 4)
         throw new Error("Size must be between 1 and 4");
     if (bufferAndReadInfo == null) {
@@ -40,7 +30,7 @@ var attributeLoader = function (gl, bufferAndReadInfo, index, size, _a) {
             constantFunction(gl, index, size, escapeValues);
         return;
     }
-    var buffer = bufferAndReadInfo.buffer, stride = bufferAndReadInfo.stride, offset = bufferAndReadInfo.offset;
+    const { buffer, stride, offset } = bufferAndReadInfo;
     if (!gl || !buffer) {
         throw new Error("Invalid WebGL context or buffer");
     }
@@ -50,7 +40,7 @@ var attributeLoader = function (gl, bufferAndReadInfo, index, size, _a) {
     if (stride < 0 || offset < 0) {
         throw new Error("Stride and offset must be non-negative");
     }
-    var attribType = type === null ? gl.FLOAT : type;
+    const attribType = type === null ? gl.FLOAT : type;
     gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
     gl.enableVertexAttribArray(index);
     gl.vertexAttribPointer(index, size, attribType, normalized, stride, offset);
@@ -66,16 +56,14 @@ exports.attributeLoader = attributeLoader;
  * @param {number} offset
  * @returns {BufferAndReadInfo}
  */
-var createBufferAndReadInfo = function (buffer, stride, offset) {
-    if (stride === void 0) { stride = 0; }
-    if (offset === void 0) { offset = 0; }
+const createBufferAndReadInfo = (buffer, stride = 0, offset = 0) => {
     if (buffer == null)
         return null;
-    return { buffer: buffer, stride: stride, offset: offset };
+    return { buffer, stride, offset };
 };
 exports.createBufferAndReadInfo = createBufferAndReadInfo;
-var constantFunction = function (gl, index, size, escapeValues) {
-    var func = "vertexAttrib".concat(size, "f");
+const constantFunction = (gl, index, size, escapeValues) => {
+    const func = `vertexAttrib${size}f`;
     // @ts-ignore
-    gl[func].apply(gl, __spreadArray([index], escapeValues, false));
+    gl[func](index, ...escapeValues);
 };

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

@@ -2,5 +2,5 @@
 // import './types';
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.attributeLoader = void 0;
-var attribute_loader_1 = require("./attribute-loader");
+const 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,12 +5,11 @@ require("./types");
 /**
  * Draws instanced geometry using WebGL2.
  */
-var drawInstanced = function (gl, mode, drawOptions, vertexCount) {
-    var _a;
-    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;
+const drawInstanced = (gl, mode, drawOptions, vertexCount) => {
+    const { drawRange, elementBufferIndexType = gl.UNSIGNED_INT } = drawOptions;
+    const { first = 0, count: instanceCount = 1 } = drawRange;
     if (first > 0 || drawOptions.elementBuffer) {
-        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, (_a = drawOptions.elementBuffer) !== null && _a !== void 0 ? _a : null);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, drawOptions.elementBuffer ?? null);
         gl.drawElementsInstanced(mode, vertexCount, elementBufferIndexType, first, instanceCount);
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
     }
@@ -22,10 +21,10 @@ exports.drawInstanced = drawInstanced;
 /**
  * Draws geometry using WebGL2.
  */
-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;
+const drawArrays = (gl, defaultMode, drawOptions) => {
+    const { drawRange, elementBuffer, elementBufferIndexType = gl.UNSIGNED_INT, drawMode = null } = drawOptions;
+    const { first = 0, count } = drawRange;
+    const mode = 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");
-var typeSizes = {
+const typeSizes = {
     'float': 4,
     'vec2': 8,
     'vec3': 16, // vec3 takes up same space as vec4 due to alignment
@@ -16,7 +16,7 @@ var typeSizes = {
     'ivec4': 16,
     'bool': 4
 };
-var typeAlignments = {
+const typeAlignments = {
     'float': 4,
     'vec2': 8,
     'vec3': 16,
@@ -30,7 +30,7 @@ var typeAlignments = {
     'ivec4': 16,
     'bool': 4
 };
-var typeArrayConstructors = {
+const typeArrayConstructors = {
     'float': Float32Array,
     'vec2': Float32Array,
     'vec3': Float32Array,
@@ -44,9 +44,20 @@ var typeArrayConstructors = {
     'ivec4': Int32Array,
     'bool': Float32Array
 };
-var UniformBlockManager = /** @class */ (function () {
-    function UniformBlockManager(blockName, blockMembers, bindingPoint, prefix) {
-        if (prefix === void 0) { prefix = ""; }
+class UniformBlockManager {
+    /**
+     *
+     * @param {UniformBlockName} blockName
+     * @param {Array<UniformBlockMember} blockMembers
+     * @param {string} prefix usage name of block in the shader
+     */
+    blockName;
+    blockMembers;
+    bindingPoint;
+    prefix;
+    offsetMap;
+    size;
+    constructor(blockName, blockMembers, bindingPoint, prefix = "") {
         this.blockName = blockName;
         this.blockMembers = blockMembers;
         this.bindingPoint = bindingPoint;
@@ -54,56 +65,52 @@ var UniformBlockManager = /** @class */ (function () {
         this.offsetMap = this.__create_LayoutSTD140_OffsetMap();
         this.size = this.__calculateSize();
     }
-    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, ";");
+    glslCode() {
+        let code = `layout(std140) uniform ${this.blockName} {`;
+        for (const member of this.blockMembers) {
+            const { name, type } = member;
+            code += `${type} ${this.prefix}${name};`;
         }
         if (this.prefix) {
-            code += "} ".concat(this.prefix, ";");
+            code += `} ${this.prefix};`;
         }
         else {
-            code += "};";
+            code += `};`;
         }
         return code;
-    };
-    UniformBlockManager.prototype.createUBO = function (gl, bufferWriteType) {
-        var _this = this;
-        if (bufferWriteType === void 0) { bufferWriteType = "STATIC_DRAW"; }
-        var ubo = gl.createBuffer();
+    }
+    createUBO(gl, bufferWriteType = "STATIC_DRAW") {
+        const 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 (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;
+        for (const member of this.blockMembers) {
+            const { name, type, value = null } = member;
             ;
-            var offset = this.offsetMap.get(name_2);
-            var data = (value === null) ? new typeArrayConstructors[type](typeSizes[type] / 4).fill(NaN) : value;
+            const offset = this.offsetMap.get(name);
+            const 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: 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); },
+            ubo,
+            update: (nameValueMap) => this.updateUBO(gl, ubo, nameValueMap),
+            bind: () => this.bind(gl, ubo),
+            unbind: () => this.unbind(gl),
+            free: () => gl.deleteBuffer(ubo),
         };
-    };
-    UniformBlockManager.prototype.updateUBO = function (gl, ubo, nameValueMap) {
+    }
+    updateUBO(gl, ubo, nameValueMap) {
         gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
-        var _loop_1 = function (name_3, value) {
-            var offset = this_1.offsetMap.get(name_3);
+        for (const [name, value] of nameValueMap.entries()) {
+            const offset = this.offsetMap.get(name);
             if (offset === undefined) {
-                throw new Error("Uniform block member ".concat(name_3, " not found in offset map."));
+                throw new Error(`Uniform block member ${name} not found in offset map.`);
             }
             // @ts-ignore
-            var type = this_1.blockMembers.find(function (member) { return member.name === name_3; }).type;
-            var data = void 0;
+            const type = this.blockMembers.find(member => member.name === name).type;
+            let data;
             if (Array.isArray(value)) {
                 data = new typeArrayConstructors[type](value);
             }
@@ -116,53 +123,46 @@ var UniformBlockManager = /** @class */ (function () {
             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 ".concat(name_3, ": ").concat(typeof value));
+                throw new Error(`Unsupported value type for ${name}: ${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
-    UniformBlockManager.prototype.assignBindingPoint = function (gl, program) {
-        var blockIndex = gl.getUniformBlockIndex(program, this.blockName);
+    assignBindingPoint(gl, program) {
+        const blockIndex = gl.getUniformBlockIndex(program, this.blockName);
         gl.uniformBlockBinding(program, blockIndex, this.bindingPoint);
-    };
+    }
     // call this before drawing
-    UniformBlockManager.prototype.bind = function (gl, ubo) {
+    bind(gl, ubo) {
         gl.bindBufferBase(gl.UNIFORM_BUFFER, this.bindingPoint, ubo);
-    };
+    }
     // call this right after drawing
-    UniformBlockManager.prototype.unbind = function (gl) {
+    unbind(gl) {
         gl.bindBufferBase(gl.UNIFORM_BUFFER, this.bindingPoint, null);
-    };
+    }
     // implicit methods
-    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;
+    __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;
             offset += padding;
-            offsetMap.set(name_4, offset);
+            offsetMap.set(name, offset);
             offset += size;
         }
         return offsetMap;
-    };
+    }
     // __create_LayoutSTD140_OffsetMap() should be called before this
-    UniformBlockManager.prototype.__calculateSize = function () {
-        var lastOffset = Array.from(this.offsetMap.values()).pop() || 0;
-        var lastItemAlignment = typeAlignments[this.blockMembers[this.blockMembers.length - 1].type];
+    __calculateSize() {
+        const lastOffset = Array.from(this.offsetMap.values()).pop() || 0;
+        const lastItemAlignment = typeAlignments[this.blockMembers[this.blockMembers.length - 1].type];
         return lastOffset + lastItemAlignment;
-    };
-    return UniformBlockManager;
-}());
+    }
+}
 exports.UniformBlockManager = UniformBlockManager;

package/util/heatwavedatamanager/datamanager.js

@@ -3,62 +3,16 @@
  * 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 });
-var DataManager = /** @class */ (function () {
+class DataManager {
     /**
      *
      * @param {Array<number>} timeEpocs | array of time epocs
      * @param {Function} fetchMethod | fetchMethod(time) => Promise<data>
      * @param {boolean} autoDownload | auto download data or not
     */
-    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; });
+    constructor(timeEpocs, fetchMethod, { autoDownload = true } = {}) {
+        this._timeEpocs = timeEpocs.sort((a, b) => a - b);
         this._datas = [];
         this._datas.length = timeEpocs.length;
         // in construction
@@ -71,13 +25,12 @@ var DataManager = /** @class */ (function () {
         this._lastIndex = -1;
         this.autoDownload(autoDownload);
     }
-    DataManager.prototype.autoDownload = function (bool, time) {
-        var _this = this;
+    autoDownload(bool, time) {
         if (!bool) {
             this._autoDownload = false;
             return;
         }
-        var index = this._lastIndex === -1 ? 0 : this._lastIndex;
+        let 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;
@@ -89,11 +42,11 @@ var DataManager = /** @class */ (function () {
             return;
         this._downloadStartIndex = index;
         this._autoDownload = bool;
-        var recursion = function (startId, currentDownloadId) {
-            if (startId !== _this._downloadStartIndex)
+        const recursion = (startId, currentDownloadId) => {
+            if (startId !== this._downloadStartIndex)
                 return;
-            if (currentDownloadId < _this._timeEpocs.length && _this._autoDownload) {
-                _this._getData(currentDownloadId).then(function () {
+            if (currentDownloadId < this._timeEpocs.length && this._autoDownload) {
+                this._getData(currentDownloadId).then(() => {
                     recursion(startId, currentDownloadId + 1);
                 });
             }
@@ -102,29 +55,28 @@ var DataManager = /** @class */ (function () {
         // 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.
      */
-    DataManager.prototype.updateTime = function (time) {
-        var _this = this;
+    updateTime(time) {
         if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
             this._dontRender();
             return;
         }
         this._lastTime = time;
-        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);
+        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);
             }
         });
-    };
-    DataManager.prototype.register = function (key, callback) {
+    }
+    register(key, callback) {
         if (this._callbackmethodOwners.indexOf(key) !== -1) {
             console.warn("key already registered, old one is unregistered");
             this.unregister(key);
@@ -133,12 +85,12 @@ var DataManager = /** @class */ (function () {
         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
      */
-    DataManager.prototype.unregister = function (key) {
-        var index = this._callbackmethodOwners.indexOf(key);
+    unregister(key) {
+        let index = this._callbackmethodOwners.indexOf(key);
         if (index !== -1) {
             this._callbackmethods.splice(index, 1);
             this._callbackmethodOwners.splice(index, 1);
@@ -146,15 +98,15 @@ var DataManager = /** @class */ (function () {
         if (this._callbackmethods.length === 0) {
             this.free();
         }
-    };
-    DataManager.prototype.free = function () {
+    }
+    free() {
         this._callbackmethods = [];
         this._callbackmethodOwners = [];
         this._autoDownload = false;
-    };
-    DataManager.prototype._findIndex = function (time) {
-        var _timeEpocs = this._timeEpocs;
-        var index = this._lastIndex === -1 ? 1 : this._lastIndex;
+    }
+    _findIndex(time) {
+        const { _timeEpocs } = this;
+        let index = this._lastIndex === -1 ? 1 : this._lastIndex;
         if (this)
             if (time < _timeEpocs[index - 1]) {
                 while (index > 1 && time < _timeEpocs[index - 1]) {
@@ -167,46 +119,34 @@ var DataManager = /** @class */ (function () {
                 }
             }
         return index;
-    };
-    DataManager.prototype._getRatio = function (time, index) {
+    }
+    _getRatio(time, index) {
         return (time - this._timeEpocs[index - 1]) / (this._timeEpocs[index] - this._timeEpocs[index - 1]);
-    };
-    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));
+    }
+    _pushCallback(ratio, datas) {
+        for (let i = 0; i < this._callbackmethods.length; i++) {
+            this._callbackmethods[i](ratio, ...datas);
         }
-    };
-    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 () {
+    }
+    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;
+                });
+        }
+        await this._dataPromises[index];
+        return this._datas[index];
+    }
+    _dontRender() {
         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;
-var pointcoordinatesdatacalculator_1 = __importDefault(require("./pointcoordinatesdatacalculator"));
+const pointcoordinatesdatacalculator_1 = __importDefault(require("./pointcoordinatesdatacalculator"));
 exports.PointCoordinatesDataCalculator = pointcoordinatesdatacalculator_1.default;
-var datamanager_1 = __importDefault(require("./datamanager"));
+const datamanager_1 = __importDefault(require("./datamanager"));
 exports.HeatWaveDataManager = datamanager_1.default;