@pirireis/webglobeplugins 0.9.12 → 0.9.13

package/bearing-line/plugin.js

@@ -1,18 +1,15 @@
-"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({
+import { PieceOfPieProgramCache } from '../programs/rings/partial-ring/piece-of-pie';
+import { LineOnGlobeCache } from '../programs/line-on-globe/naive-accurate-flexible';
+import { CircleCache as Circle3DCache } from '../programs/line-on-globe/circle-accurate-3d';
+import { CircleCache, EDGE_COUNT as flatCircleEdgeCount, centerCoords2dflatDataCreator } from '../programs/line-on-globe/circle-accurate-flat';
+import { BufferOrchestrator, BufferManager } from '../util/account';
+import { mapGetOrThrow } from "../util/check/get";
+import { populateFloat32Array } from "../util/jshelpers/data-filler";
+import { ContextTextWriter3 } from '../write-text/context-text3';
+import { constraintFloat, isBoolean } from '../util/check/typecheck';
+import { sphereCoord } from '../util/geometry';
+import { createBufferAndReadInfo } from '../util/gl-util/buffer/attribute-loader';
+export const RINGPARTIAL_DRAW_MODE = Object.freeze({
     LINE_STRIP: "LINE_STRIP",
     TRIANGLE_FAN: "TRIANGLE_FAN",
 });
@@ -33,7 +30,7 @@ exports.RINGPARTIAL_DRAW_MODE = Object.freeze({
      * @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 textWriterGetOrThrow = 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));
@@ -44,15 +41,15 @@ const calculateStartAngle = (long, lat, endLong, endLat) => {
     let angle = -Math.atan2(dLat, dLong);
     return angle;
 };
