@pirireis/webglobeplugins 0.9.10 → 0.9.11

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

@@ -5,27 +5,28 @@ exports.ChainListMap = void 0;
  * set and get node data
  * node indexes;
  */
-class ChainListMap {
-    constructor(keyMethod) {
+var ChainListMap = /** @class */ (function () {
+    function ChainListMap(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) {
+    ChainListMap.prototype.getChain = function (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];
+    ChainListMap.prototype.addNode = function (node, chainKey, theNodeKeyFront) {
+        if (theNodeKeyFront === void 0) { theNodeKeyFront = null; }
+        var chain = this.getChain(chainKey);
+        var frontIndex = null;
+        for (var i = 0; i < chain.length; i++) {
+            var n_ode = chain[i];
             if (n_ode.key === node.key) {
                 throw new Error("Chain node already exists");
             }
@@ -46,15 +47,15 @@ class ChainListMap {
         }
         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__;
+    };
+    ChainListMap.prototype.deleteNodesBelongToAChain = function (chainKey, nodeKeys) {
+        var chain = this._chainMap.get(chainKey);
+        var deleteKeys = [];
+        var removeSet = new Set(nodeKeys);
+        var newChain = [];
+        for (var i = 0; i < chain.length - 1; i++) {
+            var node = chain[i];
+            var dKey = node.__identity__;
             this._indexMap.delete(dKey);
             if (removeSet.has(node.key)) {
                 deleteKeys.push(dKey);
@@ -64,7 +65,7 @@ class ChainListMap {
             }
         }
         { // last item case
-            const lastItem = chain[chain.length - 1];
+            var lastItem = chain[chain.length - 1];
             this._indexMap.delete(lastItem.__identity__);
             if (removeSet.has(lastItem.key)) {
                 if (chain.length > 1) {
@@ -79,127 +80,132 @@ class ChainListMap {
         }
         this._chainMap.set(chainKey, newChain);
         return deleteKeys;
-    }
-    deleteChainAndReturnChainKeys(chainKey) {
-        const keys = this.getNodeKeysOfChain(chainKey);
+    };
+    ChainListMap.prototype.deleteChainAndReturnChainKeys = function (chainKey) {
+        var keys = this.getNodeKeysOfChain(chainKey);
         this._chainMap.delete(chainKey);
-        for (const key of keys)
+        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+            var key = keys_1[_i];
             this._indexMap.delete(key);
+        }
         return keys;
-    }
-    updateNode(node, chainKey) {
-        const index = this.getIndexOfNode(chainKey, node.key);
-        const chain = this._chainMap.get(chainKey);
+    };
+    ChainListMap.prototype.updateNode = function (node, chainKey) {
+        var index = this.getIndexOfNode(chainKey, node.key);
+        var 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];
+    };
+    ChainListMap.prototype.updateNodesProperties = function (chainKey, nodes) {
+        var _this = this;
+        nodes.forEach(function (node) {
+            var index = _this.getIndexOfNode(chainKey, node.key);
+            var 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);
+                node.circleProperties.forEach(function (value, key, container) { return chainNode.circleProperties[key] = value; });
             }
             if (node.lineProperties) {
                 if (typeof chainNode.lineProperties !== 'object')
                     chainNode.lineProperties = {};
-                node.lineProperties.forEach((value, key, container) => chainNode.lineProperties[key] = value);
+                node.lineProperties.forEach(function (value, key, container) { return chainNode.lineProperties[key] = value; });
             }
         });
-    }
-    updateCoordsinatesOfNode(node, chainKey) {
-        const index = this.getIndexOfNode(chainKey, node.key);
-        const chain = this._chainMap.get(chainKey);
+    };
+    ChainListMap.prototype.updateCoordsinatesOfNode = function (node, chainKey) {
+        var index = this.getIndexOfNode(chainKey, node.key);
+        var chain = this._chainMap.get(chainKey);
         chain[index].long = node.long;
         chain[index].lat = node.lat;
-    }
-    setChain(chainKey, nodeList) {
+    };
+    ChainListMap.prototype.setChain = function (chainKey, nodeList) {
+        var _this = this;
         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) {
+        nodeList.forEach(function (v) { return v.__identity__ = _this.keyMethod(chainKey, v.key); });
+    };
+    ChainListMap.prototype.setChainProperties = function (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) => {
+    ChainListMap.prototype.updateChainProperties = function (chainKey, properties) {
+        var memoryProperties = this._chainSideProperties.get(chainKey);
+        properties.forEach(function (value, key, m) {
             memoryProperties[key] = value;
         });
-    }
-    getChainProperties(chainKey) {
+    };
+    ChainListMap.prototype.getChainProperties = function (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);
+    ChainListMap.prototype.calculateBufferPropertiesChain = function (chainKey, callback, result) {
+        var chain = this._chainMap.get(chainKey);
+        var props = this._chainSideProperties.get(chainKey);
+        for (var i = 0; i < chain.length - 1; i++) {
+            var 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);
+    ChainListMap.prototype.textUpdate = function (chainKey, textWriterObjs, dataPreAdaptor) {
+        var chain = this._chainMap.get(chainKey);
         if (!chain)
             return;
-        const data = (dataPreAdaptor) ? chain.map(dataPreAdaptor) : chain;
-        const properties = this._chainSideProperties.get(chainKey);
-        textWriterObjs.forEach((writer) => {
+        var data = (dataPreAdaptor) ? chain.map(dataPreAdaptor) : chain;
+        var properties = this._chainSideProperties.get(chainKey);
+        textWriterObjs.forEach(function (writer) {
             writer.insertTextBulk(data, properties);
         });
-    }
-    getAllChainKeysIterator() {
+    };
+    ChainListMap.prototype.getAllChainKeysIterator = function () {
         return this._chainMap.keys();
-    }
-    getIndexOfNode(chainKey, nodeKey) {
-        const key = this.keyMethod(chainKey, nodeKey);
+    };
+    ChainListMap.prototype.getIndexOfNode = function (chainKey, nodeKey) {
+        var 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];
+        var chain = this._chainMap.get(chainKey);
+        for (var i = 0; i < chain.length; i++) {
+            var node = chain[i];
             this._indexMap.set(key, i);
             if (node.key === nodeKey) {
                 return i;
             }
         }
-    }
-    _flushIndexMap() {
+    };
+    ChainListMap.prototype._flushIndexMap = function () {
         this._indexMap.clear();
-    }
-    _resetIndexChain(chainKey) {
-        const chain = this._chainMap.get(chainKey);
-        for (let i = 0; i < chain.length; i++) {
-            const node = chain[i];
+    };
+    ChainListMap.prototype._resetIndexChain = function (chainKey) {
+        var chain = this._chainMap.get(chainKey);
+        for (var i = 0; i < chain.length; i++) {
+            var node = chain[i];
             this._indexMap.set(this.keyMethod(chainKey, node.key), i);
         }
-    }
-    getNodeKeysOfChain(chainKey) {
-        const chain = this._chainMap.get(chainKey);
+    };
+    ChainListMap.prototype.getNodeKeysOfChain = function (chainKey) {
+        var chain = this._chainMap.get(chainKey);
         if (!chain)
             return [];
-        const result = chain.map((v) => v.__identity__);
+        var result = chain.map(function (v) { return v.__identity__; });
         return result;
-    }
-}
+    };
+    return ChainListMap;
+}());
 exports.ChainListMap = ChainListMap;