@pirireis/webglobeplugins 0.17.0 → 1.0.2

package/range-tools-on-terrain/circle-line-chain/{plugin.js → plugin.ts}

@@ -1,464 +1,607 @@
-import { CircleOnTerrainPlugin } from "../../semiplugins/shape-on-terrain/circle-plugin";
-import { LinePlugin } from "../../semiplugins/lightweight/line-plugin";
-import { ArcOnTerrainPlugin } from "../../semiplugins/shape-on-terrain/arc-plugin";
-import { keyMethod, lineDataAdaptor, arcDataAdaptor, circleDataAdaptor, getOpacity } from "./adapters";
-import { ContextTextWriter3 } from "../../write-text/context-text3";
-import { ChainListMap } from "./chain-list-map";
-import { mapGetOrThrow } from "../../util/check/typecheck";
-const textWriterGetOrThrow = mapGetOrThrow("textWriterIDs is invalid");
-export class CircleLineChainPlugin {
-    id;
-    globe = null;
-    gl = null;
-    circlePlugin = null;
-    linePlugin = null;
-    arcPlugin = null;
-    _freed = false;
-    _opacities;
-    _drawCircleOn = true;
-    _textWritersMap;
-    _textDataPreAdaptor = undefined;
-    _chainListMap;
-    _semiPluginOptions = {
-        circleOnTerrainOptions: {
-            variativeColorsOn: false,
-            defaultColor: [1, 1, 1, 1],
-            defaultHeightFromGroundIn3D: 30,
-            isMSL: false
-        },
-        arcOnTerrainOptions: {
-            flatViewOn: true,
-            globeViewOn: true,
-            variativeColorsOn: false,
-            defaultColor: [1, 1, 1, 1],
-            defaultHeightFromGroundIn3D: 0,
-            vertexCount: 32,
-            cameraAttractionIsOn: true, // If true, camera attraction is enabled else evenly distributed arc points are used
-            isMSL: false, // If true, no elevation of terrain
-        },
-        lineOptions: {
-            flatViewOn: true,
-            globeViewOn: true,
-            variativeColorsOn: false,
-            defaultColor: [1, 1, 1, 1],
-            dashedLineOpacityVariativeOn: false,
-            dashedLineRatioVariativeOn: false,
-            bufferType: "DYNAMIC_DRAW",
-            opacity: 1.0,
-        }
-    };
-    constructor(id, { drawCircleOn, textWritersMap, textDataPreAdaptor, opacities, arcOnTerrainOptions, circleOnTerrainOptions, lineOptions } = {}) {
-        const defaults = {
-            drawCircleOn: true,
-            textWritersMap: new Map(),
-            textDataPreAdaptor: undefined,
-            opacities: {
-                general: 1,
-                circle: null,
-                flatStraightLine: null,
-                flatGreatCircle: null,
-                globeArcFitsTerrain: null,
-                globeArcNotFitsTerrain: null
-            }
-        };
-        const finalOpacities = { ...defaults.opacities, ...opacities };
-        const config = {
-            ...defaults,
-            drawCircleOn: drawCircleOn ?? defaults.drawCircleOn,
-            textWritersMap: textWritersMap ?? defaults.textWritersMap,
-            textDataPreAdaptor: textDataPreAdaptor ?? defaults.textDataPreAdaptor,
-            opacities: finalOpacities
-        };
-        this._semiPluginOptions.circleOnTerrainOptions = {
-            ...this._semiPluginOptions.circleOnTerrainOptions,
-            ...circleOnTerrainOptions
-        };
-        this._semiPluginOptions.arcOnTerrainOptions = {
-            ...this._semiPluginOptions.arcOnTerrainOptions,
-            ...arcOnTerrainOptions
-        };
-        this._semiPluginOptions.lineOptions = {
-            ...this._semiPluginOptions.lineOptions,
-            ...lineOptions
-        };
-        this.id = id;
-        this._drawCircleOn = config.drawCircleOn;
-        this._textWritersMap = config.textWritersMap;
-        this._textDataPreAdaptor = config.textDataPreAdaptor;
-        this._chainListMap = new ChainListMap(keyMethod);
-        this._opacities = config.opacities;
-        this._checktextWritersMap(this._textWritersMap);
-        this._textWritersMap.forEach((writer) => {
-            writer.setKeyAdaptor((v) => v.__identity__);
-        });
-    }
-    // API
-    insertBulk(chains, { textWriterIDs = [] } = {}) {
-        if (this._freed) {
-            console.warn("CircleLineChainPlugin is freed, cannot insert bulk.");
-            return;
-        }
-        if (chains.length === 0)
-            return;
-        const chainKeys = [];
-        const chainsToClean = [];
-        for (const { chainKey } of chains) {
-            if (this._chainListMap.hasChain(chainKey)) {
-                chainsToClean.push(chainKey);
-            }
-        }
-        this._cleanChainsFromSemiPlugins(chainsToClean);
-        for (const { chainKey, chainProperties, nodes } of chains) {
-            if (!chainKey || !chainProperties || !nodes || nodes.length === 0) {
-                console.warn("Invalid chain data, skipping insertion.");
-                continue;
-            }
-            this._chainListMap.setChain(chainKey, nodes);
-            this._chainListMap.setChainProperties(chainKey, chainProperties);
-            chainKeys.push(chainKey);
-        }
-        // Reconstruct chains
-        this._reconstructChains(chainKeys);
-        // Update texts
-        this._updateTexts(chainKeys, textWriterIDs);
-        this.globe?.DrawRender();
-    }
-    addNode(node, chainKey, { theNodeKeyFront, textWriterIDs = [] } = {}) {
-        if (this._freed) {
-            console.warn("CircleLineChainPlugin is freed, cannot add node.");
-            return;
-        }
-        this._cleanChainsFromSemiPlugins([chainKey]);
-        this._chainListMap.addNode(node, chainKey, theNodeKeyFront);
-        this._reconstructChains([chainKey]);
-        this._updateTexts([chainKey], textWriterIDs);
-        this.globe?.DrawRender();
-    }
-    getChain(chainKey) {
-        return this._chainListMap.getNodes(chainKey);
-    }
-    setDrawCircleOn(value) {
-        if (this._freed) {
-            console.warn("CircleLineChainPlugin is freed, cannot set drawCircleOn.");
-            return;
-        }
-        this._drawCircleOn = value;
-        this.globe?.DrawRender();
-    }
-    setOpacities(opacities) {
-        if (this._freed) {
-            console.warn("CircleLineChainPlugin is freed, cannot set opacities.");
-            return;
-        }
-        this._opacities = {
-            ...this._opacities,
-            ...opacities
-        };
-        this.globe?.DrawRender();
-    }
-    setElevationMode(mode) {
-        if (this._freed) {
-            console.warn("CircleLineChainPlugin is freed, cannot set elevation mode.");
-            return;
-        }
-        this.arcPlugin?.setElevationMode(mode);
-        this.circlePlugin?.setElevationMode(mode);
-        this.globe?.DrawRender();
-    }
-    deleteChains(chainKeys) {
-        if (this._freed) {
-            console.warn("CircleLineChainPlugin is freed, cannot delete chains.");
-            return;
-        }
-        // type check chainKeys
-        if (!Array.isArray(chainKeys) || chainKeys.some(key => typeof key !== "string")) {
-            console.warn("Invalid chainKeys array.");
-            return;
-        }
-        for (const chainKey of chainKeys) {
-            const keys = this._chainListMap.deleteChainAndReturnChainKeys(chainKey, this._textWritersMap);
-            if (keys.length <= 1) {
-                console.warn(`Deleted chain ${chainKey}, was too small to be displayed.`);
-                continue;
-            }
-            keys.pop(); // Remove the last key which which is destination of the last circle
-            this.linePlugin?.deleteBulk(keys);
-            this.arcPlugin?.deleteBulk(keys);
-            this.circlePlugin?.deleteBulk(keys);
-            this._updateTexts(chainKeys, Array.from(this._textWritersMap.keys()));
-        }
-        this.globe?.DrawRender();
-    }
-    deleteNodes(keysAndNodes) {
-        if (this._freed) {
-            console.warn("CircleLineChainPlugin is freed, cannot delete nodes.");
-            return;
-        }
-        const chainKeysToReconstruct = keysAndNodes.map(({ chainKey }) => chainKey);
-        // this._chainListMap.deleteTexts(chainKeysToReconstruct, this._textWritersMap); // TODO: delete this method from chain-list-map
-        this._cleanChainsFromSemiPlugins(chainKeysToReconstruct);
-        keysAndNodes.forEach(({ chainKey, nodeKeys }) => {
-            this._chainListMap.deleteNodesBelongToAChain(chainKey, nodeKeys);
-        });
-        this._reconstructChains(chainKeysToReconstruct);
-        this._updateTexts(chainKeysToReconstruct, Array.from(this._textWritersMap.keys()));
-        this.globe?.DrawRender();
-    }
-    updateNodesProperties(chainKey, nodesAndPropertyList, { textWriterIDs = [] } = {}) {
-        if (this._freed) {
-            console.warn("CircleLineChainPlugin is freed, cannot update nodes properties.");
-            return;
-        }
-        const hasChain = this._chainListMap.hasChain(chainKey);
-        if (!hasChain) {
-            console.warn(`Chain with key ${chainKey} not found.`);
-            return;
-        }
-        this._chainListMap.updateNodesProperties(chainKey, nodesAndPropertyList);
-        this._cleanChainsFromSemiPlugins([chainKey]);
-        this._reconstructChains([chainKey]);
-        this._updateTexts([chainKey], textWriterIDs);
-        this.globe?.DrawRender();
-    }
-    updateChainDrawOptionsProperties(chainKey, drawOptions) {
-        if (this._freed) {
-            console.warn("CircleLineChainPlugin is freed, cannot update chain draw options properties.");
-            return;
-        }
-        const chain = this._chainListMap.getChain(chainKey);
-        if (!chain) {
-            console.warn(`Chain with key ${chainKey} not found.`);
-            return;
-        }
-        const { nodes } = chain;
-        nodes.forEach((node) => {
-            if (drawOptions.circleOn !== undefined) {
-                node.circleOn = drawOptions.circleOn;
-            }
-            if (drawOptions.arcOn !== undefined) {
-                node.arcOn = drawOptions.arcOn;
-            }
-            if (drawOptions.line !== undefined) {
-                node.lineOn = drawOptions.line;
-            }
-        });
-        this._cleanChainsFromSemiPlugins([chainKey]);
-        this._reconstructChains([chainKey]);
-        this._updateTexts([chainKey], Array.from(this._textWritersMap.keys()));
-        this.globe?.DrawRender();
-    }
-    updateCoordinatesBulk(chains, { textWriterIDs = [] } = {}) {
-        if (this._freed) {
-            console.warn("CircleLineChainPlugin is freed, cannot update coordinates.");
-            return;
-        }
-        const chainKeys = [];
-        for (const chain of chains) {
-            const { chainKey, nodes } = chain;
-            chainKeys.push(chainKey);
-            nodes.forEach((node, index) => {
-                this._chainListMap.updateCoordsinatesOfNode(node, chainKey);
-            });
-        }
-        this._updateTexts(chainKeys, textWriterIDs);
-        this._reconstructChains(chainKeys);
-    }
-    updateNodeCoordinates(node, chainKey, { textWriterIDs = [] } = {}) {
-        if (this._freed) {
-            console.warn("CircleLineChainPlugin is freed, cannot update node coordinates.");
-            return;
-        }
-        this._chainListMap.updateCoordsinatesOfNode(node, chainKey);
-        if (textWriterIDs && textWriterIDs.length > 0) {
-            this._updateTexts([chainKey], textWriterIDs);
-        }
-        this._reconstructChains([chainKey]);
-        this.globe?.DrawRender();
-    }
-    updateChainProperties(chainKey, properties) {
-        if (this._freed) {
-            console.warn("CircleLineChainPlugin is freed, cannot update chain properties.");
-            return;
-        }
-        this._chainListMap.updateChainProperties(chainKey, properties);
-        this._cleanChainsFromSemiPlugins([chainKey]);
-        this._reconstructChains([chainKey]);
-        this._updateTexts([chainKey], Array.from(this._textWritersMap.keys()));
-        this.globe?.DrawRender();
-    }
-    updateText(textWriterIDs, chainKeys = null) {
-        if (this._freed) {
-            console.warn("CircleLineChainPlugin is freed, cannot update text.");
-            return;
-        }
-        if (!chainKeys) {
-            chainKeys = Array.from(this._chainListMap.getAllChainKeysIterator());
-        }
-        this._updateTexts(chainKeys, textWriterIDs);
-        this.globe?.DrawRender();
-    }
-    setDefaultSemiPluginColor(semiPluginName, color) {
-        if (semiPluginName === "ALL") {
-            this._semiPluginOptions.circleOnTerrainOptions.defaultColor = color;
-            this._semiPluginOptions.arcOnTerrainOptions.defaultColor = color;
-            this._semiPluginOptions.lineOptions.defaultColor = color;
-            this.circlePlugin?.setDefaultColor(color);
-            this.arcPlugin?.setDefaultColor(color);
-            this.linePlugin?.setDefaultColor(color);
-            return;
-        }
-        switch (semiPluginName) {
-            case "circleOnTerrain":
-                this._semiPluginOptions.circleOnTerrainOptions.defaultColor = color;
-                this.circlePlugin?.setDefaultColor(color);
-                break;
-            case "arcOnTerrain":
-                this._semiPluginOptions.arcOnTerrainOptions.defaultColor = color;
-                this.arcPlugin?.setDefaultColor(color);
-                break;
-            case "line":
-                this._semiPluginOptions.lineOptions.defaultColor = color;
-                this.linePlugin?.setDefaultColor(color);
-                break;
-            default:
-                throw new Error(`Unknown semi-plugin name: ${semiPluginName}`);
-        }
-    }
-    // IMPLICIT METHODS
-    _checktextWritersMap(textWritersMap) {
-        if (!(textWritersMap instanceof Map))
-            throw new Error("textWritersMap is not an instance of Map");
-        textWritersMap.forEach((v) => {
-            if (!(v instanceof ContextTextWriter3))
-                throw new Error("textWritersMap element is not an instance of ContextTextWriter3");
-        });
-    }
-    _updateTexts(chainKeys, textWriterIDs) {
-        if (textWriterIDs.length === 0)
-            return;
-        const textWriters = textWriterGetOrThrow(this._textWritersMap, textWriterIDs);
-        chainKeys.forEach((chainKey) => {
-            this._chainListMap.textUpdate(chainKey, textWriters, this._textDataPreAdaptor);
-        });
-    }
-    _cleanChainsFromSemiPlugins(chainKeys) {
-        if (!this.globe || !this.gl) {
-            throw new Error("Globe or WebGL context is not initialized");
-        }
-        for (const chainKey of chainKeys) {
-            // Clean chains from text writers
-            const nodeKeys = this._chainListMap.getNodeKeysOfChain(chainKey);
-            this._textWritersMap.forEach((writer) => {
-                writer.deleteTextBulk(nodeKeys);
-            });
-            nodeKeys.pop(); // Remove the last key which is destination of the last circle
-            // Clean chains from semi-plugins
-            this.circlePlugin?.deleteBulk(nodeKeys);
-            this.linePlugin?.deleteBulk(nodeKeys);
-            this.arcPlugin?.deleteBulk(nodeKeys);
-        }
-    }
-    _reconstructChains(chainKeys) {
-        // TODO: this is core
-        // Get chain nodes
-        const globe = this.globe;
-        if (!globe || !this.gl) {
-            throw new Error("Globe or WebGL context is not initialized");
-        }
-        for (let chainKey of chainKeys) {
-            const chain = this._chainListMap.getChain(chainKey);
-            if (!chain) {
-                console.warn(`Chain with key ${chainKey} not found.`);
-                continue;
-            }
-            const lineInput = lineDataAdaptor(chain);
-            const arcInput = arcDataAdaptor(chain);
-            const circleInput = circleDataAdaptor(globe, chain);
-            this.linePlugin?.insertBulk(lineInput);
-            this.arcPlugin?.insertBulk(arcInput);
-            this.circlePlugin?.insertBulk(circleInput);
-        }
-    }
-    // GLOBE INTERFACE METHODS
-    init(globe, gl) {
-        this.globe = globe;
-        this.gl = gl;
-        // Initialize sub-plugins with unique IDs
-        this.circlePlugin = new CircleOnTerrainPlugin(`${this.id}_unregistered_circles`, this._semiPluginOptions.circleOnTerrainOptions);
-        this.linePlugin = new LinePlugin(`${this.id}_unregistered_lines`, this._semiPluginOptions.lineOptions);
-        this.arcPlugin = new ArcOnTerrainPlugin(`${this.id}_unregistered_arcs`, this._semiPluginOptions.arcOnTerrainOptions);
-        this.circlePlugin.init(globe, gl);
-        this.linePlugin.init(globe, gl);
-        this.arcPlugin.init(globe, gl);
-    }
-    draw3D() {
-        if (this._freed) {
-            console.warn("CircleLineChainPlugin is freed, cannot draw.");
-            return;
-        }
-        const { globe, gl } = this;
-        if (!globe || !gl) {
-            console.warn("Globe or WebGL context is not initialized, cannot draw.");
-            return;
-        }
-        const circleOpacity = getOpacity(this._opacities, "circle");
-        if (this._drawCircleOn && circleOpacity !== 0) {
-            this.circlePlugin?.setPluginOpacity(circleOpacity, false);
-            this.circlePlugin?.draw3D();
-        }
-        const currentGeometry = globe.api_GetCurrentGeometry();
-        switch (currentGeometry) {
-            case 0: {
-                // globe view
-                const lineOpacity = getOpacity(this._opacities, "globeArc");
-                if (lineOpacity !== 0) {
-                    this.linePlugin?.setPluginOpacity(lineOpacity, false);
-                    this.linePlugin?.draw3D();
-                }
-                const arcOpacity = getOpacity(this._opacities, "globeArcFitsTerrain");
-                if (arcOpacity !== 0) {
-                    this.arcPlugin?.setPluginOpacity(arcOpacity, false);
-                    this.arcPlugin?.draw3D();
-                }
-                break;
-            }
-            case 1: {
-                // flat view
-                const lineOpacity = getOpacity(this._opacities, "flatStraightLine");
-                if (lineOpacity !== 0) {
-                    this.linePlugin?.setPluginOpacity(lineOpacity);
-                    this.linePlugin?.draw3D();
-                }
-                const arcOpacity = getOpacity(this._opacities, "flatGreatCircleLine");
-                if (arcOpacity !== 0) {
-                    this.arcPlugin?.setPluginOpacity(arcOpacity);
-                    this.arcPlugin?.draw3D();
-                }
-                break;
-            }
-            default: {
-                throw new Error("Unknown geometry type, Implementation need on Circle-Line-Chain Plugin");
-            }
-        }
-        this._textWritersMap.forEach((writer) => {
-            writer.draw();
-        });
-    }
-    free() {
-        if (this._freed)
-            return;
-        this._freed = true;
-        // Free sub-plugins
-        this.circlePlugin?.free();
-        this.linePlugin?.free();
-        this.arcPlugin?.free();
-        // Clear text writers map
-        this._textWritersMap.clear();
-        // Clear references
-        this.globe = null;
-        this.gl = null;
-        this.circlePlugin = null;
-        this.linePlugin = null;
-        this.arcPlugin = null;
-    }
-}
+import { Chain, Node, Opacities } from "./types";
+
+import { CircleOnTerrainPlugin, CircleOnTerrainPluginOptions } from "../../semiplugins/shape-on-terrain/circle-plugin";
+import { LinePlugin, LinePluginOptions } from "../../semiplugins/lightweight/line-plugin";
+import { ArcOnTerrainPlugin, ArcOnTerrainPluginOptions } from "../../semiplugins/shape-on-terrain/arc-plugin";
+
+
+import { keyMethod, lineDataAdaptor, arcDataAdaptor, circleDataAdaptor, getOpacity } from "./adapters";
+
+import { Globe, PluginInterface, Color } from "../../types";
+import { ContextTextWriter3 } from "../../write-text/context-text3";
+import { ChainListMap } from "./chain-list-map";
+import { mapGetOrThrow } from "../../util/check/typecheck";
+
+
+const textWriterGetOrThrow = mapGetOrThrow("textWriterIDs is invalid");
+
+export type DrawSemiPluginDraw = {
+    circleOn: boolean;
+    arcOn: boolean;
+    line: boolean;
+};
+
+
+export class CircleLineChainPlugin implements PluginInterface {
+    id: string;
+    globe: Globe | null = null;
+    gl: WebGL2RenderingContext | null = null;
+    circlePlugin: CircleOnTerrainPlugin | null = null;
+    linePlugin: LinePlugin | null = null;
+    arcPlugin: ArcOnTerrainPlugin | null = null;
+
+    private _freed: boolean = false;
+    private _opacities: Opacities;
+    private _drawCircleOn: boolean = true;
+    private _textWritersMap: Map<string, ContextTextWriter3>;
+    private _textDataPreAdaptor: ((item: Node, index: number, nodes: Node[]) => any) | undefined = undefined;
+    private _chainListMap: ChainListMap;
+    private _semiPluginOptions: {
+        circleOnTerrainOptions: Partial<CircleOnTerrainPluginOptions>;
+        arcOnTerrainOptions: Partial<ArcOnTerrainPluginOptions>;
+        lineOptions: Partial<LinePluginOptions>;
+    } = {
+            circleOnTerrainOptions: {
+                variativeColorsOn: false,
+                defaultColor: [1, 1, 1, 1],
+                defaultHeightFromGroundIn3D: 30,
+                isMSL: false
+            },
+            arcOnTerrainOptions: {
+                flatViewOn: true,
+                globeViewOn: true,
+                variativeColorsOn: false,
+                defaultColor: [1, 1, 1, 1],
+                defaultHeightFromGroundIn3D: 0,
+                vertexCount: 32,
+                cameraAttractionIsOn: true, // If true, camera attraction is enabled else evenly distributed arc points are used
+                isMSL: false, // If true, no elevation of terrain
+
+            },
+            lineOptions: {
+                flatViewOn: true,
+                globeViewOn: true,
+                variativeColorsOn: false,
+                defaultColor: [1, 1, 1, 1],
+                dashedLineOpacityVariativeOn: false,
+                dashedLineRatioVariativeOn: false,
+                bufferType: "DYNAMIC_DRAW",
+                opacity: 1.0,
+
+            }
+        }
+
+    constructor(id: string, {
+        drawCircleOn,
+        textWritersMap,
+        textDataPreAdaptor,
+        opacities,
+        arcOnTerrainOptions,
+        circleOnTerrainOptions,
+        lineOptions
+    }: {
+        drawCircleOn?: boolean;
+        textWritersMap?: Map<string, ContextTextWriter3>;
+        textDataPreAdaptor?: (item: Node, index: number, nodes: Node[]) => any | null;
+        opacities?: Opacities;
+        arcOnTerrainOptions?: Partial<ArcOnTerrainPluginOptions>;
+        circleOnTerrainOptions?: Partial<CircleOnTerrainPluginOptions>;
+        lineOptions?: Partial<LinePluginOptions>;
+    } = {}) {
+        const defaults = {
+            drawCircleOn: true,
+            textWritersMap: new Map<string, ContextTextWriter3>(),
+            textDataPreAdaptor: undefined,
+            opacities: {
+                general: 1,
+                circle: null,
+                flatStraightLine: null,
+                flatGreatCircle: null,
+                globeArcFitsTerrain: null,
+                globeArcNotFitsTerrain: null
+            }
+        };
+
+        const finalOpacities = { ...defaults.opacities, ...opacities };
+        const config = {
+            ...defaults,
+            drawCircleOn: drawCircleOn ?? defaults.drawCircleOn,
+            textWritersMap: textWritersMap ?? defaults.textWritersMap,
+            textDataPreAdaptor: textDataPreAdaptor ?? defaults.textDataPreAdaptor,
+            opacities: finalOpacities
+        };
+
+        this._semiPluginOptions.circleOnTerrainOptions = {
+            ...this._semiPluginOptions.circleOnTerrainOptions,
+            ...circleOnTerrainOptions
+        };
+        this._semiPluginOptions.arcOnTerrainOptions = {
+            ...this._semiPluginOptions.arcOnTerrainOptions,
+            ...arcOnTerrainOptions
+        };
+        this._semiPluginOptions.lineOptions = {
+            ...this._semiPluginOptions.lineOptions,
+            ...lineOptions
+        };
+
+        this.id = id;
+        this._drawCircleOn = config.drawCircleOn;
+        this._textWritersMap = config.textWritersMap;
+        this._textDataPreAdaptor = config.textDataPreAdaptor;
+        this._chainListMap = new ChainListMap(keyMethod);
+        this._opacities = config.opacities;
+
+        this._checktextWritersMap(this._textWritersMap);
+        this._textWritersMap.forEach((writer) => {
+            writer.setKeyAdaptor((v: any) => v.__identity__);
+        });
+    }
+
+
+    // API
+
+    insertBulk(chains: Chain[], { textWriterIDs = [] }: { textWriterIDs?: string[] } = {}): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot insert bulk.");
+            return;
+        }
+        if (chains.length === 0) return;
+
+        const chainKeys = [];
+        const chainsToClean = []
+        for (const { chainKey } of chains) {
+            if (this._chainListMap.hasChain(chainKey)) {
+                chainsToClean.push(chainKey);
+            }
+
+        }
+        this._cleanChainsFromSemiPlugins(chainsToClean);
+
+        for (const { chainKey, chainProperties, nodes } of chains) {
+            if (!chainKey || !chainProperties || !nodes || nodes.length === 0) {
+                console.warn("Invalid chain data, skipping insertion.");
+                continue;
+            }
+            this._chainListMap.setChain(chainKey, nodes);
+            this._chainListMap.setChainProperties(chainKey, chainProperties);
+            chainKeys.push(chainKey);
+        }
+
+        // Reconstruct chains
+        this._reconstructChains(chainKeys);
+
+        // Update texts
+        this._updateTexts(chainKeys, textWriterIDs);
+        this.globe?.DrawRender();
+    }
+
+
+    addNode(node: Node, chainKey: string, { theNodeKeyFront, textWriterIDs = [] }: { theNodeKeyFront?: undefined | string, textWriterIDs?: string[] } = {}): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot add node.");
+            return;
+        }
+        this._cleanChainsFromSemiPlugins([chainKey]);
+        this._chainListMap.addNode(node, chainKey, theNodeKeyFront)
+        this._reconstructChains([chainKey]);
+        this._updateTexts([chainKey], textWriterIDs);
+        this.globe?.DrawRender();
+    }
+
+
+    getChain(chainKey: string): Node[] | undefined {
+        return this._chainListMap.getNodes(chainKey);
+    }
+
+
+    setDrawCircleOn(value: boolean): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot set drawCircleOn.");
+            return;
+        }
+        this._drawCircleOn = value;
+        this.globe?.DrawRender();
+    }
+
+
+
+    setOpacities(opacities: Partial<Opacities>): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot set opacities.");
+            return;
+        }
+        this._opacities = {
+            ...this._opacities,
+            ...opacities
+        };
+        this.globe?.DrawRender();
+    }
+
+
+    setElevationMode(mode: "msl" | "agl"): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot set elevation mode.");
+            return;
+        }
+        this.arcPlugin?.setElevationMode(mode);
+        this.circlePlugin?.setElevationMode(mode);
+
+        this.globe?.DrawRender();
+    }
+
+
+
+    deleteChains(chainKeys: string[]): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot delete chains.");
+            return;
+        }
+        // type check chainKeys
+        if (!Array.isArray(chainKeys) || chainKeys.some(key => typeof key !== "string")) {
+            console.warn("Invalid chainKeys array.");
+            return;
+        }
+
+        for (const chainKey of chainKeys) {
+            const keys = this._chainListMap.deleteChainAndReturnChainKeys(chainKey, this._textWritersMap);
+            if (keys.length <= 1) {
+                console.warn(`Deleted chain ${chainKey}, was too small to be displayed.`);
+                continue;
+            }
+            keys.pop(); // Remove the last key which which is destination of the last circle
+            this.linePlugin?.deleteBulk(keys);
+            this.arcPlugin?.deleteBulk(keys);
+            this.circlePlugin?.deleteBulk(keys);
+
+            this._updateTexts(chainKeys, Array.from(this._textWritersMap.keys()));
+        }
+        this.globe?.DrawRender();
+    }
+
+
+    deleteNodes(keysAndNodes: Array<{
+        chainKey: string;
+        nodeKeys: string[];
+    }>): void {
+
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot delete nodes.");
+            return;
+        }
+        const chainKeysToReconstruct: string[] = keysAndNodes.map(({ chainKey }) => chainKey);
+        // this._chainListMap.deleteTexts(chainKeysToReconstruct, this._textWritersMap); // TODO: delete this method from chain-list-map
+        this._cleanChainsFromSemiPlugins(chainKeysToReconstruct);
+        keysAndNodes.forEach(({ chainKey, nodeKeys }) => {
+            this._chainListMap.deleteNodesBelongToAChain(chainKey, nodeKeys);
+        });
+        this._reconstructChains(chainKeysToReconstruct);
+        this._updateTexts(chainKeysToReconstruct, Array.from(this._textWritersMap.keys()));
+
+        this.globe?.DrawRender();
+    }
+
+
+    updateNodesProperties(chainKey: string,
+        nodesAndPropertyList: Pick<Node, "key" | "circleProperties" | "lineProperties" | "circleOn" | "arcOn" | "lineOn">[],
+        { textWriterIDs = [] }: { textWriterIDs?: string[] } = {}): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot update nodes properties.");
+            return;
+        }
+        const hasChain = this._chainListMap.hasChain(chainKey);
+        if (!hasChain) {
+            console.warn(`Chain with key ${chainKey} not found.`);
+            return;
+        }
+        this._chainListMap.updateNodesProperties(chainKey, nodesAndPropertyList);
+        this._cleanChainsFromSemiPlugins([chainKey]);
+        this._reconstructChains([chainKey]);
+        this._updateTexts([chainKey], textWriterIDs);
+        this.globe?.DrawRender();
+    }
+
+
+    updateChainDrawOptionsProperties(chainKey: string,
+        drawOptions: Partial<DrawSemiPluginDraw>,
+    ): void {
+
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot update chain draw options properties.");
+            return;
+        }
+
+        const chain = this._chainListMap.getChain(chainKey);
+        if (!chain) {
+            console.warn(`Chain with key ${chainKey} not found.`);
+            return;
+        }
+        const { nodes } = chain;
+        nodes.forEach((node) => {
+            if (drawOptions.circleOn !== undefined) {
+                node.circleOn = drawOptions.circleOn;
+            }
+            if (drawOptions.arcOn !== undefined) {
+                node.arcOn = drawOptions.arcOn;
+            }
+            if (drawOptions.line !== undefined) {
+                node.lineOn = drawOptions.line;
+            }
+        });
+
+        this._cleanChainsFromSemiPlugins([chainKey]);
+        this._reconstructChains([chainKey]);
+        this._updateTexts([chainKey], Array.from(this._textWritersMap.keys()));
+        this.globe?.DrawRender();
+    }
+
+
+
+    updateCoordinatesBulk(chains: Pick<Chain, "chainKey" | "nodes">[], { textWriterIDs = [] }: { textWriterIDs?: string[] } = {}): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot update coordinates.");
+            return;
+        }
+
+        const chainKeys = [];
+
+        for (const chain of chains) {
+            const { chainKey, nodes } = chain;
+            chainKeys.push(chainKey);
+            nodes.forEach((node, index) => {
+                this._chainListMap.updateCoordsinatesOfNode(node, chainKey);
+
+            });
+        }
+        this._updateTexts(chainKeys, textWriterIDs);
+        this._reconstructChains(chainKeys);
+    }
+
+
+    updateNodeCoordinates(
+        node: Pick<Node, "key" | "lat" | "long">,
+        chainKey: string,
+        { textWriterIDs = [] }: { textWriterIDs?: string[] } = {}
+    ) {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot update node coordinates.");
+            return;
+        }
+
+        this._chainListMap.updateCoordsinatesOfNode(node, chainKey);
+        if (textWriterIDs && textWriterIDs.length > 0) {
+            this._updateTexts([chainKey], textWriterIDs);
+        }
+        this._reconstructChains([chainKey]);
+        this.globe?.DrawRender();
+    }
+
+
+    updateChainProperties(chainKey: string, properties: Map<string, any>): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot update chain properties.");
+            return;
+        }
+        this._chainListMap.updateChainProperties(chainKey, properties);
+
+        this._cleanChainsFromSemiPlugins([chainKey]);
+        this._reconstructChains([chainKey]);
+        this._updateTexts([chainKey], Array.from(this._textWritersMap.keys()));
+        this.globe?.DrawRender();
+    }
+
+    updateText(textWriterIDs: string[], chainKeys: string[] | null = null): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot update text.");
+            return;
+        }
+        if (!chainKeys) {
+            chainKeys = Array.from(this._chainListMap.getAllChainKeysIterator());
+        }
+        this._updateTexts(chainKeys, textWriterIDs);
+        this.globe?.DrawRender();
+    }
+
+
+    setDefaultSemiPluginColor(
+        semiPluginName: "circleOnTerrain" | "arcOnTerrain" | "line" | "ALL",
+        color: Color
+    ) {
+
+        if (semiPluginName === "ALL") {
+            this._semiPluginOptions.circleOnTerrainOptions.defaultColor = color;
+            this._semiPluginOptions.arcOnTerrainOptions.defaultColor = color;
+            this._semiPluginOptions.lineOptions.defaultColor = color;
+            this.circlePlugin?.setDefaultColor(color);
+            this.arcPlugin?.setDefaultColor(color);
+            this.linePlugin?.setDefaultColor(color);
+            return;
+        }
+        switch (semiPluginName) {
+            case "circleOnTerrain":
+                this._semiPluginOptions.circleOnTerrainOptions.defaultColor = color;
+                this.circlePlugin?.setDefaultColor(color);
+                break;
+            case "arcOnTerrain":
+                this._semiPluginOptions.arcOnTerrainOptions.defaultColor = color;
+                this.arcPlugin?.setDefaultColor(color);
+                break;
+            case "line":
+                this._semiPluginOptions.lineOptions.defaultColor = color;
+                this.linePlugin?.setDefaultColor(color);
+                break;
+            default:
+                throw new Error(`Unknown semi-plugin name: ${semiPluginName}`);
+        }
+    }
+    // IMPLICIT METHODS
+
+
+    _checktextWritersMap(textWritersMap: Map<string, ContextTextWriter3>): void {
+        if (!(textWritersMap instanceof Map)) throw new Error("textWritersMap is not an instance of Map");
+        textWritersMap.forEach((v) => {
+            if (!(v instanceof ContextTextWriter3)) throw new Error("textWritersMap element is not an instance of ContextTextWriter3");
+        });
+    }
+
+
+    _updateTexts(chainKeys: string[], textWriterIDs: string[]): void {
+        if (textWriterIDs.length === 0) return;
+        const textWriters = textWriterGetOrThrow(this._textWritersMap, textWriterIDs)
+        chainKeys.forEach((chainKey) => {
+            this._chainListMap.textUpdate(chainKey, textWriters, this._textDataPreAdaptor);
+        });
+    }
+
+
+
+
+    _cleanChainsFromSemiPlugins(chainKeys: string[]): void {
+        if (!this.globe || !this.gl) {
+            throw new Error("Globe or WebGL context is not initialized");
+        }
+
+        for (const chainKey of chainKeys) {
+            // Clean chains from text writers
+            const nodeKeys = this._chainListMap.getNodeKeysOfChain(chainKey);
+            this._textWritersMap.forEach((writer) => {
+                writer.deleteTextBulk(nodeKeys);
+            });
+            nodeKeys.pop(); // Remove the last key which is destination of the last circle
+            // Clean chains from semi-plugins
+            this.circlePlugin?.deleteBulk(nodeKeys);
+            this.linePlugin?.deleteBulk(nodeKeys);
+            this.arcPlugin?.deleteBulk(nodeKeys);
+        }
+    }
+
+
+
+    _reconstructChains(chainKeys: string[]): void {
+        // TODO: this is core
+        // Get chain nodes
+        const globe = this.globe as Globe;
+        if (!globe || !this.gl) {
+            throw new Error("Globe or WebGL context is not initialized");
+        }
+        for (let chainKey of chainKeys) {
+            const chain = this._chainListMap.getChain(chainKey);
+            if (!chain) {
+                console.warn(`Chain with key ${chainKey} not found.`);
+                continue;
+            }
+            const lineInput = lineDataAdaptor(chain);
+            const arcInput = arcDataAdaptor(chain);
+            const circleInput = circleDataAdaptor(globe, chain);
+            this.linePlugin?.insertBulk(lineInput);
+            this.arcPlugin?.insertBulk(arcInput);
+            this.circlePlugin?.insertBulk(circleInput);
+
+        }
+    }
+
+
+
+
+    // GLOBE INTERFACE METHODS
+
+    init(globe: Globe, gl: WebGL2RenderingContext): void {
+        this.globe = globe;
+        this.gl = gl;
+
+        // Initialize sub-plugins with unique IDs
+        this.circlePlugin = new CircleOnTerrainPlugin(`${this.id}_unregistered_circles`,
+            this._semiPluginOptions.circleOnTerrainOptions);
+        this.linePlugin = new LinePlugin(`${this.id}_unregistered_lines`,
+            this._semiPluginOptions.lineOptions);
+        this.arcPlugin = new ArcOnTerrainPlugin(`${this.id}_unregistered_arcs`,
+            this._semiPluginOptions.arcOnTerrainOptions);
+        this.circlePlugin.init(globe, gl);
+        this.linePlugin.init(globe, gl);
+        this.arcPlugin.init(globe, gl);
+
+    }
+
+
+    draw3D(): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot draw.");
+            return;
+        }
+        const { globe, gl } = this;
+        if (!globe || !gl) {
+            console.warn("Globe or WebGL context is not initialized, cannot draw.");
+            return;
+        }
+
+        const circleOpacity = getOpacity(this._opacities, "circle");
+        if (this._drawCircleOn && circleOpacity !== 0) {
+            this.circlePlugin?.setPluginOpacity(circleOpacity, false);
+            this.circlePlugin?.draw3D();
+        }
+
+        const currentGeometry = globe.api_GetCurrentGeometry();
+
+        switch (currentGeometry) {
+            case 0: {
+                // globe view
+
+                const lineOpacity = getOpacity(this._opacities, "globeArc");
+                if (lineOpacity !== 0) {
+                    this.linePlugin?.setPluginOpacity(lineOpacity, false);
+                    this.linePlugin?.draw3D();
+                }
+                const arcOpacity = getOpacity(this._opacities, "globeArcFitsTerrain");
+                if (arcOpacity !== 0) {
+                    this.arcPlugin?.setPluginOpacity(arcOpacity, false);
+                    this.arcPlugin?.draw3D();
+                }
+                break;
+            }
+            case 1: {
+                // flat view
+                const lineOpacity = getOpacity(this._opacities, "flatStraightLine");
+                if (lineOpacity !== 0) {
+                    this.linePlugin?.setPluginOpacity(lineOpacity);
+                    this.linePlugin?.draw3D();
+                }
+                const arcOpacity = getOpacity(this._opacities, "flatGreatCircleLine");
+                if (arcOpacity !== 0) {
+                    this.arcPlugin?.setPluginOpacity(arcOpacity);
+                    this.arcPlugin?.draw3D();
+                }
+                break;
+            }
+            default: {
+                throw new Error("Unknown geometry type, Implementation need on Circle-Line-Chain Plugin");
+            }
+        }
+
+        this._textWritersMap.forEach((writer) => {
+            writer.draw();
+        });
+    }
+
+
+    free(): void {
+        if (this._freed) return;
+        this._freed = true;
+
+        // Free sub-plugins
+        this.circlePlugin?.free();
+        this.linePlugin?.free();
+        this.arcPlugin?.free();
+
+
+        // Clear text writers map
+        this._textWritersMap.clear();
+
+        // Clear references
+        this.globe = null;
+        this.gl = null;
+        this.circlePlugin = null;
+        this.linePlugin = null;
+        this.arcPlugin = null;
+    }
+
+
+}