@pirireis/webglobeplugins 1.0.2 → 1.0.3

package/semiplugins/shape-on-terrain/terrain-polygon/{adapters.ts → adapters.js}

@@ -1,69 +1,55 @@
-import { Color } from "../../../types";
-import { PolygonPluginInput } from "./types";
-
-
-function geoJSONToTerrainPolygon(geojson: any,
-    keyAdapter: (feature: any) => string,
-    colorAdapter: (feature: any) => Color | undefined
-): PolygonPluginInput[] {
-
-    if (geojson.type !== 'FeatureCollection') {
-        throw new Error('Invalid GeoJSON: Expected FeatureCollection');
-    }
-
-    const features = geojson.features;
-    const polygons: PolygonPluginInput[] = [];
-
-    for (const feature of features) {
-        const geometry = feature.geometry;
-        const key = keyAdapter(feature);
-        const color = colorAdapter(feature);
-        const geometries: { vertices: number[]; holes: number[] }[] = [];
-
-        if (geometry.type === 'Polygon') {
-            const coordinates = geometry.coordinates;
-            const vertices: number[] = [];
-            const holes: number[] = [];
-            let holeIndex = 0;
-            for (let i = 0; i < coordinates.length; i++) {
-                if (i > 0) {
-                    holeIndex += coordinates[i - 1].length;
-                    holes.push(holeIndex);
-                }
-                for (const coord of coordinates[i]) {
-                    vertices.push(coord[0], coord[1]);
-                }
-            }
-            geometries.push({ vertices, holes });
-        } else if (geometry.type === 'MultiPolygon') {
-            const multiCoordinates = geometry.coordinates;
-            for (const coordinates of multiCoordinates) {
-                const vertices: number[] = [];
-                const holes: number[] = [];
-                let holeIndex = 0;
-                for (let i = 0; i < coordinates.length; i++) {
-                    if (i > 0) {
-                        holeIndex += coordinates[i - 1].length;
-                        holes.push(holeIndex);
-                    }
-                    for (const coord of coordinates[i]) {
-                        vertices.push(coord[0], coord[1]);
-                    }
-                }
-                geometries.push({ vertices, holes });
-            }
-        } else {
-            continue; // Skip non-polygon geometries
-        }
-
-        if (geometries.length > 0) {
-            polygons.push({ key, color, geometry: geometries });
-        }
-    }
-
-    return polygons;
-
-}
-
-
-export { geoJSONToTerrainPolygon };
+function geoJSONToTerrainPolygon(geojson, keyAdapter, colorAdapter) {
+    if (geojson.type !== 'FeatureCollection') {
+        throw new Error('Invalid GeoJSON: Expected FeatureCollection');
+    }
+    const features = geojson.features;
+    const polygons = [];
+    for (const feature of features) {
+        const geometry = feature.geometry;
+        const key = keyAdapter(feature);
+        const color = colorAdapter(feature);
+        const geometries = [];
+        if (geometry.type === 'Polygon') {
+            const coordinates = geometry.coordinates;
+            const vertices = [];
+            const holes = [];
+            let holeIndex = 0;
+            for (let i = 0; i < coordinates.length; i++) {
+                if (i > 0) {
+                    holeIndex += coordinates[i - 1].length;
+                    holes.push(holeIndex);
+                }
+                for (const coord of coordinates[i]) {
+                    vertices.push(coord[0], coord[1]);
+                }
+            }
+            geometries.push({ vertices, holes });
+        }
+        else if (geometry.type === 'MultiPolygon') {
+            const multiCoordinates = geometry.coordinates;
+            for (const coordinates of multiCoordinates) {
+                const vertices = [];
+                const holes = [];
+                let holeIndex = 0;
+                for (let i = 0; i < coordinates.length; i++) {
+                    if (i > 0) {
+                        holeIndex += coordinates[i - 1].length;
+                        holes.push(holeIndex);
+                    }
+                    for (const coord of coordinates[i]) {
+                        vertices.push(coord[0], coord[1]);
+                    }
+                }
+                geometries.push({ vertices, holes });
+            }
+        }
+        else {
+            continue; // Skip non-polygon geometries
+        }
+        if (geometries.length > 0) {
+            polygons.push({ key, color, geometry: geometries });
+        }
+    }
+    return polygons;
+}
+export { geoJSONToTerrainPolygon };

