@sakuzu/maplibre-gl-draw 1.0.0

package/dist/view/cache/buffer.js

@@ -0,0 +1,176 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * BufferCache
+ *
+ * Caches VAOs and buffers keyed by feature ID.
+ * They are recreated only when the geometry has changed.
+ *
+ * @internal
+ */
+export class BufferCache {
+    constructor(gl, maxCacheSize = 2000) {
+        Object.defineProperty(this, "gl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "maxCacheSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.gl = gl;
+        this.maxCacheSize = maxCacheSize;
+    }
+    /**
+     * Gets the geometry from the cache, creating it if it is not present
+     *
+     * @param key Cache key (for example "feature_1:fill")
+     * @param geometryHash Hash of the geometry (regenerated when the coordinates change)
+     * @param createFn Function that creates the geometry
+     */
+    getOrCreate(key, geometryHash, createFn) {
+        const cached = this.cache.get(key);
+        // If an entry is cached and its hash matches, reuse it
+        if (cached && cached.geometryHash === geometryHash) {
+            cached.lastUsed = Date.now();
+            return cached;
+        }
+        // Delete the stale cache entry if there is one
+        if (cached) {
+            this.gl.deleteVertexArray(cached.vao);
+            this.gl.deleteBuffer(cached.buffer);
+        }
+        // Check the cache size
+        if (this.cache.size >= this.maxCacheSize) {
+            this.evictOldest();
+        }
+        // Create the new geometry
+        const { vertices, vertexCount, drawMode, stride, attributes } = createFn();
+        const gl = this.gl;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        const buffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);
+        for (const attr of attributes) {
+            gl.enableVertexAttribArray(attr.index);
+            gl.vertexAttribPointer(attr.index, attr.size, gl.FLOAT, false, stride, attr.offset);
+        }
+        gl.bindVertexArray(null);
+        const geometry = {
+            vao,
+            buffer,
+            vertexCount,
+            drawMode,
+            geometryHash,
+            lastUsed: Date.now(),
+        };
+        this.cache.set(key, geometry);
+        return geometry;
+    }
+    /**
+     * Deletes the oldest entry (LRU)
+     */
+    evictOldest() {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.cache) {
+            if (entry.lastUsed < oldestTime) {
+                oldestTime = entry.lastUsed;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            this.invalidate(oldestKey);
+        }
+    }
+    /**
+     * Invalidates the cache entry for a specific key
+     */
+    invalidate(key) {
+        const cached = this.cache.get(key);
+        if (cached) {
+            this.gl.deleteVertexArray(cached.vao);
+            this.gl.deleteBuffer(cached.buffer);
+            this.cache.delete(key);
+        }
+    }
+    /**
+     * Invalidates the cache entries whose keys start with a specific prefix
+     * Used when deleting cache entries based on a feature ID
+     */
+    invalidateByPrefix(prefix) {
+        const keysToDelete = [];
+        for (const key of this.cache.keys()) {
+            if (key.startsWith(prefix)) {
+                keysToDelete.push(key);
+            }
+        }
+        for (const key of keysToDelete) {
+            this.invalidate(key);
+        }
+    }
+    /**
+     * Clears the whole cache
+     */
+    clear() {
+        for (const cached of this.cache.values()) {
+            this.gl.deleteVertexArray(cached.vao);
+            this.gl.deleteBuffer(cached.buffer);
+        }
+        this.cache.clear();
+    }
+    /**
+     * Gets the cache size
+     */
+    get size() {
+        return this.cache.size;
+    }
+    /**
+     * Releases the resources
+     */
+    dispose() {
+        this.clear();
+    }
+}
+/**
+ * Generates a hash from an array of coordinates
+ * Uses a fast hash function
+ */
+export function hashCoordinates(coords) {
+    // Stringify the coordinates and hash them
+    // Round to 6 decimal places to keep the hash stable
+    let hash = 0;
+    for (const [x, y] of coords) {
+        const xInt = Math.round(x * 1000000);
+        const yInt = Math.round(y * 1000000);
+        hash = ((hash << 5) - hash + xInt) | 0;
+        hash = ((hash << 5) - hash + yInt) | 0;
+    }
+    return hash.toString(36);
+}
+/**
+ * Generates a hash from a two-dimensional array of coordinates (the rings of a Polygon)
+ */
+export function hashRings(rings) {
+    let hash = 0;
+    for (const ring of rings) {
+        for (const [x, y] of ring) {
+            const xInt = Math.round(x * 1000000);
+            const yInt = Math.round(y * 1000000);
+            hash = ((hash << 5) - hash + xInt) | 0;
+            hash = ((hash << 5) - hash + yInt) | 0;
+        }
+    }
+    return hash.toString(36);
+}

