@pirireis/webglobeplugins 1.0.2 → 1.0.4

package/webglobeplugins/semiplugins/shape-on-terrain/terrain-polygon/data/master-worker.js

@@ -0,0 +1,241 @@
+/// <reference lib="webworker" />
+/* eslint-disable no-restricted-globals */
+import { uint32Escape } from "../../../../Math/tessellation/triangle-tessellation";
+const _workers = [];
+const _workerMap = new Map();
+let _maxWorkers = 4;
+let _nextWorkerIndex = 0;
+let _pickableState;
+let _arcState;
+let _variativeColorsOn;
+// NEW: barrier state for "wait for all outputs of the last dispatched batch"
+let _batchInFlight = false;
+let _batchPending = 0;
+function initWorkers() {
+    _maxWorkers = Math.max(1, ((navigator.hardwareConcurrency - 2) || 4) - 1);
+    console.log(`TerrainPolygon: initializing ${_maxWorkers} workers.`);
+    for (let i = 0; i < _maxWorkers; i++)
+        addWorker();
+}
+function addWorker() {
+    // IMPORTANT: use the TS entry so the bundler can build the worker module.
+    // @ts-ignore
+    const worker = new Worker(new URL("./worker.ts", import.meta.url), { type: "module" });
+    const wrapper = {
+        worker,
+        inProgress: false,
+        insertDeleteQueue: [],
+        lastBBOXData: null,
+        itemCount: 0,
+        lastOutput: null,
+    };
+    worker.onmessage = (event) => {
+        wrapper.inProgress = false;
+        wrapper.lastOutput = event.data;
+        // Barrier: only merge/send after all workers dispatched for this batch have finished.
+        if (_batchInFlight) {
+            _batchPending = Math.max(0, _batchPending - 1);
+            if (_batchPending === 0) {
+                _batchInFlight = false;
+                mergeAndSendResults();
+                // Start next batch (if anything queued while we were waiting)
+                triggerAllWorkers();
+            }
+            return;
+        }
+        // Fallback (should rarely happen): if not in a batch, allow immediate draining.
+        sendToSubWorker(wrapper);
+    };
+    worker.postMessage({
+        pickableState: _pickableState,
+        variativeColorsOn: _variativeColorsOn,
+        arcState: _arcState,
+        insertDeleteQueue: [],
+        bboxes: null,
+    });
+    _workers.push(wrapper);
+}
+function mergeAndSendResults() {
+    // Match the working master-worker.js sentinel/header layout
+    const BASE_VEC3S = 9; // 3 vertices * 3
+    const BASE_INDICES = 3;
+    const BASE_LONGLATS = 6; // 3 vertices * 2
+    const BASE_PICKINDICES = 3;
+    const BASE_VARIATIVE = _variativeColorsOn ? 12 : 0; // 3 vertices * 4
+    const BASE_REAL_EDGE_ARC_INDICES = _arcState ? 1 : 0; // reserve header only when arc mode is enabled
+    let totalVec3s = BASE_VEC3S;
+    let totalIndices = BASE_INDICES;
+    let totalLongLats = BASE_LONGLATS;
+    let totalPickIndices = BASE_PICKINDICES;
+    let totalVariativeColors = BASE_VARIATIVE;
+    let totalRealEdgeArcIndices = BASE_REAL_EDGE_ARC_INDICES;
+    const validOutputs = [];
+    for (const w of _workers) {
+        if (w.lastOutput) {
+            validOutputs.push(w.lastOutput);
+            totalVec3s += w.lastOutput.vec3s.length;
+            totalIndices += w.lastOutput.indices.length;
+            totalLongLats += w.lastOutput.longLats.length;
+            if (_arcState && w.lastOutput.realEdgeArcIndices) {
+                totalRealEdgeArcIndices += w.lastOutput.realEdgeArcIndices.length;
+            }
+            if (w.lastOutput.pickIndices)
+                totalPickIndices += w.lastOutput.pickIndices.length;
+            if (w.lastOutput.variativeColors)
+                totalVariativeColors += w.lastOutput.variativeColors.length;
+        }
+    }
+    if (validOutputs.length === 0)
+        return;
+    const merged = {
+        vec3s: new Float32Array(totalVec3s),
+        indices: new Uint32Array(totalIndices),
+        longLats: new Float32Array(totalLongLats),
+        realEdgeArcIndices: _arcState && totalRealEdgeArcIndices > 0 ? new Uint32Array(totalRealEdgeArcIndices) : null,
+        pickIndices: totalPickIndices > 0 ? new Float32Array(totalPickIndices) : null,
+        variativeColors: totalVariativeColors > 0 ? new Uint8Array(totalVariativeColors) : null,
+    };
+    // Sentinel/header (as in master-worker.js)
+    merged.vec3s[0] = NaN;
+    merged.vec3s[1] = NaN;
+    merged.vec3s[2] = NaN;
+    // Uint32Array cannot hold NaN; writing NaN becomes 0. Keep the header reserved anyway.
+    merged.indices[0] = 0;
+    merged.indices[1] = 0;
+    merged.indices[2] = 0;
+    merged.longLats[0] = NaN;
+    merged.longLats[1] = NaN;
+    if (_arcState && merged.realEdgeArcIndices) {
+        merged.realEdgeArcIndices[0] = 0; // header/sentinel
+    }
+    if (merged.variativeColors) {
+        // Sentinel/header (no-color marker)
+        merged.variativeColors[0] = 0;
+        merged.variativeColors[1] = 0;
+        merged.variativeColors[2] = 0;
+        merged.variativeColors[3] = 255;
+    }
+    let offsetVec3s = BASE_VEC3S;
+    let offsetIndices = BASE_INDICES;
+    let offsetLongLats = BASE_LONGLATS;
+    let offsetPickIndices = BASE_PICKINDICES;
+    let offsetVariativeColors = BASE_VARIATIVE;
+    let vertexOffset = 3; // reserve 3 vertices
+    let arcCounter = BASE_REAL_EDGE_ARC_INDICES;
+    for (const out of validOutputs) {
+        merged.vec3s.set(out.vec3s, offsetVec3s);
+        offsetVec3s += out.vec3s.length;
+        for (let i = 0; i < out.indices.length; i++) {
+            merged.indices[offsetIndices + i] = out.indices[i] + vertexOffset;
+        }
+        if (_arcState && merged.realEdgeArcIndices && out.realEdgeArcIndices) {
+            for (let i = 0; i < out.realEdgeArcIndices.length; i++) {
+                const realEdgeIndice = out.realEdgeArcIndices[i];
+                merged.realEdgeArcIndices[arcCounter++] =
+                    realEdgeIndice === uint32Escape ? uint32Escape : realEdgeIndice + vertexOffset;
+            }
+        }
+        offsetIndices += out.indices.length;
+        vertexOffset += out.vec3s.length / 3;
+        merged.longLats.set(out.longLats, offsetLongLats);
+        offsetLongLats += out.longLats.length;
+        if (merged.pickIndices && out.pickIndices) {
+            merged.pickIndices.set(out.pickIndices, offsetPickIndices);
+            offsetPickIndices += out.pickIndices.length;
+        }
+        if (merged.variativeColors && out.variativeColors) {
+            merged.variativeColors.set(out.variativeColors, offsetVariativeColors);
+            offsetVariativeColors += out.variativeColors.length;
+        }
+    }
+    self.postMessage(merged, [
+        merged.vec3s.buffer,
+        merged.indices.buffer,
+        merged.longLats.buffer,
+        ...(merged.pickIndices ? [merged.pickIndices.buffer] : []),
+        ...(merged.variativeColors ? [merged.variativeColors.buffer] : []),
+        ...(merged.realEdgeArcIndices ? [merged.realEdgeArcIndices.buffer] : []),
+    ]);
+}
+function sendToSubWorker(wrapper) {
+    if (wrapper.inProgress)
+        return false;
+    if (wrapper.insertDeleteQueue.length === 0 && wrapper.lastBBOXData === null)
+        return false;
+    wrapper.inProgress = true;
+    wrapper.worker.postMessage({
+        pickableState: undefined,
+        variativeColorsOn: undefined,
+        arcState: undefined,
+        bboxes: wrapper.lastBBOXData,
+        insertDeleteQueue: wrapper.insertDeleteQueue,
+    });
+    wrapper.lastBBOXData = null;
+    wrapper.insertDeleteQueue = [];
+    return true;
+}
+function triggerAllWorkers() {
+    // If a batch is already running, do not start another one.
+    if (_batchInFlight)
+        return;
+    let dispatched = 0;
+    for (const w of _workers) {
+        if (sendToSubWorker(w))
+            dispatched++;
+    }
+    // Start barrier only if we actually dispatched work.
+    if (dispatched > 0) {
+        _batchInFlight = true;
+        _batchPending = dispatched;
+    }
+}
+self.onmessage = (event) => {
+    const { bboxes, insertDeleteQueue, pickableState, variativeColorsOn, arcState } = event.data;
+    if (_workers.length === 0) {
+        _pickableState = pickableState;
+        _variativeColorsOn = variativeColorsOn;
+        _arcState = arcState;
+        initWorkers();
+    }
+    if (bboxes) {
+        for (const w of _workers)
+            w.lastBBOXData = bboxes;
+    }
+    if (insertDeleteQueue && insertDeleteQueue.length > 0) {
+        if (insertDeleteQueue[0] === "__CLEAR_ALL_ITEMS__") {
+            _workerMap.clear();
+            for (const w of _workers) {
+                w.insertDeleteQueue = ["__CLEAR_ALL_ITEMS__"];
+                w.itemCount = 0;
+                w.lastOutput = null;
+            }
+        }
+        else {
+            for (const item of insertDeleteQueue) {
+                if (typeof item === "string") {
+                    // Delete
+                    const workerIdx = _workerMap.get(item);
+                    if (workerIdx !== undefined) {
+                        _workers[workerIdx].insertDeleteQueue.push(item);
+                        _workers[workerIdx].itemCount--;
+                        _workerMap.delete(item);
+                    }
+                }
+                else {
+                    // Insert/Update: MUST enqueue the full polygon payload, not just the key
+                    let workerIdx = _workerMap.get(item.key);
+                    if (workerIdx === undefined) {
+                        workerIdx = _nextWorkerIndex;
+                        _workerMap.set(item.key, workerIdx);
+                        _workers[workerIdx].itemCount++;
+                        _nextWorkerIndex = (_nextWorkerIndex + 1) % _workers.length;
+                    }
+                    _workers[workerIdx].insertDeleteQueue.push(item);
+                }
+            }
+        }
+    }
+    // This now starts a "batch" and waits for all dispatched workers to respond
+    // before mergeAndSendResults() is called.
+    triggerAllWorkers();
+};