-class BearingLinePlugin {
+export default 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 } = {}) {
+    constructor(id, { opacity = 1, textWritersMap = new Map(), textDataPreAdaptor = (x) => x, drawVRM = true, drawBearingLine = true, drawAngleRing = true, drawText = true, circleFlatEdgeCount = flatCircleEdgeCount - 2 } = {}) {
         this.id = id;
         this._opacity = opacity;
-        this.bufferOrchestrator = new account_1.BufferOrchestrator({ capacity: 10 });
+        this.bufferOrchestrator = new BufferOrchestrator({ capacity: 10 });
         this._checkTextContextWriterInjectionMap(textWritersMap);
         this._textWritersMap = textWritersMap;
         this._textWritersMap.forEach((writer) => writer.keyAdaptor = (item) => item.key);
@@ -65,35 +62,35 @@ class BearingLinePlugin {
         this.circleFlatEdgeCount = circleFlatEdgeCount + 2;
     }
     setDoDrawVRM(bool) {
-        (0, typecheck_1.isBoolean)(bool);
+        isBoolean(bool);
         if (bool === this.drawVRM)
             return;
         this.drawVRM = bool;
         this.globe.DrawRender();
     }
     setDoDrawText(bool) {
-        (0, typecheck_1.isBoolean)(bool);
+        isBoolean(bool);
         if (bool === this.drawText)
             return;
         this.drawText = bool;
         this.globe.DrawRender();
     }
     setDoDrawText(bool) {
-        (0, typecheck_1.isBoolean)(bool);
+        isBoolean(bool);
         if (bool === this.drawText)
             return;
         this.drawText = bool;
         this.globe.DrawRender();
     }
     setDoDrawAngleRing(bool) {
-        (0, typecheck_1.isBoolean)(bool);
+        isBoolean(bool);
         if (bool === this.drawAngleRing)
             return;
         this.drawAngleRing = bool;
         this.globe.DrawRender();
     }
     setOpacity(opacity) {
-        (0, typecheck_1.constraintFloat)(opacity, 0, 1);
+        constraintFloat(opacity, 0, 1);
         this._opacity = opacity;
         this._textWritersMap.forEach((writer) => writer.setOpacity(opacity));
         this.globe.DrawRender();
@@ -186,7 +183,7 @@ class BearingLinePlugin {
         if (!(textContextWriterInjectionMap instanceof Map))
             throw new Error("textContextWriterInjectionMap is not an instance of Map");
         textContextWriterInjectionMap.forEach((v) => {
-            if (!(v instanceof context_text3_1.ContextTextWriter3))
+            if (!(v instanceof ContextTextWriter3))
                 throw new Error("textContextWriterInjectionMap element is not an instance of ContextTextWriter3");
         });
     }
@@ -240,7 +237,7 @@ class BearingLinePlugin {
         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 });
+        const centerCoords2dflat = centerCoords2dflatDataCreator(globe, item.long, item.lat, item.endLong, item.endLat, { startAngleOfCircle, edgeCount: this.circleFlatEdgeCount });
         return {
             key: item.key,
             lat: item.lat,
@@ -275,10 +272,10 @@ class BearingLinePlugin {
     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);
+        this.lineProgram = LineOnGlobeCache.get(globe);
+        this.pieceOfPieProgram = PieceOfPieProgramCache.get(globe);
+        this.circleProgram = CircleCache.get(globe);
+        this.circle3DProgram = Circle3DCache.get(globe);
         const circleFlatEdgeCount = this.circleFlatEdgeCount;
         {
             // createBuffers
@@ -286,97 +283,97 @@ class BearingLinePlugin {
             const initialCapacity = this.bufferOrchestrator.capacity;
             this.bufferManagersCompMap = new Map([
                 ["centerCoords2d", {
-                        'bufferManager': new account_1.BufferManager(gl, 2, { bufferType, initialCapacity }),
+                        'bufferManager': new 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 }),
+                        'bufferManager': new 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),
+                        '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, initialCapacity }),
+                        'bufferManager': new 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)
+                        'bufferManager': new BufferManager(gl, 3, { bufferType, initialCapacity }),
+                        'adaptor': (item) => sphereCoord(item.endLong, item.endLat, globe, item.altitude)
                     }],
                 ["bearingTargetCoords2d", {
-                        'bufferManager': new account_1.BufferManager(gl, 2, { bufferType, initialCapacity }),
+                        'bufferManager': new 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)
+                        'bufferManager': new BufferManager(gl, 3, { bufferType, initialCapacity }),
+                        'adaptor': (item) => sphereCoord(item.bearingLong, item.bearingLat, globe, item.altitude)
                     }],
                 ["startAngle2d", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.startAngle2d])
                     }],
                 ["tailAngle2d", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.tailAngle2d])
                     }],
                 ["startAngle3d", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.startAngle3d])
                     }],
                 ["tailAngle3d", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.tailAngle3d])
                     }],
                 ["bearingDashRatio", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([0])
                     }],
                 ["rgba", {
-                        'bufferManager': new account_1.BufferManager(gl, 4, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 4, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array(item.rgba)
                     }],
                 ["radius", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.radius])
                     }],
                 ["rgbaMode", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.rgbaMode])
                     }],
                 ["dashRatio", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.dashRatio])
                     }],
                 ["bigRadius", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.bigRadius])
                     }],
                 ["dashOpacity", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.dashOpacity]),
                     }],
                 ["circleDashAngle", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new 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),
+                        'bufferManager': new BufferManager(gl, 4 * circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        'adaptor': (item) => 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),
+                        'bufferManager': new BufferManager(gl, circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        'adaptor': (item) => 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),
+                        'bufferManager': new BufferManager(gl, circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        'adaptor': (item) => populateFloat32Array.fillFloat32Array(circleFlatEdgeCount, item.dashOpacity),
                     }],
             ]);
         }
-        const vaoOBJ = (key) => (0, attribute_loader_1.createBufferAndReadInfo)(this.bufferManagersCompMap.get(key).bufferManager.buffer);
+        const vaoOBJ = (key) => 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',
@@ -401,8 +398,8 @@ class BearingLinePlugin {
         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);
