@pirireis/webglobeplugins 0.9.11 → 0.9.13

package/circle-line-chain/plugin.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CircleLineChainPlugin = void 0;
-var naive_accurate_flexible_1 = require("../programs/line-on-globe/naive-accurate-flexible");
-var circle_accurate_flat_1 = require("../programs/line-on-globe/circle-accurate-flat");
-var circle_accurate_3d_1 = require("../programs/line-on-globe/circle-accurate-3d");
-var account_1 = require("../util/account");
-var chain_list_map_1 = require("./chain-list-map");
-var get_1 = require("../util/check/get");
-var util_1 = require("./util");
-var data_filler_1 = require("../util/jshelpers/data-filler");
-var context_text3_1 = require("../write-text/context-text3");
-var typecheck_1 = require("../util/check/typecheck");
-var attribute_loader_1 = require("../util/gl-util/buffer/attribute-loader");
-var index_1 = require("../util/geometry/index");
+import { LineOnGlobeCache } from '../programs/line-on-globe/naive-accurate-flexible';
+import { CircleCache, EDGE_COUNT as flatCircleEdgeCount, centerCoords2dflatDataCreator } from '../programs/line-on-globe/circle-accurate-flat';
+import { CircleCache as Circle3DCache } from '../programs/line-on-globe/circle-accurate-3d';
+import { BufferOrchestrator, BufferManager } from "../util/account";
+import { ChainListMap } from "./chain-list-map";
+import { mapGetOrThrow } from "../util/check/get";
+import { keyMethod } from "./util";
+import { populateFloat32Array } from "../util/jshelpers/data-filler";
+import { ContextTextWriter3 } from '../write-text/context-text3';
+import { isBoolean, constraintFloat, opacityCheck } from '../util/check/typecheck';
+import { createBufferAndReadInfo } from '../util/gl-util/buffer/attribute-loader';
+import { sphereCoord } from '../util/geometry/index';
 /**
  * Insert info to chain list map (nodes and properties)
  *
@@ -55,34 +52,33 @@ var index_1 = require("../util/geometry/index");
  *
  * //property {Array<Node>} nodes
  */