package/webglobeplugins/semiplugins/shape-on-terrain/terrain-polygon/data/polygon-to-triangles.js

@@ -0,0 +1,76 @@
+/**
+ * # Purpose
+ * Divide long edges of polygons into smaller segments
+ *
+ * This algorithm should be called after earcutting / triangulation.
+ * Then earcut should run second time to further divide long edges.
+ *
+ * populate points on a arc between two given points on a sphere
+ *
+ */
+import earcut from "earcut";
+function _isReal(a, b, len) {
+    return (Math.abs(a - b) === 1 || Math.abs(a - b) === len);
+}
+function edgeKey(a, b) {
+    // undirected edge key
+    return a < b ? `${a},${b}` : `${b},${a}`;
+}
+export function calculateRealEdges(geom, indeces) {
+    const realEdges = [];
+    const boundaryEdges = new Set();
+    // Build boundary edges for all geometries, using a running vertex offset
+    // (must match how triangulation() concatenates vertices and offsets indices).
+    let vertexIndexOffset = 0;
+    for (const g of geom) {
+        const vertexCount = g.vertices.length / 2;
+        if (!Number.isInteger(vertexCount) || vertexCount <= 1) {
+            vertexIndexOffset += vertexCount; // still advance consistently
+            continue;
+        }
+        // Build rings: [0..holes[0]), [holes[0]..holes[1]), ... , [holes[last]..vertexCount)
+        const ringStarts = [0, ...(g.holes ?? [])];
+        const ringEnds = [...(g.holes ?? []), vertexCount];
+        for (let r = 0; r < ringStarts.length; r++) {
+            const start = ringStarts[r];
+            const end = ringEnds[r];
+            if (end - start < 2)
+                continue;
+            for (let i = start; i < end - 1; i++) {
+                boundaryEdges.add(edgeKey(vertexIndexOffset + i, vertexIndexOffset + i + 1));
+            }
+            // close the ring
+            boundaryEdges.add(edgeKey(vertexIndexOffset + (end - 1), vertexIndexOffset + start));
+        }
+        vertexIndexOffset += vertexCount;
+    }
+    // Mark each triangle edge as "real" iff it belongs to any boundary ring edge
+    for (let i = 0; i < indeces.length; i += 3) {
+        const a = indeces[i];
+        const b = indeces[i + 1];
+        const c = indeces[i + 2];
+        realEdges.push(boundaryEdges.has(edgeKey(a, b)));
+        realEdges.push(boundaryEdges.has(edgeKey(b, c)));
+        realEdges.push(boundaryEdges.has(edgeKey(c, a)));
+    }
+    return realEdges;
+}
+function triangulation(polygon) {
+    const finalVertices = [];
+    const finalIndices = [];
+    let vertexIndexOffset = 0;
+    for (const geom of polygon.geometry) {
+        const indices = earcut(geom.vertices, geom.holes, 2);
+        finalVertices.push(...geom.vertices);
+        for (const index of indices) {
+            finalIndices.push(index + vertexIndexOffset);
+        }
+        vertexIndexOffset += geom.vertices.length / 2;
+    }
+    return {
+        key: polygon.key,
+        vertices: finalVertices,
+        indices: finalIndices,
+    };
+}
+export { triangulation };

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