package/dist/view/cache/earcut.d.ts

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

package/dist/view/cache/earcut.js

@@ -0,0 +1,122 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * EarcutCache
+ *
+ * Caches earcut results keyed by feature ID + part index
+ *
+ * @internal
+ */
+export class EarcutCache {
+    constructor() {
+        /**
+         * Holds, for each feature ID, a map of part index -> earcut result.
+         *
+         * Because a MultiPolygon has several polygon parts in a single feature,
+         * the cache key includes the part index as well. Invalidation is still done
+         * per feature ID, deleting all the parts of that feature.
+         */
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        /** Number of cache hits (for statistics) */
+        Object.defineProperty(this, "hits", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /** Number of cache misses (for statistics) */
+        Object.defineProperty(this, "misses", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    /**
+     * Gets an earcut result from the cache
+     *
+     * @param featureId Feature ID
+     * @param partIndex Part index (0 for a single polygon)
+     * @param signature Fingerprint of the geometry (when omitted, only entries recorded
+     *   without a fingerprint are matched)
+     * @returns The index array on a cache hit, null on a miss
+     */
+    get(featureId, partIndex = 0, signature) {
+        const entry = this.cache.get(featureId)?.get(partIndex);
+        if (entry && entry.signature === signature) {
+            this.hits++;
+            return entry.indices;
+        }
+        this.misses++;
+        return null;
+    }
+    /**
+     * Stores an earcut result in the cache
+     *
+     * @param featureId Feature ID
+     * @param indices Earcut result
+     * @param partIndex Part index (0 for a single polygon)
+     * @param signature Fingerprint of the geometry (when omitted, the entry is recorded
+     *   without a fingerprint)
+     */
+    set(featureId, indices, partIndex = 0, signature) {
+        let parts = this.cache.get(featureId);
+        if (!parts) {
+            parts = new Map();
+            this.cache.set(featureId, parts);
+        }
+        parts.set(partIndex, { indices, signature });
+    }
+    /**
+     * Deletes the cache entries of a specific feature (all parts)
+     */
+    delete(featureId) {
+        this.cache.delete(featureId);
+    }
+    /**
+     * Deletes the cache entries of several features
+     */
+    deleteMany(featureIds) {
+        for (const id of featureIds) {
+            this.cache.delete(id);
+        }
+    }
+    /**
+     * Clears the cache
+     */
+    clear() {
+        this.cache.clear();
+        this.hits = 0;
+        this.misses = 0;
+    }
+    /**
+     * Gets the cache statistics
+     *
+     * size is the number of parts held (a MultiPolygon counts as several within one feature).
+     */
+    getStats() {
+        const total = this.hits + this.misses;
+        let size = 0;
+        for (const parts of this.cache.values()) {
+            size += parts.size;
+        }
+        return {
+            size,
+            hits: this.hits,
+            misses: this.misses,
+            hitRate: total > 0 ? this.hits / total : 0,
+        };
+    }
+    /**
+     * Resets the statistics
+     */
+    resetStats() {
+        this.hits = 0;
+        this.misses = 0;
+    }
+}

package/dist/view/cache/style-rule.d.ts

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

package/dist/view/cache/style-rule.js

@@ -0,0 +1,97 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { evaluateStyleRule } from '../style-rule.js';
+/**
+ * StyleRuleCache
+ *
+ * Caches the result of evaluating a rule (the color), keyed by feature ID.
+ *
+ * @internal
+ */
+export class StyleRuleCache {
+    constructor() {
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        /** Number of cache hits (for statistics) */
+        Object.defineProperty(this, "hits", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /** Number of cache misses (for statistics) */
+        Object.defineProperty(this, "misses", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    /**
+     * Resolves the rule color to apply to a feature (the result is cached)
+     *
+     * When there is no rule, null is returned without evaluating or caching anything.
+     *
+     * @param feature The target feature
+     * @param rule The layer's style rule
+     * @returns The rule color (in #RRGGBB form). null when there is no rule
+     */
+    resolve(feature, rule) {
+        if (!rule)
+            return null;
+        const entry = this.cache.get(feature.id);
+        if (entry && entry.rule === rule) {
+            this.hits++;
+            return entry.color;
+        }
+        this.misses++;
+        const color = evaluateStyleRule(rule, feature.properties);
+        this.cache.set(feature.id, { rule, color });
+        return color;
+    }
+    /**
+     * Deletes the cache entry of a specific feature
+     */
+    delete(featureId) {
+        this.cache.delete(featureId);
+    }
+    /**
+     * Deletes the cache entries of several features
+     */
+    deleteMany(featureIds) {
+        for (const id of featureIds) {
+            this.cache.delete(id);
+        }
+    }
+    /**
+     * Clears the cache
+     */
+    clear() {
+        this.cache.clear();
+        this.hits = 0;
+        this.misses = 0;
+    }
+    /**
+     * Gets the cache statistics
+     */
+    getStats() {
+        const total = this.hits + this.misses;
+        return {
+            size: this.cache.size,
+            hits: this.hits,
+            misses: this.misses,
+            hitRate: total > 0 ? this.hits / total : 0,
+        };
+    }
+    /**
+     * Resets the statistics
+     */
+    resetStats() {
+        this.hits = 0;
+        this.misses = 0;
+    }
+}

package/dist/view/cache/terrain-fill.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Result cache for terrain tessellation
+ */
+export declare class TerrainFillCache {
+    private cache;
+    /**
+     * Gets a subdivision result (null when the fingerprint or the source data differs)
+     */
+    get(featureId: string, partIndex: number, signature: string, source: readonly number[]): {
+        flatCoords: number[];
+        indices: number[];
+        grid: number;
+    } | null;
+    /**
+     * Stores a subdivision result
+     */
+    set(featureId: string, partIndex: number, signature: string, source: readonly number[], flatCoords: number[], indices: number[], grid: number): void;
+    /**
+     * Deletes the records of a specific feature (all parts)
+     */
+    delete(featureId: string): void;
+    /**
+     * Discards everything
+     */
+    clear(): void;
+    /**
+     * The number of parts held
+     */
+    size(): number;
+}

package/dist/view/cache/terrain-fill.js

@@ -0,0 +1,60 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Result cache for terrain tessellation
+ */
+export class TerrainFillCache {
+    constructor() {
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    /**
+     * Gets a subdivision result (null when the fingerprint or the source data differs)
+     */
+    get(featureId, partIndex, signature, source) {
+        const entry = this.cache.get(featureId)?.get(partIndex);
+        if (!entry || entry.signature !== signature || entry.source !== source)
+            return null;
+        return { flatCoords: entry.flatCoords, indices: entry.indices, grid: entry.grid };
+    }
+    /**
+     * Stores a subdivision result
+     */
+    set(featureId, partIndex, signature, source, flatCoords, indices, grid) {
+        let parts = this.cache.get(featureId);
+        if (!parts) {
+            parts = new Map();
+            this.cache.set(featureId, parts);
+        }
+        parts.set(partIndex, { flatCoords, indices, signature, source, grid });
+    }
+    /**
+     * Deletes the records of a specific feature (all parts)
+     */
+    delete(featureId) {
+        this.cache.delete(featureId);
+    }
+    /**
+     * Discards everything
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * The number of parts held
+     */
+    size() {
+        let size = 0;
+        for (const parts of this.cache.values())
+            size += parts.size;
+        return size;
+    }
+}
+// No global instance is placed here. A subdivision result depends on "the generation and
+// step of that instance", so its owner is the TerrainContext of each draw instance
+// (`view/terrain/context.ts`). Back when it was shared by feature id, there was a defect
+// where triangles subdivided with the step of another instance could be picked up.

package/dist/view/cache/texture.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Uploads an image to a new RGBA texture with the unpack state the engine's shaders expect
+ *
+ * The shaders output colors that are not premultiplied and read the image with its first row at
+ * the top, so the upload sets `UNPACK_PREMULTIPLY_ALPHA_WEBGL` and `UNPACK_FLIP_Y_WEBGL` to
+ * false explicitly instead of inheriting whatever maplibre left in the context. The pixel store
+ * and the texture binding are borrowed and given back (maplibre-coupling.md): the values found
+ * are restored after the upload.
+ *
+ * @param mipmap Whether to build mipmaps (for images, which are often drawn smaller than their
+ *   size)
+ * @returns The texture, or null when it cannot be created (a lost context)
+ */
+export declare function uploadRgbaTexture(gl: WebGL2RenderingContext, source: TexImageSource, mipmap: boolean): WebGLTexture | null;