+            this.pieceOfPieProgram.draw(this.bufferOrchestrator.length, this.ringVao, 360, this._opacity * 0.8, RINGPARTIAL_DRAW_MODE.TRIANGLE_FAN);
+            this.pieceOfPieProgram.draw(this.bufferOrchestrator.length, this.ringVao, 360, this._opacity * 0.8, RINGPARTIAL_DRAW_MODE.LINE_STRIP);
         }
         if (this.drawBearingLine) {
             // this.lineProgram.draw(this.bearingLineVAO, this.bufferOrchestrator.length, this._opacity );
@@ -433,10 +430,10 @@ class BearingLinePlugin {
         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);
+        LineOnGlobeCache.release(globe);
+        PieceOfPieProgramCache.release(globe);
+        CircleCache.release(globe);
+        Circle3DCache.release(globe);
         this.isFreed = true;
     }
     _deleteTexts(keys) {
@@ -445,4 +442,3 @@ class BearingLinePlugin {
         });
     }
 }
-exports.default = BearingLinePlugin;

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

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChainListMap = void 0;
 /**
  * set and get node data
  * node indexes;
  */
-class ChainListMap {
+export class ChainListMap {
     constructor(keyMethod) {
         this._chainMap = new Map();
         this._chainSideProperties = new Map();
@@ -202,4 +199,3 @@ class ChainListMap {
         return result;
     }
 }
-exports.ChainListMap = ChainListMap;

package/circle-line-chain/plugin.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CircleLineChainPlugin = void 0;
-const naive_accurate_flexible_1 = require("../programs/line-on-globe/naive-accurate-flexible");
-const circle_accurate_flat_1 = require("../programs/line-on-globe/circle-accurate-flat");
-const circle_accurate_3d_1 = require("../programs/line-on-globe/circle-accurate-3d");
-const account_1 = require("../util/account");
-const chain_list_map_1 = require("./chain-list-map");
-const get_1 = require("../util/check/get");
-const util_1 = require("./util");
-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 attribute_loader_1 = require("../util/gl-util/buffer/attribute-loader");
-const 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,21 +52,21 @@ const index_1 = require("../util/geometry/index");
  *
  * //property {Array<Node>} nodes
  */
-const textWriterGetOrThrow = (0, get_1.mapGetOrThrow)("textWriterIDs is invalid");
-class CircleLineChainPlugin {
+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";
      */
-    constructor(id, { drawCircleOn = true, textWritersMap = new Map(), textDataPreAdaptor = null, circleFlatEdgeCount = circle_accurate_flat_1.EDGE_COUNT - 2 } = {}) {
+    constructor(id, { drawCircleOn = true, textWritersMap = new Map(), textDataPreAdaptor = null, circleFlatEdgeCount = flatCircleEdgeCount - 2 } = {}) {
         this.id = id;
         this._checktextWritersMap(textWritersMap);
         this._textWritersMap = textWritersMap;
         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;
@@ -178,7 +175,7 @@ class CircleLineChainPlugin {
         this.globe.DrawRender();
     }
     setOpacity(opacity) {
-        (0, typecheck_1.opacityCheck)(opacity);
+        opacityCheck(opacity);
         this._textWritersMap.forEach((writer) => writer.setOpacity(opacity));
         this._opacity = opacity;
         this.globe.DrawRender();
@@ -227,15 +224,15 @@ class CircleLineChainPlugin {
         if (!(textWritersMap instanceof Map))
             throw new Error("textWritersMap is not an instance of Map");
         textWritersMap.forEach((v) => {
-            if (!(v instanceof context_text3_1.ContextTextWriter3))
+            if (!(v instanceof ContextTextWriter3))
                 throw new Error("textWritersMap element is not an instance of ContextTextWriter3");
         });
     }
     _initOrchestrations() {
         const { gl, globe } = this;
-        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);
+        this.lineProgram = LineOnGlobeCache.get(globe);
+        this.circleProgram2d = CircleCache.get(globe);
+        this.circle3DProgram = Circle3DCache.get(globe);
         const _circleFlatEdgeCount = this._circleFlatEdgeCount;
         {
             // createBuffers
@@ -243,23 +240,23 @@ class CircleLineChainPlugin {
             const initialCapacity = this.bufferOrchestrator.capacity;
             this.bufferManagersCompMap = new Map([
                 ["centerCoords2d", {
-                        'bufferManager': new account_1.BufferManager(gl, 2, { bufferType, initialCapacity }),
+                        '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, initialCapacity }),
-                        'adaptor': (item) => (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, initialCapacity }),
+                        '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, initialCapacity }),
-                        'adaptor': (item) => (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, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 4, { bufferType, initialCapacity }),
                         'adaptor': (item) => {
                             if (item.lineProperties?.rgba)
                                 return new Float32Array(item.lineProperties.rgba);
@@ -271,15 +268,15 @@ class CircleLineChainPlugin {
                 //     'adaptor': (item) => new Float32Array([item.bigRadius])
                 // }],
                 ["dashRatio", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.chainProperties.dashRatio])
                     }],
                 ["dashOpacity", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.chainProperties.dashOpacity])
                     }],
                 ["circleDashAngle", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => {
                             if (item.circleProperties?.circleDashAngle)
                                 return new Float32Array([item.circleProperties.circleDashAngle / 360]);
@@ -287,7 +284,7 @@ class CircleLineChainPlugin {
                         }
                     }],
                 ["rgbaCircle", {
-                        "bufferManager": new account_1.BufferManager(gl, 4, { bufferType, initialCapacity }),
+                        "bufferManager": new BufferManager(gl, 4, { bufferType, initialCapacity }),
                         "adaptor": (item) => {
                             if (item.circleProperties?.rgba)
                                 return new Float32Array(item.circleProperties.rgba);
@@ -296,31 +293,31 @@ class CircleLineChainPlugin {
                     }],
                 // Mercator buffers
                 ["circleDashAngleMercator", {
-                        'bufferManager': new account_1.BufferManager(gl, 1 * _circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        '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, initialCapacity }),
+                        "bufferManager": new BufferManager(gl, 4 * _circleFlatEdgeCount, { bufferType, initialCapacity }),
                         "adaptor": (item) => {
                             if (item.circleProperties?.rgba)
-                                return data_filler_1.populateFloat32Array.fillWithListData(_circleFlatEdgeCount, item.circleProperties.rgba);
-                            return data_filler_1.populateFloat32Array.fillWithListData(_circleFlatEdgeCount, item.chainProperties.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, initialCapacity }),
-                        'adaptor': (item) => 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, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 2 * _circleFlatEdgeCount, { bufferType, initialCapacity }),
                         'adaptor': (item) => item.centerCoords2dflat,
                     }],
             ]);
-            const obj = (key) => (0, attribute_loader_1.createBufferAndReadInfo)(this.bufferManagersCompMap.get(key).bufferManager.buffer);
+            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"
@@ -343,7 +340,7 @@ class CircleLineChainPlugin {
         const callback = (v, i, array, chainProperties) => {
             if (i === array.length - 1)
                 return null;
-            const centerCoords2dflat = (0, circle_accurate_flat_1.centerCoords2dflatDataCreator)(globe, v.long, v.lat, array[i + 1].long, array[i + 1].lat, { edgeCount: this._circleFlatEdgeCount });
+            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,
@@ -376,9 +373,9 @@ class CircleLineChainPlugin {
         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((writer) => writer.free());
         const { gl } = this;
@@ -412,7 +409,6 @@ class CircleLineChainPlugin {
         gl.enable(gl.DEPTH_TEST);
     }
 }
-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;
-const keyMethod = (chainKey, nodeKey) => `${chainKey}_${nodeKey}`;
-exports.keyMethod = keyMethod;
+export const keyMethod = (chainKey, nodeKey) => `${chainKey}_${nodeKey}`;

package/compass-rose/compass-rose-padding-flat.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PixelPaddingCompassPlugin = void 0;
-const pixel_padding_for_compass_1 = require("../programs/two-d/pixel-padding-for-compass");
-const account_1 = require("../util/account");
-const compass_text_writer_1 = require("./compass-text-writer");
+import { PixelPaddingForFlatCompassCache } from "../programs/two-d/pixel-padding-for-compass";
+import { BufferManager, BufferOrchestrator } from "../util/account";
+import { PixelPaddingCompassTextWriter } from "./compass-text-writer";
 const PaddingAngle = 30;
 const textGapFit = 10;
-class PixelPaddingCompassPlugin {
+export class PixelPaddingCompassPlugin {
     constructor(id, { opacity = 1, textAngleOn = true, defaultProperties = {
         rgba: [1, 1, 1, 1],
         pixelRadiusRatioBig: 0.8,
@@ -31,7 +28,7 @@ class PixelPaddingCompassPlugin {
         this.id = id;
         this.textAngleOn = textAngleOn;
         this.defaultProperties = defaultProperties;
-        this.bufferOrchestrator = new account_1.BufferOrchestrator({ capacity: 10 });
+        this.bufferOrchestrator = new BufferOrchestrator({ capacity: 10 });
         this._font_hold = { font, northFont };
         this.compassMap = new CompassMap(this);
         this._opacity = opacity;
@@ -84,26 +81,26 @@ class PixelPaddingCompassPlugin {
     }
     _initOrchestrations() {
         const { gl, globe } = this;
-        this.paddingProgram = pixel_padding_for_compass_1.PixelPaddingForFlatCompassCache.get(globe);
+        this.paddingProgram = PixelPaddingForFlatCompassCache.get(globe);
         {
             // createBuffers
             const bufferType = "DYNAMIC_DRAW";
             const initialCapacity = this.bufferOrchestrator.capacity;
             this.bufferManagersCompMap = new Map([
                 ["screenCoordinates", {
-                        'bufferManager': new account_1.BufferManager(gl, 2, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 2, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.x, item.y])
                     }],
                 ["pixelRadiusRatioSmall", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.properties.pixelRadiusRatioSmall])
                     }],
                 ["pixelRadiusRatioBig", {
-                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.properties.pixelRadiusRatioBig])
                     }],
                 ["rgba", {
-                        'bufferManager': new account_1.BufferManager(gl, 4, { bufferType, initialCapacity }),
+                        'bufferManager': new BufferManager(gl, 4, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array(item.properties.rgba)
                     }],
             ]);
@@ -114,7 +111,7 @@ class PixelPaddingCompassPlugin {
         }
     }
     _createTextWriter() {
-        this.writer = new compass_text_writer_1.PixelPaddingCompassTextWriter(this.globe, { angle: PaddingAngle, ...this._font_hold });
+        this.writer = new PixelPaddingCompassTextWriter(this.globe, { angle: PaddingAngle, ...this._font_hold });
     }
     resize() {
         this.writer?.resize();
@@ -159,7 +156,7 @@ class PixelPaddingCompassPlugin {
         this.compassMap.free();
         const { globe, gl, paddingVao } = this;
         gl.deleteVertexArray(paddingVao);
-        pixel_padding_for_compass_1.PixelPaddingForFlatCompassCache.release(globe);
+        PixelPaddingForFlatCompassCache.release(globe);
         this.bufferManagersCompMap.forEach(v => {
             v.bufferManager.free();
         });
@@ -178,7 +175,6 @@ class PixelPaddingCompassPlugin {
         return Math.min(globe.api_ScrW(), globe.api_ScrH());
     }
 }
-exports.PixelPaddingCompassPlugin = PixelPaddingCompassPlugin;
 class CompassMap {
     constructor(parent) {
         this.coordsMemory = new Map();