@pirireis/webglobeplugins 0.9.7 → 0.9.8

package/dist/bearing-line/plugin.js

@@ -0,0 +1,449 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RINGPARTIAL_DRAW_MODE = void 0;
+const piece_of_pie_1 = require("../programs/rings/partial-ring/piece-of-pie");
+const naive_accurate_flexible_1 = require("../programs/line-on-globe/naive-accurate-flexible");
+const circle_accurate_3d_1 = require("../programs/line-on-globe/circle-accurate-3d");
+const circle_accurate_flat_1 = require("../programs/line-on-globe/circle-accurate-flat");
+const account_1 = require("../util/account");
+const get_1 = require("../util/check/get");
+const data_filler_1 = require("../util/jshelpers/data-filler");
+const context_text3_1 = require("../write-text/context-text3");
+const typecheck_1 = require("../util/check/typecheck");
+const geometry_1 = require("../util/geometry");
+const attribute_loader_1 = require("../util/gl-util/buffer/attribute-loader");
+exports.RINGPARTIAL_DRAW_MODE = Object.freeze({
+    LINE_STRIP: "LINE_STRIP",
+    TRIANGLE_FAN: "TRIANGLE_FAN",
+});
+/**
+     * @typedef {{key, long, lat, endLong, endLat, bearingAngle, radius,  rgba:[4numbers], rgbaMode, bigRadius, dashRatio, dashOpacity, circleDashAngle}} BearingLineItem
+     * @property {string} key
+     * @property {number} long
+     * @property {number} lat
+     * @property {number} endLong
+     * @property {number} endLat
+     * @property {number} bearingAngle 0-360
+     * @property {number} radius angle ring radius
+     * @property {number} altitude in meters effects all parts of the item
+     * @property {Array<numbers>} rgba [r,g,b,a] 0-1
+     * @property {number} rgbaMode 0 constant, 1 fading, 2 hides angle ring
+     * @property {number} bigRadius undefined means it will be calculated from long, lat, endLong, endLat
+     * @property {number} dashRatio 0-1
+     * @property {number} dashOpacity 0-1
+     * @property {number} circleDashAngle 0-360
+ */
+const textWriterGetOrThrow = (0, get_1.mapGetOrThrow)("BearingLine textContextInjection id does not exist in map");
+const radian = (degree) => degree * Math.PI / 180;
+const integralSec = (angle) => {
+    return Math.log(Math.tan(angle / 2 + Math.PI / 4));
+};
+const calculateStartAngle = (long, lat, endLong, endLat) => {
+    const dLat = (integralSec(endLat) - integralSec(lat)); // Because lines are strectes toward poles.
+    const dLong = endLong - long;
+    let angle = -Math.atan2(dLat, dLong);
+    return angle;
+};
+class BearingLinePlugin {
+    /**
+     * @param {*} id
+     * @param {Map<[key, ContextTextWriter3]>} textWritersMap
+     */
+    constructor(id, { opacity = 1, textWritersMap = new Map(), textDataPreAdaptor = (x) => x, drawVRM = true, drawBearingLine = true, drawAngleRing = true, drawText = true, circleFlatEdgeCount = circle_accurate_flat_1.EDGE_COUNT - 2 } = {}) {
+        this.id = id;
+        this._opacity = opacity;
+        this.bufferOrchestrator = new account_1.BufferOrchestrator({ capacity: 10 });
+        this._checkTextContextWriterInjectionMap(textWritersMap);
+        this._textWritersMap = textWritersMap;
+        this._textWritersMap.forEach((writer) => writer.keyAdaptor = (item) => item.key);
+        this.drawVRM = drawVRM;
+        this.drawBearingLine = drawBearingLine;
+        this.drawAngleRing = drawAngleRing;
+        this._textDataPreAdaptor = textDataPreAdaptor;
+        this.drawText = drawText;
+        this._memoryForText = new Map();
+        this.circleFlatEdgeCount = circleFlatEdgeCount + 2;
+    }
+    setDoDrawVRM(bool) {
+        (0, typecheck_1.isBoolean)(bool);
+        if (bool === this.drawVRM)
+            return;
+        this.drawVRM = bool;
+        this.globe.DrawRender();
+    }
+    setDoDrawText(bool) {
+        (0, typecheck_1.isBoolean)(bool);
+        if (bool === this.drawText)
+            return;
+        this.drawText = bool;
+        this.globe.DrawRender();
+    }
+    setDoDrawText(bool) {
+        (0, typecheck_1.isBoolean)(bool);
+        if (bool === this.drawText)
+            return;
+        this.drawText = bool;
+        this.globe.DrawRender();
+    }
+    setDoDrawAngleRing(bool) {
+        (0, typecheck_1.isBoolean)(bool);
+        if (bool === this.drawAngleRing)
+            return;
+        this.drawAngleRing = bool;
+        this.globe.DrawRender();
+    }
+    setOpacity(opacity) {
+        (0, typecheck_1.constraintFloat)(opacity, 0, 1);
+        this._opacity = opacity;
+        this._textWritersMap.forEach((writer) => writer.setOpacity(opacity));
+        this.globe.DrawRender();
+    }
+    /**
+
+     * @param {Array<BearingLineItem>} items
+     * @param {Array<string>} textWriterIDs | textWritersMap keys to be used for writing text.
+     */
+    insertBulk(items, { textWriterIDs = [] } = {}) {
+        const { globe, bufferOrchestrator, bufferManagersCompMap } = this; // angleTextContext, distanceTextContext,
+        const data = [];
+        for (let item of items) {
+            data.push(this.__insertAdaptor(item));
+        }
+        bufferOrchestrator.insertBulk(data, bufferManagersCompMap);
+        this.__insertTexts(items, textWriterIDs);
+        globe.DrawRender();
+    }
+    /**
+     * @param {Array<string>} textWriterIDs | textWritersMap keys to be used for writing text.
+     * @param {Array<string>} itemKeys | if empty, all texts will be updated.
+     */
+    updateText(textWriterIDs = [], itemKeys = null) {
+        const textWritersMap = textWriterGetOrThrow(this._textWritersMap, textWriterIDs);
+        if (itemKeys === null) {
+            this._memoryForText.forEach((item) => {
+                let _item = this._textDataPreAdaptor(item);
+                textWritersMap.forEach((writer) => writer.insertText(_item));
+            });
+        }
+        else {
+            itemKeys.forEach((key) => {
+                let item = this._memoryForText.get(key);
+                if (item === undefined)
+                    return;
+                let _item = this._textDataPreAdaptor(item);
+                textWritersMap.forEach((writer) => writer.insertText(_item));
+            });
+        }
+        this.globe.DrawRender();
+    }
+    deleteBulk(keys) {
+        this.bufferOrchestrator.deleteBulk(keys, this.bufferManagersCompMap);
+        for (const key of keys) {
+            this._memoryForText.delete(key);
+        }
+        this._deleteTexts(keys);
+        this.globe.DrawRender();
+    }
+    defrag() {
+        this.bufferOrchestrator.defrag(this.bufferManagersCompMap);
+    }
+    /**
+     * @param {Array<{key, long, lat, endLong, endLat, bearingAngle}>} items
+     * @param {Array<string>} textWriterIDs | textWritersMap keys to be used for writing text.
+     */
+    updateCoordinatesBulk(items, { textWriterIDs = [] } = {}) {
+        const { globe, bufferOrchestrator, bufferManagersCompMap, } = this;
+        const data = [];
+        for (let item of items) {
+            data.push(this.__updateCoordsAdaptor(item));
+        }
+        this.__insertTexts(items, textWriterIDs);
+        bufferOrchestrator.updateBulk(data, bufferManagersCompMap, ["centerCoords2d", "centerCoords3d", "targetCoords2d", "targetCoords3d",
+            "startAngle2d", "tailAngle2d", "startAngle3d", "tailAngle3d", "bearingTargetCoords2d", "bearingTargetCoords3d", "centerCoords2dflat",
+            "bigRadius", "radius"]);
+        globe.DrawRender();
+    }
+    /**
+     *
+     * @param {Array<BearingLineItem>} items some colums EXCEPT positional ones
+     * @param {string} propertyIDs
+     * @param {string} textWriterIDs
+     * Do NOT send empty data if property ID of this data is entered or NaN is loaded to the buffer, resulting in an unwanted behaviour.
+     *{ textWriterIDs = []}
+     */
+    updatePartial(items, propertyIDs = [], { textWriterIDs = [] } = {}) {
+        if (propertyIDs.length === 0)
+            console.warn("updatePartial is called with no target propertyIDs");
+        const fixedPropertyIDs = this.__fixPartialProperties(propertyIDs);
+        const { bufferOrchestrator, bufferManagersCompMap } = this;
+        bufferOrchestrator.updateBulk(items, bufferManagersCompMap, fixedPropertyIDs);
+        // patch to update text opacity
+        this.__insertTexts(items, textWriterIDs);
+        this.globe.DrawRender();
+    }
+    // Private methods
+    _checkTextContextWriterInjectionMap(textContextWriterInjectionMap) {
+        if (!(textContextWriterInjectionMap instanceof Map))
+            throw new Error("textContextWriterInjectionMap is not an instance of Map");
+        textContextWriterInjectionMap.forEach((v) => {
+            if (!(v instanceof context_text3_1.ContextTextWriter3))
+                throw new Error("textContextWriterInjectionMap element is not an instance of ContextTextWriter3");
+        });
+    }
+    __insertTexts(items, textWriterIDs) {
+        const textWritersMap = textWriterGetOrThrow(this._textWritersMap, textWriterIDs);
+        for (const item of items) {
+            const oldItem = this._memoryForText.get(item.key);
+            let _item = oldItem !== undefined ? { ...oldItem, ...item } : item;
+            this._memoryForText.set(item.key, _item);
+            if (this._textDataPreAdaptor !== null)
+                _item = this._textDataPreAdaptor(_item);
+            textWritersMap.forEach((writer) => writer.insertText(_item));
+        }
+    }
+    __insertAdaptor(item) {
+        const rgba = item.rgba !== undefined ? item.rgba : [0, 0, 0, 0];
+        const rgbaMode = item.rgbaMode !== undefined ? item.rgbaMode : 0;
+        const dashRatio = item.dashRatio !== undefined ? item.dashRatio : 1.0;
+        const dashOpacity = item.dashOpacity !== undefined ? item.dashOpacity : 0.9;
+        const circleDashAngle = item.circleDashAngle !== undefined ? item.circleDashAngle : 360;
+        const coordsData = this.__updateCoordsAdaptor(item);
+        return {
+            ...coordsData,
+            rgba,
+            dashRatio,
+            dashOpacity,
+            circleDashAngle,
+            rgbaMode
+        };
+    }
+    __updateCoordsAdaptor(item) {
+        var _a, _b;
+        const { globe } = this;
+        const lat = radian(item.lat);
+        const long = radian(item.long);
+        const endLat = radian(item.endLat);
+        const endLong = radian(item.endLong);
+        const altitude = ((_a = item.altitude) !== null && _a !== void 0 ? _a : 0) / 1000;
+        const bigRadius = (_b = item.bigRadius) !== null && _b !== void 0 ? _b : globe.Math.GetDist2D(item.long, item.lat, item.endLong, item.endLat);
+        const radius = item.radius !== undefined ? item.radius : bigRadius * 0.2;
+        const { long: bearingLong, lat: bearingLat } = globe.Math.FindPointByPolar(item.long, item.lat, bigRadius, item.bearingAngle);
+        const startAngle2d = calculateStartAngle(long, lat, endLong, endLat);
+        const bearingAngle2d = calculateStartAngle(long, lat, radian(bearingLong), radian(bearingLat));
+        let tailAngle2d = bearingAngle2d - startAngle2d;
+        if (tailAngle2d > 0) {
+            tailAngle2d -= Math.PI * 2;
+        }
+        const bearingAngle = radian(item.bearingAngle - 90);
+        const startAngleOfCircle = globe.Math.GetAzimuthAngle(item.long, item.lat, item.endLong, item.endLat); //startAngle2d * 180 / Math.PI;
+        const startAngle3d = radian(startAngleOfCircle) - radian(90);
+        let tailAngle3d = bearingAngle - startAngle3d;
+        if (tailAngle3d > 0) {
+            tailAngle3d -= Math.PI * 2;
+        }
+        const centerCoords2dflat = (0, circle_accurate_flat_1.centerCoords2dflatDataCreator)(globe, item.long, item.lat, item.endLong, item.endLat, { startAngleOfCircle, edgeCount: this.circleFlatEdgeCount });
+        return {
+            key: item.key,
+            lat: item.lat,
+            long: item.long,
+            endLat: item.endLat,
+            endLong: item.endLong,
+            altitude,
+            bearingAngle,
+            radius,
+            bigRadius,
+            startAngle2d,
+            tailAngle2d,
+            startAngle3d,
+            tailAngle3d,
+            bearingLong,
+            bearingLat,
+            centerCoords2dflat
+        };
+    }
+    __fixPartialProperties(propertyIDs) {
+        const s = new Set(["rgba", "dashOpacity", "circleDashAngle"]);
+        const result = [];
+        for (const item of propertyIDs) {
+            result.push(item);
+            if (s.has(item)) {
+                result.push(item + "Mercator");
+            }
+        }
+        return result;
+    }
+    // Globe API
+    init(globe, gl) {
+        this.gl = gl;
+        this.globe = globe;
+        this.lineProgram = naive_accurate_flexible_1.LineOnGlobeCache.get(globe);
+        this.pieceOfPieProgram = piece_of_pie_1.PieceOfPieProgramCache.get(globe);
+        this.circleProgram = circle_accurate_flat_1.CircleCache.get(globe);
+        this.circle3DProgram = circle_accurate_3d_1.CircleCache.get(globe);
+        const circleFlatEdgeCount = this.circleFlatEdgeCount;
+        {
+            // createBuffers
+            const bufferType = "DYNAMIC_DRAW";
+            const initialCapacity = this.bufferOrchestrator.capacity;
+            this.bufferManagersCompMap = new Map([
+                ["centerCoords2d", {
+                        'bufferManager': new account_1.BufferManager(gl, 2, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array(globe.api_GetMercator2DPoint(item.long, item.lat)),
+                    }],
+                ["centerCoords2dflat", {
+                        'bufferManager': new account_1.BufferManager(gl, circleFlatEdgeCount * 2, { bufferType, initialCapacity }),
+                        'adaptor': (item) => item.centerCoords2dflat,
+                    }],
+                ["centerCoords3d", {
+                        'bufferManager': new account_1.BufferManager(gl, 3, { bufferType, initialCapacity }),
+                        'adaptor': (item) => (0, geometry_1.sphereCoord)(item.long, item.lat, globe, item.altitude),
+                    }],
+                ["targetCoords2d", {
+                        'bufferManager': new account_1.BufferManager(gl, 2, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array(globe.api_GetMercator2DPoint(item.endLong, item.endLat))
+                    }],
+                ["targetCoords3d", {
+                        'bufferManager': new account_1.BufferManager(gl, 3, { bufferType, initialCapacity }),
+                        'adaptor': (item) => (0, geometry_1.sphereCoord)(item.endLong, item.endLat, globe, item.altitude)
+                    }],
+                ["bearingTargetCoords2d", {
+                        'bufferManager': new account_1.BufferManager(gl, 2, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array(globe.api_GetMercator2DPoint(item.bearingLong, item.bearingLat))
+                    }],
+                ["bearingTargetCoords3d", {
+                        'bufferManager': new account_1.BufferManager(gl, 3, { bufferType, initialCapacity }),
+                        'adaptor': (item) => (0, geometry_1.sphereCoord)(item.bearingLong, item.bearingLat, globe, item.altitude)
+                    }],
+                ["startAngle2d", {
+                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.startAngle2d])
+                    }],
+                ["tailAngle2d", {
+                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.tailAngle2d])
+                    }],
+                ["startAngle3d", {
+                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.startAngle3d])
+                    }],
+                ["tailAngle3d", {
+                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.tailAngle3d])
+                    }],
+                ["bearingDashRatio", {
+                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([0])
+                    }],
+                ["rgba", {
+                        'bufferManager': new account_1.BufferManager(gl, 4, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array(item.rgba)
+                    }],
+                ["radius", {
+                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.radius])
+                    }],
+                ["rgbaMode", {
+                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.rgbaMode])
+                    }],
+                ["dashRatio", {
+                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.dashRatio])
+                    }],
+                ["bigRadius", {
+                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.bigRadius])
+                    }],
+                ["dashOpacity", {
+                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.dashOpacity]),
+                    }],
+                ["circleDashAngle", {
+                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.circleDashAngle / 360]),
+                    }],
+                // Mercator circle properties are duplicated for the sake of performance.
+                ["rgbaMercator", {
+                        'bufferManager': new account_1.BufferManager(gl, 4 * circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        'adaptor': (item) => data_filler_1.populateFloat32Array.fillWithListData(circleFlatEdgeCount, item.rgba),
+                    }],
+                ["circleDashAngleMercator", {
+                        'bufferManager': new account_1.BufferManager(gl, circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        'adaptor': (item) => data_filler_1.populateFloat32Array.fillFloat32Array(circleFlatEdgeCount, item.circleDashAngle / 360),
+                    }],
+                ["dashOpacityMercator", {
+                        'bufferManager': new account_1.BufferManager(gl, circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        'adaptor': (item) => data_filler_1.populateFloat32Array.fillFloat32Array(circleFlatEdgeCount, item.dashOpacity),
+                    }],
+            ]);
+        }
+        const vaoOBJ = (key) => (0, attribute_loader_1.createBufferAndReadInfo)(this.bufferManagersCompMap.get(key).bufferManager.buffer);
+        this.lineVao = this.lineProgram.createVAO(...['centerCoords2d', 'centerCoords3d', 'targetCoords2d', 'targetCoords3d', 'dashOpacity', 'dashOpacity', 'rgba'].map(key => vaoOBJ(key)));
+        this.ringVao = this.pieceOfPieProgram.createVAO(...['centerCoords2d',
+            'centerCoords3d',
+            'startAngle2d',
+            'tailAngle2d',
+            'startAngle3d',
+            'tailAngle3d',
+            'rgba',
+            'radius',
+            'rgbaMode'].map(key => vaoOBJ(key)));
+        this.bearingLineVAO = this.lineProgram.createVAO(...['centerCoords2d', 'centerCoords3d', 'bearingTargetCoords2d', 'bearingTargetCoords3d', 'bearingDashRatio', 'dashOpacity', 'rgba'
+        ].map(key => vaoOBJ(key)));
+        this.circleVao = this.circleProgram.createVAO(...["centerCoords2dflat", "rgbaMercator", "circleDashAngleMercator", "dashOpacityMercator"
+        ].map(key => vaoOBJ(key)));
+        this.circle3DVao = this.circle3DProgram.createVAO(...["centerCoords3d", "targetCoords3d", "rgba", "circleDashAngle", "dashOpacity"
+        ].map(key => vaoOBJ(key)));
+    }
+    draw3D() {
+        const { gl } = this;
+        gl.disable(gl.DEPTH_TEST);
+        const is3D = this.globe.api_GetCurrentGeometry() === 0;
+        const drawRange = { first: 0, count: this.bufferOrchestrator.length };
+        this.lineProgram.draw(this.lineVao, { drawRange }, this._opacity);
+        if (this.drawAngleRing) {
+            this.pieceOfPieProgram.draw(this.bufferOrchestrator.length, this.ringVao, 360, this._opacity * 0.8, exports.RINGPARTIAL_DRAW_MODE.TRIANGLE_FAN);
+            this.pieceOfPieProgram.draw(this.bufferOrchestrator.length, this.ringVao, 360, this._opacity * 0.8, exports.RINGPARTIAL_DRAW_MODE.LINE_STRIP);
+        }
+        if (this.drawBearingLine) {
+            // this.lineProgram.draw(this.bearingLineVAO, this.bufferOrchestrator.length, this._opacity );
+            this.lineProgram.draw(this.bearingLineVAO, { drawRange }, this._opacity);
+        }
+        if (this.drawVRM) {
+            if (is3D) {
+                this.circle3DProgram.draw(this.circle3DVao, this.bufferOrchestrator.length, this._opacity);
+            }
+            else {
+                this.circleProgram.draw(this.circleVao, this.bufferOrchestrator.length, this.circleFlatEdgeCount, this._opacity);
+            }
+        }
+        if (this.drawText) {
+            this._textWritersMap.forEach((writer) => writer.draw());
+        }
+        gl.enable(gl.DEPTH_TEST);
+    }
+    free() {
+        if (this.isFreed)
+            return;
+        this.bufferManagersCompMap.forEach(({ bufferManager, adaptor }) => {
+            bufferManager.free();
+        });
+        const { gl, globe } = this;
+        gl.deleteVertexArray(this.lineVao);
+        gl.deleteVertexArray(this.ringVao);
+        gl.deleteVertexArray(this.bearingLineVAO);
+        gl.deleteVertexArray(this.circleVao);
+        gl.deleteVertexArray(this.circle3DVao);
+        naive_accurate_flexible_1.LineOnGlobeCache.release(globe);
+        piece_of_pie_1.PieceOfPieProgramCache.release(globe);
+        circle_accurate_flat_1.CircleCache.release(globe);
+        circle_accurate_3d_1.CircleCache.release(globe);
+        this.isFreed = true;
+    }
+    _deleteTexts(keys) {
+        this._textWritersMap.forEach((writer) => {
+            writer.deleteTextBulk(keys);
+        });
+    }
+}
+exports.default = BearingLinePlugin;