@@ -1,165 +1,121 @@
-/**
- * Generates random polygon data for testing PolygonPluginInput
- */
-
-import { GlobeBBox } from "../../../../types";
-
-/**
- * Generates a random polygon with optional holes
- * @param {Object} options - Configuration options
- * @param {number} options.minVertices - Minimum number of vertices for the shell (default: 3)
- * @param {number} options.maxVertices - Maximum number of vertices for the shell (default: 8)
- * @param {number} options.holeCount - Number of holes to generate (default: 0)
- * @param {number} options.minLat - Minimum latitude (default: -85)
- * @param {number} options.maxLat - Maximum latitude (default: 85)
- * @param {number} options.minLng - Minimum longitude (default: -180)
- * @param {number} options.maxLng - Maximum longitude (default: 180)
- * @param {number} options.dimensions - Number of dimensions per vertex (default: 2)
- * @returns {Object} PolygonPluginInput object
- */
-function generateRandomPolygon(options: {
-    minVertices?: number;
-    maxVertices?: number;
-    holeCount?: number;
-    minLat?: number;
-    maxLat?: number;
-    minLng?: number;
-    maxLng?: number;
-    radius?: number;
-    dimensions?: number;
-} = {}) {
-    const {
-        minVertices = 3,
-        maxVertices = 8,
-        holeCount = 0,
-        minLat = -85,
-        maxLat = 85,
-        minLng = -180,
-        maxLng = 180,
-        dimensions = 2,
-        radius = 4,
-    } = options;
-
-    const key = `polygon_${Date.now()}_${Math.floor(Math.random() * 1000)}_${Math.random()}`;
-    const vertices = [];
-    const holes = [];
-
-    // Generate shell vertices
-    const shellVertexCount = Math.floor(Math.random() * (maxVertices - minVertices + 1)) + minVertices;
-    const centerLng = Math.random() * (maxLng - minLng) + minLng;
-    const centerLat = Math.random() * (maxLat - minLat) + minLat;
-
-    // Generate shell as a rough circle with random variations
-    for (let i = 0; i < shellVertexCount; i++) {
-        const angle = (i / shellVertexCount) * 2 * Math.PI;
-        const radiusVariation = radius * (0.7 + Math.random() * 0.6); // Add variation to radius
-        const lng = centerLng + Math.cos(angle) * radiusVariation;
-        const lat = centerLat + Math.sin(angle) * radiusVariation;
-
-        vertices.push(lng, lat);
-        if (dimensions > 2) {
-            for (let d = 2; d < dimensions; d++) {
-                vertices.push(Math.random() * 1000); // Random additional dimensions
-            }
-        }
-    }
-
-    // Generate holes
-    for (let h = 0; h < holeCount; h++) {
-        const holeStartIndex = vertices.length / dimensions;
-        holes.push(holeStartIndex);
-
-        const holeVertexCount = Math.floor(Math.random() * 4) + 3; // 3-6 vertices for holes
-        const holeRadius = radius * (0.2 + Math.random() * 0.3); // Smaller radius for holes
-        const holeCenterLng = centerLng + (Math.random() - 0.5) * radius * 0.8;
-        const holeCenterLat = centerLat + (Math.random() - 0.5) * radius * 0.8;
-
-        for (let i = 0; i < holeVertexCount; i++) {
-            const angle = (i / holeVertexCount) * 2 * Math.PI;
-            const lng = holeCenterLng + Math.cos(angle) * holeRadius;
-            const lat = holeCenterLat + Math.sin(angle) * holeRadius;
-
-            vertices.push(lng, lat);
-            if (dimensions > 2) {
-                for (let d = 2; d < dimensions; d++) {
-                    vertices.push(Math.random() * 1000);
-                }
-            }
-        }
-    }
-
-    return {
-        key,
-        geometry: [{ vertices, holes }],
-        color: [Math.random(), Math.random(), Math.random(), 1.0],
-    };
-}
-
-/**
- * Generates multiple random polygons
- * @param {number} count - Number of polygons to generate
- * @param {Object} options - Options to pass to generateRandomPolygon
- * @returns {Array} Array of PolygonPluginInput objects
- */
-function generateRandomPolygons(count: number, options = {}) {
-    const polygons = [];
-    for (let i = 0; i < count; i++) {
-        polygons.push(generateRandomPolygon(options));
-    }
-    return polygons;
-}
-
-/**
- * Generates a simple rectangular polygon for basic testing
- * @param {number} lng - Center longitude
- * @param {number} lat - Center latitude
- * @param {number} width - Width in degrees
- * @param {number} height - Height in degrees
- * @returns {Object} PolygonPluginInput object
- */
-function generateRectanglePolygon(lng = 0, lat = 0, width = 2, height = 1) {
-    const halfWidth = width / 2;
-    const halfHeight = height / 2;
-
-    return {
-        key: `rectangle_${Date.now()}`,
-        geometry: [{
-            vertices: [
-                lng - halfWidth, lat - halfHeight,  // Bottom-left
-                lng + halfWidth, lat - halfHeight,  // Bottom-right
-                lng + halfWidth, lat + halfHeight,  // Top-right
-                lng - halfWidth, lat + halfHeight   // Top-left
-            ],
-            holes: []
-        }]
-    };
-}
-
-function generateRectangleFromBBOX(bbox: GlobeBBox, key: string | null = null) {
-    const { ll, ur } = bbox;
-    return {
-        key: key || `rectangle_${Date.now()}`,
-        geometry: [{
-            vertices: [
-                ll.x, ll.y,  // Bottom-left
-                ur.x, ll.y,  // Bottom-right
-                ur.x, ur.y,  // Top-right
-                ll.x, ur.y   // Top-left
-            ],
-            holes: []
-        }]
-    };
-}
-
-// // Example usage:
-// console.log('Polygon with holes:', generateRandomPolygon({ holeCount: 2 }));
-// console.log('Multiple polygons:', generateRandomPolygons(3));
-// console.log('Rectangle polygon:', generateRectanglePolygon(-74, 40.7, 0.1, 0.05));
-
-export {
-    generateRandomPolygon,
-    generateRandomPolygons,
-    generateRectanglePolygon,
-    generateRectangleFromBBOX
-};
-
+/**
+ * Generates random polygon data for testing PolygonPluginInput
+ */
+/**
+ * Generates a random polygon with optional holes
+ * @param {Object} options - Configuration options
+ * @param {number} options.minVertices - Minimum number of vertices for the shell (default: 3)
+ * @param {number} options.maxVertices - Maximum number of vertices for the shell (default: 8)
+ * @param {number} options.holeCount - Number of holes to generate (default: 0)
+ * @param {number} options.minLat - Minimum latitude (default: -85)
+ * @param {number} options.maxLat - Maximum latitude (default: 85)
+ * @param {number} options.minLng - Minimum longitude (default: -180)
+ * @param {number} options.maxLng - Maximum longitude (default: 180)
+ * @param {number} options.dimensions - Number of dimensions per vertex (default: 2)
+ * @returns {Object} PolygonPluginInput object
+ */
+function generateRandomPolygon(options = {}) {
+    const { minVertices = 3, maxVertices = 8, holeCount = 0, minLat = -85, maxLat = 85, minLng = -180, maxLng = 180, dimensions = 2, radius = 4, } = options;
+    const key = `polygon_${Date.now()}_${Math.floor(Math.random() * 1000)}_${Math.random()}`;
+    const vertices = [];
+    const holes = [];
+    // Generate shell vertices
+    const shellVertexCount = Math.floor(Math.random() * (maxVertices - minVertices + 1)) + minVertices;
+    const centerLng = Math.random() * (maxLng - minLng) + minLng;
+    const centerLat = Math.random() * (maxLat - minLat) + minLat;
+    // Generate shell as a rough circle with random variations
+    for (let i = 0; i < shellVertexCount; i++) {
+        const angle = (i / shellVertexCount) * 2 * Math.PI;
+        const radiusVariation = radius * (0.7 + Math.random() * 0.6); // Add variation to radius
+        const lng = centerLng + Math.cos(angle) * radiusVariation;
+        const lat = centerLat + Math.sin(angle) * radiusVariation;
+        vertices.push(lng, lat);
+        if (dimensions > 2) {
+            for (let d = 2; d < dimensions; d++) {
+                vertices.push(Math.random() * 1000); // Random additional dimensions
+            }
+        }
+    }
+    // Generate holes
+    for (let h = 0; h < holeCount; h++) {
+        const holeStartIndex = vertices.length / dimensions;
+        holes.push(holeStartIndex);
+        const holeVertexCount = Math.floor(Math.random() * 4) + 3; // 3-6 vertices for holes
+        const holeRadius = radius * (0.2 + Math.random() * 0.3); // Smaller radius for holes
+        const holeCenterLng = centerLng + (Math.random() - 0.5) * radius * 0.8;
+        const holeCenterLat = centerLat + (Math.random() - 0.5) * radius * 0.8;
+        for (let i = 0; i < holeVertexCount; i++) {
+            const angle = (i / holeVertexCount) * 2 * Math.PI;
+            const lng = holeCenterLng + Math.cos(angle) * holeRadius;
+            const lat = holeCenterLat + Math.sin(angle) * holeRadius;
+            vertices.push(lng, lat);
+            if (dimensions > 2) {
+                for (let d = 2; d < dimensions; d++) {
+                    vertices.push(Math.random() * 1000);
+                }
+            }
+        }
+    }
+    return {
+        key,
+        geometry: [{ vertices, holes }],
+        color: [Math.random(), Math.random(), Math.random(), 1.0],
+    };
+}
+/**
+ * Generates multiple random polygons
+ * @param {number} count - Number of polygons to generate
+ * @param {Object} options - Options to pass to generateRandomPolygon
+ * @returns {Array} Array of PolygonPluginInput objects
+ */
+function generateRandomPolygons(count, options = {}) {
+    const polygons = [];
+    for (let i = 0; i < count; i++) {
+        polygons.push(generateRandomPolygon(options));
+    }
+    return polygons;
+}
+/**
+ * Generates a simple rectangular polygon for basic testing
+ * @param {number} lng - Center longitude
+ * @param {number} lat - Center latitude
+ * @param {number} width - Width in degrees
+ * @param {number} height - Height in degrees
+ * @returns {Object} PolygonPluginInput object
+ */
+function generateRectanglePolygon(lng = 0, lat = 0, width = 2, height = 1) {
+    const halfWidth = width / 2;
+    const halfHeight = height / 2;
+    return {
+        key: `rectangle_${Date.now()}`,
+        geometry: [{
+                vertices: [
+                    lng - halfWidth, lat - halfHeight, // Bottom-left
+                    lng + halfWidth, lat - halfHeight, // Bottom-right
+                    lng + halfWidth, lat + halfHeight, // Top-right
+                    lng - halfWidth, lat + halfHeight // Top-left
+                ],
+                holes: []
+            }]
+    };
+}
+function generateRectangleFromBBOX(bbox, key = null) {
+    const { ll, ur } = bbox;
+    return {
+        key: key || `rectangle_${Date.now()}`,
+        geometry: [{
+                vertices: [
+                    ll.x, ll.y, // Bottom-left
+                    ur.x, ll.y, // Bottom-right
+                    ur.x, ur.y, // Top-right
+                    ll.x, ur.y // Top-left
+                ],
+                holes: []
+            }]
+    };
+}
+// // Example usage:
+// console.log('Polygon with holes:', generateRandomPolygon({ holeCount: 2 }));
+// console.log('Multiple polygons:', generateRandomPolygons(3));
+// console.log('Rectangle polygon:', generateRectanglePolygon(-74, 40.7, 0.1, 0.05));
+export { generateRandomPolygon, generateRandomPolygons, generateRectanglePolygon, generateRectangleFromBBOX };

package/webglobeplugins/semiplugins/shape-on-terrain/terrain-polygon/data/types.js

@@ -0,0 +1 @@
+export {};