package/semiplugins/shape-on-terrain/terrain-polygon/data/{cache.ts → cache.js}

@@ -1,149 +1,102 @@
-import { TrianglesMiddleData } from "../types";
-import { TriangleTessellationMeta, createTriangleTessellationMeta } from "../../../../Math/tessellation/triangle-tessellation";
-import { triangulation } from "./polygon-to-triangles";
-import { Color, GlobeBBox } from "../../../../types";
-import { LongLat } from "../../../../Math/types";
-import { CatchedType } from "./types";
-
-import { PolygonProperties, CacheTriangle } from "./types";
-import RBush from "rbush";
-import { RADIAN } from "../../../../Math/methods";
-import { PolygonInput } from "../types";
-
-type BBOXES = {
-    zoom: number,
-    minX: number,
-    minY: number,
-    maxX: number,
-    maxY: number
-}
-
-
-// TODO: use type instead of any
-function _entry(polygon: PolygonInput, kmThreshold: number): CatchedType[] {
-    __polygonInputWGS84ToRadian(polygon);
-    const trianglesData: TrianglesMiddleData = triangulation(polygon, kmThreshold);
-    const cacheTriangles: CatchedType[] = [];
-
-
-    for (let i = 0; i < trianglesData.indices.length; i += 3) {
-
-        const idx0 = trianglesData.indices[i] * 2;
-        const idx1 = trianglesData.indices[i + 1] * 2;
-        const idx2 = trianglesData.indices[i + 2] * 2;
-
-        const v0 = [trianglesData.vertices[idx0], trianglesData.vertices[idx0 + 1]] as LongLat;
-        const v1 = [trianglesData.vertices[idx1], trianglesData.vertices[idx1 + 1]] as LongLat;
-        const v2 = [trianglesData.vertices[idx2], trianglesData.vertices[idx2 + 1]] as LongLat;
-
-        const tessellationMeta = createTriangleTessellationMeta(v0, v1, v2);
-
-        cacheTriangles.push({
-            polygon: polygon,
-            offset: i / 3,
-            tessellationMeta: tessellationMeta,
-            minX: tessellationMeta.bbox.min[0],
-            minY: tessellationMeta.bbox.min[1],
-            maxX: tessellationMeta.bbox.max[0],
-            maxY: tessellationMeta.bbox.max[1],
-        });
-    }
-    return cacheTriangles;
-}
-
-
-function __polygonInputWGS84ToRadian(polygon: PolygonInput) {
-    for (const geom of polygon.geometry) {
-        const vertices: number[] = geom.vertices;
-        for (let i = 0; i < vertices.length / 2; i++) {
-            vertices[i * 2] = vertices[i * 2] * RADIAN;
-            vertices[i * 2 + 1] = vertices[i * 2 + 1] * RADIAN;
-        }
-    }
-}
-
-export class Cache {
-    private cache: Map<string,
-        {
-            polygon: PolygonInput,
-            triangles: CatchedType[]
-        }> = new Map();
-    private kmThreshold: number;
-    private rbush: RBush = new RBush();
-    private bboxes: BBOXES[] = [];
-    constructor(kmThreshold: number) {
-        this.kmThreshold = kmThreshold;
-    }
-
-
-    clear(): void {
-        this.cache.clear();
-        this.rbush.clear();
-    }
-
-
-
-    insert(key: string, polygon: PolygonInput): void {
-        if (this.cache.has(key)) {
-            this.remove(key);
-        }
-        const triangles = _entry(polygon as PolygonInput, this.kmThreshold);
-        this.rbush.load(triangles);
-        this.cache.set(key, { polygon: polygon as PolygonInput, triangles });
-    }
-
-
-    remove(key: string): void {
-        const entry = this.cache.get(key);
-        if (entry) {
-            for (const triangle of entry.triangles) {
-                this.rbush.remove(triangle);
-            }
-            this.cache.delete(key);
-        }
-    }
-
-
-    setBBOXes(BBOXES: BBOXES[]): void {
-        this.bboxes = BBOXES;
-    }
-
-    search(): Set<CatchedType> {
-        const results = new Set<CatchedType>();
-        for (const bbox of this.bboxes) {
-            const { minX, minY, maxX, maxY } = bbox;
-            if (minX <= maxX && minY <= maxY) {
-                // Normal case
-                const partialResults = this.rbush.search({ minX, minY, maxX, maxY }) as CatchedType[];
-                for (const res of partialResults) {
-                    results.add(res);
-                }
-            } else {
-                // Handle antimeridian crossing
-                // MinX > MaxX case is the signal.
-                const partialResults1 = this.rbush.search({ minX, minY, maxX: Math.PI, maxY }) as CatchedType[];
-                const partialResults2 = this.rbush.search({ minX: -Math.PI, minY, maxX, maxY }) as CatchedType[];
-                for (const res of partialResults1) {
-                    results.add(res);
-                }
-                for (const res of partialResults2) {
-                    results.add(res);
-                }
-            }
-
-        }
-        return results;
-    }
-
-
-
-    defragment(): void {
-        const allItems = this.rbush.all() as CatchedType[];
-        this.rbush.clear();
-        this.rbush.load(allItems);
-    }
-
-
-
-
-}
+import { createTriangleTessellationMeta } from "../../../../Math/tessellation/triangle-tessellation";
+import { triangulation } from "./polygon-to-triangles";
+import RBush from "rbush";
+import { RADIAN } from "../../../../Math/methods";
+// TODO: use type instead of any
+function _entry(polygon, kmThreshold) {
+    __polygonInputWGS84ToRadian(polygon);
+    const trianglesData = triangulation(polygon, kmThreshold);
+    const cacheTriangles = [];
+    for (let i = 0; i < trianglesData.indices.length; i += 3) {
+        const idx0 = trianglesData.indices[i] * 2;
+        const idx1 = trianglesData.indices[i + 1] * 2;
+        const idx2 = trianglesData.indices[i + 2] * 2;
+        const v0 = [trianglesData.vertices[idx0], trianglesData.vertices[idx0 + 1]];
+        const v1 = [trianglesData.vertices[idx1], trianglesData.vertices[idx1 + 1]];
+        const v2 = [trianglesData.vertices[idx2], trianglesData.vertices[idx2 + 1]];
+        const tessellationMeta = createTriangleTessellationMeta(v0, v1, v2);
+        cacheTriangles.push({
+            polygon: polygon,
+            offset: i / 3,
+            tessellationMeta: tessellationMeta,
+            minX: tessellationMeta.bbox.min[0],
+            minY: tessellationMeta.bbox.min[1],
+            maxX: tessellationMeta.bbox.max[0],
+            maxY: tessellationMeta.bbox.max[1],
+        });
+    }
+    return cacheTriangles;
+}
+function __polygonInputWGS84ToRadian(polygon) {
+    for (const geom of polygon.geometry) {
+        const vertices = geom.vertices;
+        for (let i = 0; i < vertices.length / 2; i++) {
+            vertices[i * 2] = vertices[i * 2] * RADIAN;
+            vertices[i * 2 + 1] = vertices[i * 2 + 1] * RADIAN;
+        }
+    }
+}
+export class Cache {
+    cache = new Map();
+    kmThreshold;
+    rbush = new RBush();
+    bboxes = [];
+    constructor(kmThreshold) {
+        this.kmThreshold = kmThreshold;
+    }
+    clear() {
+        this.cache.clear();
+        this.rbush.clear();
+    }
+    insert(key, polygon) {
+        if (this.cache.has(key)) {
+            this.remove(key);
+        }
+        const triangles = _entry(polygon, this.kmThreshold);
+        this.rbush.load(triangles);
+        this.cache.set(key, { polygon: polygon, triangles });
+    }
+    remove(key) {
+        const entry = this.cache.get(key);
+        if (entry) {
+            for (const triangle of entry.triangles) {
+                this.rbush.remove(triangle);
+            }
+            this.cache.delete(key);
+        }
+    }
+    setBBOXes(BBOXES) {
+        this.bboxes = BBOXES;
+    }
+    search() {
+        const results = new Set();
+        for (const bbox of this.bboxes) {
+            const { minX, minY, maxX, maxY } = bbox;
+            if (minX <= maxX && minY <= maxY) {
+                // Normal case
+                const partialResults = this.rbush.search({ minX, minY, maxX, maxY });
+                for (const res of partialResults) {
+                    results.add(res);
+                }
+            }
+            else {
+                // Handle antimeridian crossing
+                // MinX > MaxX case is the signal.
+                const partialResults1 = this.rbush.search({ minX, minY, maxX: Math.PI, maxY });
+                const partialResults2 = this.rbush.search({ minX: -Math.PI, minY, maxX, maxY });
+                for (const res of partialResults1) {
+                    results.add(res);
+                }
+                for (const res of partialResults2) {
+                    results.add(res);
+                }
+            }
+        }
+        return results;
+    }
+    defragment() {
+        const allItems = this.rbush.all();
+        this.rbush.clear();
+        this.rbush.load(allItems);
+    }
+}