package/dist/circle-line-chain/chain-list-map.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainListMap = void 0;
+/**
+ * set and get node data
+ * node indexes;
+ */
+class ChainListMap {
+    constructor(keyMethod) {
+        this._chainMap = new Map();
+        this._chainSideProperties = new Map();
+        this._indexMap = new Map(); // hold list index of lastly updated nodes. on add delete goes empty
+        this.keyMethod = keyMethod;
+    }
+    getChain(chainKey) {
+        return this._chainMap.get(chainKey);
+    }
+    /**
+     *
+     * @param {*} node
+     * @param {*} chainKey
+     * @param {string|null} theNodeKeyFront
+     */
+    addNode(node, chainKey, theNodeKeyFront = null) {
+        const chain = this.getChain(chainKey);
+        let frontIndex = null;
+        for (let i = 0; i < chain.length; i++) {
+            const n_ode = chain[i];
+            if (n_ode.key === node.key) {
+                throw new Error("Chain node already exists");
+            }
+            if (n_ode.key === theNodeKeyFront) {
+                frontIndex = i;
+            }
+        }
+        if (theNodeKeyFront !== null) {
+            if (frontIndex !== null) {
+                chain.splice(frontIndex, 0, node);
+            }
+            else {
+                throw new Error("Could not find theNodeKeyFront");
+            }
+        }
+        else {
+            chain.push(node);
+        }
+        node.__identity__ = this.keyMethod(chainKey, node.key);
+        this._resetIndexChain(chainKey);
+    }
+    deleteNodesBelongToAChain(chainKey, nodeKeys) {
+        const chain = this._chainMap.get(chainKey);
+        const deleteKeys = [];
+        const removeSet = new Set(nodeKeys);
+        const newChain = [];
+        for (let i = 0; i < chain.length - 1; i++) {
+            const node = chain[i];
+            const dKey = node.__identity__;
+            this._indexMap.delete(dKey);
+            if (removeSet.has(node.key)) {
+                deleteKeys.push(dKey);
+            }
+            else {
+                newChain.push(node);
+            }
+        }
+        { // last item case
+            const lastItem = chain[chain.length - 1];
+            this._indexMap.delete(lastItem.__identity__);
+            if (removeSet.has(lastItem.key)) {
+                if (chain.length > 1) {
+                    deleteKeys.push(chain[chain.length - 2].__identity__);
+                    deleteKeys.push(chain[chain.length - 1].__identity__);
+                }
+                ;
+            }
+            else {
+                newChain.push(lastItem);
+            }
+        }
+        this._chainMap.set(chainKey, newChain);
+        return deleteKeys;
+    }
+    deleteChainAndReturnChainKeys(chainKey) {
+        const keys = this.getNodeKeysOfChain(chainKey);
+        this._chainMap.delete(chainKey);
+        for (const key of keys)
+            this._indexMap.delete(key);
+        return keys;
+    }
+    updateNode(node, chainKey) {
+        const index = this.getIndexOfNode(chainKey, node.key);
+        const chain = this._chainMap.get(chainKey);
+        node.__identity__ = this.keyMethod(chainKey, node.key);
+        chain[index] = node;
+    }
+    updateNodesProperties(chainKey, nodes) {
+        nodes.forEach((node) => {
+            const index = this.getIndexOfNode(chainKey, node.key);
+            const chainNode = this._chainMap.get(chainKey)[index];
+            if (node.circleProperties) {
+                if (typeof chainNode.circleProperties !== 'object')
+                    chainNode.circleProperties = {};
+                node.circleProperties.forEach((value, key, container) => chainNode.circleProperties[key] = value);
+            }
+            if (node.lineProperties) {
+                if (typeof chainNode.lineProperties !== 'object')
+                    chainNode.lineProperties = {};
+                node.lineProperties.forEach((value, key, container) => chainNode.lineProperties[key] = value);
+            }
+        });
+    }
+    updateCoordsinatesOfNode(node, chainKey) {
+        const index = this.getIndexOfNode(chainKey, node.key);
+        const chain = this._chainMap.get(chainKey);
+        chain[index].long = node.long;
+        chain[index].lat = node.lat;
+    }
+    setChain(chainKey, nodeList) {
+        if (this._chainMap.has(chainKey))
+            this._flushIndexMap();
+        this._chainMap.set(chainKey, nodeList);
+        nodeList.forEach((v) => v.__identity__ = this.keyMethod(chainKey, v.key));
+    }
+    setChainProperties(chainKey, properties) {
+        this._chainSideProperties.set(chainKey, properties);
+    }
+    /**
+     *
+     * @param {string} chainKey
+     * @param {Map} properties
+     * // after this method update text and buffer data of the chain
+     */
+    updateChainProperties(chainKey, properties) {
+        const memoryProperties = this._chainSideProperties.get(chainKey);
+        properties.forEach((value, key, m) => {
+            memoryProperties[key] = value;
+        });
+    }
+    getChainProperties(chainKey) {
+        this._chainSideProperties.get(chainKey);
+    }
+    /**
+     *
+     * @param {*} chainKey
+     * @param {*} callback | (value, index, array) => expexted output
+     */
+    calculateBufferPropertiesChain(chainKey, callback, result) {
+        const chain = this._chainMap.get(chainKey);
+        const props = this._chainSideProperties.get(chainKey);
+        for (let i = 0; i < chain.length - 1; i++) {
+            const node = callback(chain[i], i, chain, props);
+            if (node !== null)
+                result.push(node);
+        }
+    }
+    /**
+     * @param {*} chainKey
+     * @param {*} textWriterObjs
+     * @param {*} nodeKeys use nodeKeys on updateCoordinatesOnly
+     */
+    textUpdate(chainKey, textWriterObjs, dataPreAdaptor) {
+        const chain = this._chainMap.get(chainKey);
+        if (!chain)
+            return;
+        const data = (dataPreAdaptor) ? chain.map(dataPreAdaptor) : chain;
+        const properties = this._chainSideProperties.get(chainKey);
+        textWriterObjs.forEach((writer) => {
+            writer.insertTextBulk(data, properties);
+        });
+    }
+    getAllChainKeysIterator() {
+        return this._chainMap.keys();
+    }
+    getIndexOfNode(chainKey, nodeKey) {
+        const key = this.keyMethod(chainKey, nodeKey);
+        if (this._indexMap.has(key))
+            return this._indexMap.get(key);
+        const chain = this._chainMap.get(chainKey);
+        for (let i = 0; i < chain.length; i++) {
+            const node = chain[i];
+            this._indexMap.set(key, i);
+            if (node.key === nodeKey) {
+                return i;
+            }
+        }
+    }
+    _flushIndexMap() {
+        this._indexMap.clear();
+    }
+    _resetIndexChain(chainKey) {
+        const chain = this._chainMap.get(chainKey);
+        for (let i = 0; i < chain.length; i++) {
+            const node = chain[i];
+            this._indexMap.set(this.keyMethod(chainKey, node.key), i);
+        }
+    }
+    getNodeKeysOfChain(chainKey) {
+        const chain = this._chainMap.get(chainKey);
+        if (!chain)
+            return [];
+        const result = chain.map((v) => v.__identity__);
+        return result;
+    }
+}
+exports.ChainListMap = ChainListMap;

package/dist/circle-line-chain/init.js

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