-var textWriterGetOrThrow = (0, get_1.mapGetOrThrow)("textWriterIDs is invalid");
-var CircleLineChainPlugin = /** @class */ (function () {
+const textWriterGetOrThrow = mapGetOrThrow("textWriterIDs is invalid");
+export class CircleLineChainPlugin {
     /**
      *
      * @param {*} id
      * @param {Map<[key, ContextTextWriter3]} textWritersMap //import { ContextTextWriter3 } from "@pirireis/webglobeplugins/write-text/context-text3";
      */
-    function CircleLineChainPlugin(id, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.drawCircleOn, drawCircleOn = _c === void 0 ? true : _c, _d = _b.textWritersMap, textWritersMap = _d === void 0 ? new Map() : _d, _e = _b.textDataPreAdaptor, textDataPreAdaptor = _e === void 0 ? null : _e, _f = _b.circleFlatEdgeCount, circleFlatEdgeCount = _f === void 0 ? circle_accurate_flat_1.EDGE_COUNT - 2 : _f;
+    constructor(id, { drawCircleOn = true, textWritersMap = new Map(), textDataPreAdaptor = null, circleFlatEdgeCount = flatCircleEdgeCount - 2 } = {}) {
         this.id = id;
         this._checktextWritersMap(textWritersMap);
         this._textWritersMap = textWritersMap;
-        this._textWritersMap.forEach(function (writer) { return writer.setKeyAdaptor(function (v, i, c, properties) { return v.__identity__; }); });
+        this._textWritersMap.forEach((writer) => writer.setKeyAdaptor((v, i, c, properties) => v.__identity__));
         this._opacity = 1;
-        this._chainListMap = new chain_list_map_1.ChainListMap(util_1.keyMethod);
-        this.bufferOrchestrator = new account_1.BufferOrchestrator({ capacity: 10 });
+        this._chainListMap = new ChainListMap(keyMethod);
+        this.bufferOrchestrator = new BufferOrchestrator({ capacity: 10 });
         this._drawCircleOn = drawCircleOn;
         this._textDataPreAdaptor = textDataPreAdaptor;
         this._circleFlatEdgeCount = circleFlatEdgeCount + 2;
     }
     // init
     // API
-    CircleLineChainPlugin.prototype.setDrawCircleOn = function (bool) {
+    setDrawCircleOn(bool) {
         if (typeof bool !== 'boolean')
             throw new Error("setDrawCircleOn parameter must be a boolean");
         this._drawCircleOn = bool;
         this.globe.DrawRender();
-    };
+    }
     // ---- updateBulk
     /**
      * @param {Array<chain>} data
@@ -91,57 +87,48 @@ var CircleLineChainPlugin = /** @class */ (function () {
      * @property {Array<Node>} nodes
 
      */
-    CircleLineChainPlugin.prototype.updateCoordinatesBulk = function (data, _a) {
-        var _this = this;
-        var _b = _a === void 0 ? {} : _a, _c = _b.textWriterIDs, textWriterIDs = _c === void 0 ? [] : _c;
+    updateCoordinatesBulk(data, { textWriterIDs = [] } = {}) {
         // update implicit data structure
         // find keys to update.. (inserted data and the radius of "from")
         // updateBuffers
         // update text
-        var chainKeys = [];
-        var _loop_1 = function (chain) {
+        const chainKeys = [];
+        for (const chain of data) {
             chainKeys.push(chain.chainKey);
-            chain.nodes.forEach(function (node) {
-                _this._chainListMap.updateCoordsinatesOfNode(node, chain.chainKey);
+            chain.nodes.forEach((node) => {
+                this._chainListMap.updateCoordsinatesOfNode(node, chain.chainKey);
             });
-        };
-        for (var _i = 0, data_1 = data; _i < data_1.length; _i++) {
-            var chain = data_1[_i];
-            _loop_1(chain);
         }
         this._reconstructChains(chainKeys);
         this._updateTexts(chainKeys, textWriterIDs);
-    };
+    }
     /**
      * @param {*} chainKey
      * @param {Array<{nodeKey, circleProperties:Map[propertyName ,value],  lineProperties:Map[propertyName ,value] }} propertyMap
      */
-    CircleLineChainPlugin.prototype.updateNodesProperties = function (chainKey, nodesAndPropertyMap, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.textWriterIDs, textWriterIDs = _c === void 0 ? [] : _c;
+    updateNodesProperties(chainKey, nodesAndPropertyMap, { textWriterIDs = [] } = {}) {
         this._chainListMap.updateNodesProperties(chainKey, nodesAndPropertyMap);
         this._reconstructChains([chainKey]);
         this._updateTexts([chainKey], textWriterIDs);
         this.globe.DrawRender();
-    };
+    }
     /**
      * @param {*} chainKey
      * @param {Map<propertyName ,value} propertyMap
      */
-    CircleLineChainPlugin.prototype.updateChainProperties = function (chainKey, propertyMap, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.textWriterIDs, textWriterIDs = _c === void 0 ? [] : _c;
+    updateChainProperties(chainKey, propertyMap, { textWriterIDs = [] } = {}) {
         this._chainListMap.updateChainProperties(chainKey, propertyMap);
         this._reconstructChains([chainKey]);
         if (textWriterIDs)
             this._updateTexts([chainKey], textWriterIDs);
-    };
-    CircleLineChainPlugin.prototype.updateNodeCoordinates = function (node, chainKey, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.textWriterIDs, textWriterIDs = _c === void 0 ? [] : _c;
+    }
+    updateNodeCoordinates(node, chainKey, { textWriterIDs = [] } = {}) {
         this._chainListMap.updateCoordsinatesOfNode(node, chainKey);
         if (textWriterIDs)
             this._updateTexts([chainKey], textWriterIDs);
         this._reconstructChains([chainKey]);
         this.globe.DrawRender();
-    };
+    }
     /**
      *
 
@@ -149,27 +136,23 @@ var CircleLineChainPlugin = /** @class */ (function () {
      * @param {Array<string>} textWriterIDs | textWritersMap keys to be used for writing text.
      * @param {Array<string>} chainKeys | if empty, all texts will be updated
      */
-    CircleLineChainPlugin.prototype.updateText = function (textWriterIDs, chainKeys) {
-        if (textWriterIDs === void 0) { textWriterIDs = []; }
-        if (chainKeys === void 0) { chainKeys = null; }
+    updateText(textWriterIDs = [], chainKeys = null) {
         if (chainKeys === null)
             chainKeys = this._chainListMap.getAllChainKeysIterator();
         this._updateTexts(chainKeys, textWriterIDs);
         this.globe.DrawRender();
-    };
+    }
     // ---- insertBulk
     /**
      *
      * @param {Array<chain>} data
      */
-    CircleLineChainPlugin.prototype.insertBulk = function (data, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.textWriterIDs, textWriterIDs = _c === void 0 ? [] : _c;
+    insertBulk(data, { textWriterIDs = [] } = {}) {
         // first insert everything to implicit structure,
         // then iterate over data again to update text
         // let _reconstractChainBufferData method interact with data and bufferOrchestrator.
-        var chainKeysToConstruct = [];
-        for (var _i = 0, data_2 = data; _i < data_2.length; _i++) {
-            var _d = data_2[_i], chainKey = _d.chainKey, chainProperties = _d.chainProperties, nodes = _d.nodes;
+        const chainKeysToConstruct = [];
+        for (const { chainKey, chainProperties, nodes } of data) {
             this._chainListMap.setChain(chainKey, nodes);
             this._chainListMap.setChainProperties(chainKey, chainProperties);
             chainKeysToConstruct.push(chainKey);
@@ -178,112 +161,104 @@ var CircleLineChainPlugin = /** @class */ (function () {
         if (textWriterIDs)
             this._updateTexts(chainKeysToConstruct, textWriterIDs);
         this.globe.DrawRender();
-    };
+    }
     /**
      * @param {Node} node
      * @param {*} chainKey
      * @param {*} theNodeKeyFront | node key of the next node, null places to the last
      */
-    CircleLineChainPlugin.prototype.addNode = function (node, chainKey, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.theNodeKeyFront, theNodeKeyFront = _c === void 0 ? null : _c, _d = _b.textWriterIDs, textWriterIDs = _d === void 0 ? [] : _d;
+    addNode(node, chainKey, { theNodeKeyFront = null, textWriterIDs = [] } = {}) {
         this._chainListMap.addNode(node, chainKey, theNodeKeyFront);
         if (textWriterIDs)
             this._updateTexts([chainKey], textWriterIDs);
         this._reconstructChains([chainKey]);
         this.globe.DrawRender();
-    };
-    CircleLineChainPlugin.prototype.setOpacity = function (opacity) {
-        (0, typecheck_1.opacityCheck)(opacity);
-        this._textWritersMap.forEach(function (writer) { return writer.setOpacity(opacity); });
+    }
+    setOpacity(opacity) {
+        opacityCheck(opacity);
+        this._textWritersMap.forEach((writer) => writer.setOpacity(opacity));
         this._opacity = opacity;
         this.globe.DrawRender();
-    };
-    CircleLineChainPlugin.prototype.getChain = function (chainKey) {
+    }
+    getChain(chainKey) {
         this._chainListMap.getChain(chainKey);
-    };
+    }
     /**
      *
      * @param {*} chainKeys
      */
-    CircleLineChainPlugin.prototype.deleteChains = function (chainKeys) {
-        var bufferKeys = [];
-        for (var _i = 0, chainKeys_1 = chainKeys; _i < chainKeys_1.length; _i++) {
-            var chainKey = chainKeys_1[_i];
-            bufferKeys.push.apply(bufferKeys, this._chainListMap.deleteChainAndReturnChainKeys(chainKey));
+    deleteChains(chainKeys) {
+        const bufferKeys = [];
+        for (const chainKey of chainKeys) {
+            bufferKeys.push(...this._chainListMap.deleteChainAndReturnChainKeys(chainKey));
         }
-        this._textWritersMap.forEach(function (writer) { return writer.deleteTextBulk(bufferKeys); });
+        this._textWritersMap.forEach((writer) => writer.deleteTextBulk(bufferKeys));
         this._updateTexts(chainKeys, this._textWritersMap.keys());
         this.bufferOrchestrator.deleteBulk(bufferKeys, this.bufferManagersCompMap);
         this.globe.DrawRender();
-    };
+    }
     /**
      *
      * @param {Array<{chainKey, nodeKeys:[]} keysAndNodes
      */
-    CircleLineChainPlugin.prototype.deleteNodes = function (keysAndNodes, _a) {
-        var _this = this;
-        var _b = _a === void 0 ? {} : _a, _c = _b.textWriterIDs, textWriterIDs = _c === void 0 ? [] : _c;
-        var bufferKeys = [];
-        var chainKeysToReconstuct = [];
-        keysAndNodes.forEach(function (_a) {
-            var chainKey = _a.chainKey, nodeKeys = _a.nodeKeys;
-            bufferKeys.push.apply(bufferKeys, _this._chainListMap.deleteNodesBelongToAChain(chainKey, nodeKeys));
+    deleteNodes(keysAndNodes, { textWriterIDs = [] } = {}) {
+        const bufferKeys = [];
+        const chainKeysToReconstuct = [];
+        keysAndNodes.forEach(({ chainKey, nodeKeys }) => {
+            bufferKeys.push(...this._chainListMap.deleteNodesBelongToAChain(chainKey, nodeKeys));
             chainKeysToReconstuct.push(chainKey);
         });
-        this._textWritersMap.forEach(function (writer) { return writer.deleteTextBulk(bufferKeys); });
+        this._textWritersMap.forEach((writer) => writer.deleteTextBulk(bufferKeys));
         this.bufferOrchestrator.deleteBulk(bufferKeys, this.bufferManagersCompMap);
         this._reconstructChains(chainKeysToReconstuct);
         this._updateTexts(chainKeysToReconstuct, textWriterIDs);
         this.globe.DrawRender();
-    };
-    CircleLineChainPlugin.prototype.init = function (globe, gl) {
+    }
+    init(globe, gl) {
         this.gl = gl;
         this.globe = globe;
         this._initOrchestrations();
-    };
+    }
     // implicit
-    CircleLineChainPlugin.prototype._checktextWritersMap = function (textWritersMap) {
+    _checktextWritersMap(textWritersMap) {
         if (!(textWritersMap instanceof Map))
             throw new Error("textWritersMap is not an instance of Map");
-        textWritersMap.forEach(function (v) {
-            if (!(v instanceof context_text3_1.ContextTextWriter3))
+        textWritersMap.forEach((v) => {
+            if (!(v instanceof ContextTextWriter3))
                 throw new Error("textWritersMap element is not an instance of ContextTextWriter3");
         });
-    };
-    CircleLineChainPlugin.prototype._initOrchestrations = function () {
-        var _a, _b, _c;
-        var _this = this;
-        var _d = this, gl = _d.gl, globe = _d.globe;
-        this.lineProgram = naive_accurate_flexible_1.LineOnGlobeCache.get(globe);
-        this.circleProgram2d = circle_accurate_flat_1.CircleCache.get(globe);
-        this.circle3DProgram = circle_accurate_3d_1.CircleCache.get(globe);
-        var _circleFlatEdgeCount = this._circleFlatEdgeCount;
+    }
+    _initOrchestrations() {
+        const { gl, globe } = this;
+        this.lineProgram = LineOnGlobeCache.get(globe);
+        this.circleProgram2d = CircleCache.get(globe);
+        this.circle3DProgram = Circle3DCache.get(globe);
+        const _circleFlatEdgeCount = this._circleFlatEdgeCount;
         {
             // createBuffers
-            var bufferType = "DYNAMIC_DRAW";
-            var initialCapacity = this.bufferOrchestrator.capacity;
+            const bufferType = "DYNAMIC_DRAW";
+            const initialCapacity = this.bufferOrchestrator.capacity;
             this.bufferManagersCompMap = new Map([
                 ["centerCoords2d", {
-                        'bufferManager': new account_1.BufferManager(gl, 2, { bufferType: bufferType, initialCapacity: initialCapacity }),
-                        'adaptor': function (item) { return new Float32Array(globe.api_GetMercator2DPoint(item.long, item.lat)); },
+                        'bufferManager': new BufferManager(gl, 2, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array(globe.api_GetMercator2DPoint(item.long, item.lat)),
                     }],
                 ["centerCoords3d", {
-                        'bufferManager': new account_1.BufferManager(gl, 3, { bufferType: bufferType, initialCapacity: initialCapacity }),
-                        'adaptor': function (item) { return (0, index_1.sphereCoord)(item.long, item.lat, globe, item.altitude); },
+                        'bufferManager': new BufferManager(gl, 3, { bufferType, initialCapacity }),
+                        'adaptor': (item) => sphereCoord(item.long, item.lat, globe, item.altitude),
                     }],
                 ["targetCoords2d", {
-                        'bufferManager': new account_1.BufferManager(gl, 2, { bufferType: bufferType, initialCapacity: initialCapacity }),
-                        'adaptor': function (item) { return new Float32Array(globe.api_GetMercator2DPoint(item.targetLong, item.targetLat)); },
+                        'bufferManager': new BufferManager(gl, 2, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array(globe.api_GetMercator2DPoint(item.targetLong, item.targetLat)),
                     }],
                 ["targetCoords3d", {
-                        'bufferManager': new account_1.BufferManager(gl, 3, { bufferType: bufferType, initialCapacity: initialCapacity }),
-                        'adaptor': function (item) { return (0, index_1.sphereCoord)(item.targetLong, item.targetLat, globe, item.altitude); },
+                        'bufferManager': new BufferManager(gl, 3, { bufferType, initialCapacity }),
+                        'adaptor': (item) => sphereCoord(item.targetLong, item.targetLat, globe, item.altitude),
                     }],
                 ["rgba", {
-                        'bufferManager': new account_1.BufferManager(gl, 4, { bufferType: bufferType, initialCapacity: initialCapacity }),
-                        'adaptor': function (item) {
-                            var _a;
-                            if ((_a = item.lineProperties) === null || _a === void 0 ? void 0 : _a.rgba)
+                        'bufferManager': new BufferManager(gl, 4, { bufferType, initialCapacity }),
+                        'adaptor': (item) => {
+                            if (item.lineProperties?.rgba)
                                 return new Float32Array(item.lineProperties.rgba);
                             return new Float32Array(item.chainProperties.rgba);
                         }
@@ -293,87 +268,80 @@ var CircleLineChainPlugin = /** @class */ (function () {
                 //     'adaptor': (item) => new Float32Array([item.bigRadius])
                 // }],
                 ["dashRatio", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType: bufferType, initialCapacity: initialCapacity }),
-                        'adaptor': function (item) { return new Float32Array([item.chainProperties.dashRatio]); }
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.chainProperties.dashRatio])
                     }],
                 ["dashOpacity", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType: bufferType, initialCapacity: initialCapacity }),
-                        'adaptor': function (item) { return new Float32Array([item.chainProperties.dashOpacity]); }
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.chainProperties.dashOpacity])
                     }],
                 ["circleDashAngle", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType: bufferType, initialCapacity: initialCapacity }),
-                        'adaptor': function (item) {
-                            var _a;
-                            if ((_a = item.circleProperties) === null || _a === void 0 ? void 0 : _a.circleDashAngle)
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => {
+                            if (item.circleProperties?.circleDashAngle)
                                 return new Float32Array([item.circleProperties.circleDashAngle / 360]);
                             return new Float32Array([item.chainProperties.circleDashAngle / 360]);
                         }
                     }],
                 ["rgbaCircle", {
-                        "bufferManager": new account_1.BufferManager(gl, 4, { bufferType: bufferType, initialCapacity: initialCapacity }),
-                        "adaptor": function (item) {
-                            var _a;
-                            if ((_a = item.circleProperties) === null || _a === void 0 ? void 0 : _a.rgba)
+                        "bufferManager": new BufferManager(gl, 4, { bufferType, initialCapacity }),
+                        "adaptor": (item) => {
+                            if (item.circleProperties?.rgba)
                                 return new Float32Array(item.circleProperties.rgba);
                             return new Float32Array(item.chainProperties.rgba);
                         }
                     }],
                 // Mercator buffers
                 ["circleDashAngleMercator", {
-                        'bufferManager': new account_1.BufferManager(gl, 1 * _circleFlatEdgeCount, { bufferType: bufferType, initialCapacity: initialCapacity }),
-                        'adaptor': function (item) {
-                            var _a;
-                            if ((_a = item.circleProperties) === null || _a === void 0 ? void 0 : _a.circleDashAngle)
+                        'bufferManager': new BufferManager(gl, 1 * _circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        'adaptor': (item) => {
+                            if (item.circleProperties?.circleDashAngle)
                                 return new Float32Array([item.circleProperties.circleDashAngle / 360]);
-                            return data_filler_1.populateFloat32Array.fillFloat32Array(_circleFlatEdgeCount, item.chainProperties.circleDashAngle / 360);
+                            return populateFloat32Array.fillFloat32Array(_circleFlatEdgeCount, item.chainProperties.circleDashAngle / 360);
                         }
                     }],
                 ["rgbaCircleMercator", {
-                        "bufferManager": new account_1.BufferManager(gl, 4 * _circleFlatEdgeCount, { bufferType: bufferType, initialCapacity: initialCapacity }),
-                        "adaptor": function (item) {
-                            var _a;
-                            if ((_a = item.circleProperties) === null || _a === void 0 ? void 0 : _a.rgba)
-                                return data_filler_1.populateFloat32Array.fillWithListData(_circleFlatEdgeCount, item.circleProperties.rgba);
-                            return data_filler_1.populateFloat32Array.fillWithListData(_circleFlatEdgeCount, item.chainProperties.rgba);
+                        "bufferManager": new BufferManager(gl, 4 * _circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        "adaptor": (item) => {
+                            if (item.circleProperties?.rgba)
+                                return populateFloat32Array.fillWithListData(_circleFlatEdgeCount, item.circleProperties.rgba);
+                            return populateFloat32Array.fillWithListData(_circleFlatEdgeCount, item.chainProperties.rgba);
                         }
                     }],
                 ["dashOpacityMercator", {
-                        'bufferManager': new account_1.BufferManager(gl, 1 * _circleFlatEdgeCount, { bufferType: bufferType, initialCapacity: initialCapacity }),
-                        'adaptor': function (item) { return data_filler_1.populateFloat32Array.fillFloat32Array(_circleFlatEdgeCount, item.chainProperties.dashOpacity); }
+                        'bufferManager': new BufferManager(gl, 1 * _circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        'adaptor': (item) => populateFloat32Array.fillFloat32Array(_circleFlatEdgeCount, item.chainProperties.dashOpacity)
                     }],
                 ["centerCoords2dMercator", {
-                        'bufferManager': new account_1.BufferManager(gl, 2 * _circleFlatEdgeCount, { bufferType: bufferType, initialCapacity: initialCapacity }),
-                        'adaptor': function (item) { return item.centerCoords2dflat; },
+                        'bufferManager': new BufferManager(gl, 2 * _circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        'adaptor': (item) => item.centerCoords2dflat,
                     }],
             ]);
-            var obj_1 = function (key) { return (0, attribute_loader_1.createBufferAndReadInfo)(_this.bufferManagersCompMap.get(key).bufferManager.buffer); };
-            this.lineVao = (_a = this.lineProgram).createVAO.apply(_a, ['centerCoords2d', 'centerCoords3d', 'targetCoords2d', 'targetCoords3d', 'dashRatio', 'dashOpacity', 'rgba'
-            ].map(function (key) { return obj_1(key); }));
-            this.circleVao2d = (_b = this.circleProgram2d).createVAO.apply(_b, ["centerCoords2dMercator", "rgbaCircleMercator", "circleDashAngleMercator", "dashOpacityMercator"
-            ].map(function (key) { return obj_1(key); }));
-            this.circle3DVao = (_c = this.circle3DProgram).createVAO.apply(_c, ["centerCoords3d", "targetCoords3d", "rgbaCircle", "circleDashAngle", "dashOpacity"
-            ].map(function (key) { return obj_1(key); }));
+            const obj = (key) => createBufferAndReadInfo(this.bufferManagersCompMap.get(key).bufferManager.buffer);
+            this.lineVao = this.lineProgram.createVAO(...['centerCoords2d', 'centerCoords3d', 'targetCoords2d', 'targetCoords3d', 'dashRatio', 'dashOpacity', 'rgba'
+            ].map(key => obj(key)));
+            this.circleVao2d = this.circleProgram2d.createVAO(...["centerCoords2dMercator", "rgbaCircleMercator", "circleDashAngleMercator", "dashOpacityMercator"
+            ].map(key => obj(key)));
+            this.circle3DVao = this.circle3DProgram.createVAO(...["centerCoords3d", "targetCoords3d", "rgbaCircle", "circleDashAngle", "dashOpacity"
+            ].map(key => obj(key)));
         }
-    };
-    CircleLineChainPlugin.prototype._updateTexts = function (chainKeys, textWriterIDs) {
-        var _this = this;
+    }
+    _updateTexts(chainKeys, textWriterIDs) {
         if (textWriterIDs.length === 0)
             return;
-        var textWriters = textWriterGetOrThrow(this._textWritersMap, textWriterIDs);
-        chainKeys.forEach(function (chainKey) {
-            _this._chainListMap.textUpdate(chainKey, textWriters, _this._textDataPreAdaptor);
+        const textWriters = textWriterGetOrThrow(this._textWritersMap, textWriterIDs);
+        chainKeys.forEach((chainKey) => {
+            this._chainListMap.textUpdate(chainKey, textWriters, this._textDataPreAdaptor);
         });
-    };
-    CircleLineChainPlugin.prototype._reconstructChains = function (chainKeys) {
-        var _this = this;
-        var globe = this.globe;
+    }
+    _reconstructChains(chainKeys) {
+        const { globe } = this;
         // const radiusM = radiusMethod(globe);
-        var callback = function (v, i, array, chainProperties) {
-            var _a, _b;
+        const callback = (v, i, array, chainProperties) => {
             if (i === array.length - 1)
                 return null;
-            var centerCoords2dflat = (0, circle_accurate_flat_1.centerCoords2dflatDataCreator)(globe, v.long, v.lat, array[i + 1].long, array[i + 1].lat, { edgeCount: _this._circleFlatEdgeCount });
-            var altitude = ((_b = (_a = v.altitude) !== null && _a !== void 0 ? _a : chainProperties.altitude) !== null && _b !== void 0 ? _b : 0) / 1000;
+            const centerCoords2dflat = centerCoords2dflatDataCreator(globe, v.long, v.lat, array[i + 1].long, array[i + 1].lat, { edgeCount: this._circleFlatEdgeCount });
+            const altitude = (v.altitude ?? chainProperties.altitude ?? 0) / 1000;
             return {
                 chainProperties: chainProperties,
                 // bigRadius: radiusM(v, i, array),
@@ -384,53 +352,52 @@ var CircleLineChainPlugin = /** @class */ (function () {
                 lat: v.lat,
                 lineProperties: v.lineProperties,
                 circleProperties: v.circleProperties,
-                centerCoords2dflat: centerCoords2dflat,
+                centerCoords2dflat,
                 key: v.__identity__
             };
         };
-        var bulkData = [];
-        chainKeys.forEach(function (k) {
-            _this._chainListMap.calculateBufferPropertiesChain(k, callback, bulkData);
+        const bulkData = [];
+        chainKeys.forEach((k) => {
+            this._chainListMap.calculateBufferPropertiesChain(k, callback, bulkData);
         });
         this._insertBulk(bulkData);
-    };
-    CircleLineChainPlugin.prototype._insertBulk = function (bulkData) {
+    }
+    _insertBulk(bulkData) {
         this.bufferOrchestrator.insertBulk(bulkData, this.bufferManagersCompMap);
         this.globe.DrawRender();
-    };
+    }
     // GLOBE API
-    CircleLineChainPlugin.prototype.free = function () {
+    free() {
         if (this.isFreed)
             return;
-        this.bufferManagersCompMap.forEach(function (_a) {
-            var bufferManager = _a.bufferManager;
+        this.bufferManagersCompMap.forEach(({ bufferManager }) => {
             bufferManager.free();
         });
-        naive_accurate_flexible_1.LineOnGlobeCache.release(this.globe);
-        circle_accurate_flat_1.CircleCache.release(this.globe);
-        circle_accurate_3d_1.CircleCache.release(this.globe);
+        LineOnGlobeCache.release(this.globe);
+        CircleCache.release(this.globe);
+        Circle3DCache.release(this.globe);
         // LineToTheOriginCache.release(this.globe);
-        this._textWritersMap.forEach(function (writer) { return writer.free(); });
-        var gl = this.gl;
+        this._textWritersMap.forEach((writer) => writer.free());
+        const { gl } = this;
         gl.deleteVertexArray(this.lineVao);
         gl.deleteVertexArray(this.circleVao2d);
         gl.deleteVertexArray(this.circle3DVao);
         this.lineProgram = null;
         this.circleProgram2d = null;
         this.isFreed = true;
-    };
-    CircleLineChainPlugin.prototype.draw3D = function () {
-        var _a = this, gl = _a.gl, globe = _a.globe;
+    }
+    draw3D() {
+        const { gl, globe } = this;
         gl.disable(gl.DEPTH_TEST);
-        var drawOptions = {
+        const drawOptions = {
             drawRange: {
                 first: 0,
                 count: this.bufferOrchestrator.length
             }
         };
         this.lineProgram.draw(this.lineVao, drawOptions, this._opacity);
-        this._textWritersMap.forEach(function (writer) { return writer.draw(); });
-        var is3D = globe.api_GetCurrentGeometry() === 0;
+        this._textWritersMap.forEach((writer) => writer.draw());
+        const is3D = globe.api_GetCurrentGeometry() === 0;
         if (this._drawCircleOn) {
             if (is3D) {
                 this.circle3DProgram.draw(this.circle3DVao, this.bufferOrchestrator.length, this._opacity);
@@ -440,10 +407,8 @@ var CircleLineChainPlugin = /** @class */ (function () {
             }
         }
         gl.enable(gl.DEPTH_TEST);
-    };
-    return CircleLineChainPlugin;
-}());
-exports.CircleLineChainPlugin = CircleLineChainPlugin;
+    }
+}
 // const radiusMethod = (globe) => (v, i, array) => {
 //     return globe.Math.GetDist3D(v.long, v.lat, array[i + 1].long, array[i + 1].lat)
 // }

package/circle-line-chain/util.js

@@ -1,5 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.keyMethod = void 0;
-var keyMethod = function (chainKey, nodeKey) { return "".concat(chainKey, "_").concat(nodeKey); };
-exports.keyMethod = keyMethod;
+export const keyMethod = (chainKey, nodeKey) => `${chainKey}_${nodeKey}`;