package/semiplugins/shape-on-terrain/terrain-polygon/data/{index-polygon-map.ts → index-polygon-map.js}

@@ -1,58 +1,45 @@
-import { PolygonInput, PolygonPluginInput } from "../types";
-
-export class IndexPolygonMap {
-
-    private _indexPolygonMap: Map<number, PolygonInput> = new Map();
-    private _polygonKeyMap: Map<string, number> = new Map();
-    private _thumbstones: number[] = [];
-    private _polygonIndex: number = 1; // 0 index is null
-
-    constructor() { }
-
-    private newIndex(): number {
-        if (this._thumbstones.length > 0) {
-            return this._thumbstones.pop() as number;
-        }
-        return this._polygonIndex++;
-    }
-
-    insertBulk(polygons: PolygonPluginInput[]) {
-
-        for (const poly of polygons) {
-            if (this._polygonKeyMap.has(poly.key)) {
-                this.deleteBulk([poly.key]);
-            }
-            const index = this.newIndex();
-            // @ts-ignore
-            poly.index = index; // Assign the new index to the polygon
-            this._indexPolygonMap.set(index, poly as PolygonInput);
-            this._polygonKeyMap.set(poly.key, index);
-        }
-
-        return polygons as PolygonInput[];
-    }
-
-    deleteBulk(keys: string[]) {
-        for (const key of keys) {
-            const index = this._polygonKeyMap.get(key);
-            if (index === undefined) continue;
-            this._polygonKeyMap.delete(key);
-            this._indexPolygonMap.delete(index);
-            this._thumbstones.push(index);
-        }
-    }
-
-
-    get(index: number): PolygonPluginInput | null {
-        return this._indexPolygonMap.get(index) || null;
-    }
-
-
-    clear() {
-        this._indexPolygonMap.clear();
-        this._polygonKeyMap.clear();
-        this._thumbstones = [];
-        this._polygonIndex = 1;
-    }
-}
-
+export class IndexPolygonMap {
+    _indexPolygonMap = new Map();
+    _polygonKeyMap = new Map();
+    _thumbstones = [];
+    _polygonIndex = 1; // 0 index is null
+    constructor() { }
+    newIndex() {
+        if (this._thumbstones.length > 0) {
+            return this._thumbstones.pop();
+        }
+        return this._polygonIndex++;
+    }
+    insertBulk(polygons) {
+        for (const poly of polygons) {
+            if (this._polygonKeyMap.has(poly.key)) {
+                this.deleteBulk([poly.key]);
+            }
+            const index = this.newIndex();
+            // @ts-ignore
+            poly.index = index; // Assign the new index to the polygon
+            this._indexPolygonMap.set(index, poly);
+            this._polygonKeyMap.set(poly.key, index);
+        }
+        return polygons;
+    }
+    deleteBulk(keys) {
+        for (const key of keys) {
+            const index = this._polygonKeyMap.get(key);
+            if (index === undefined)
+                continue;
+            this._polygonKeyMap.delete(key);
+            this._indexPolygonMap.delete(index);
+            this._thumbstones.push(index);
+        }
+    }
+    get(index) {
+        return this._indexPolygonMap.get(index) || null;
+    }
+    clear() {
+        this._indexPolygonMap.clear();
+        this._polygonKeyMap.clear();
+        this._thumbstones = [];
+        this._polygonIndex = 1;
+    }
+}

package/semiplugins/shape-on-terrain/terrain-polygon/data/{manager.ts → manager.js}

@@ -1,4 +1,4 @@
-// this is the glue binds data to plugin
-// plugin inserts data to this.
-// plugin send bboxes and zoom levels and expects data ready to be looaded on polygon program
-
+"use strict";
+// this is the glue binds data to plugin
+// plugin inserts data to this.
+// plugin send bboxes and zoom levels and expects data ready to be looaded on polygon program