@india-boundary-corrector/tilefixer 0.0.2 → 0.0.4

package/README.md

@@ -13,12 +13,12 @@ npm install @india-boundary-corrector/tilefixer
 ## Usage
 
 ```javascript
-import { BoundaryCorrector } from '@india-boundary-corrector/tilefixer';
+import { TileFixer } from '@india-boundary-corrector/tilefixer';
 import { getPmtilesUrl } from '@india-boundary-corrector/data';
 import { layerConfigs } from '@india-boundary-corrector/layer-configs';
 
 // Create a boundary corrector
-const corrector = new BoundaryCorrector(getPmtilesUrl());
+const corrector = new TileFixer(getPmtilesUrl());
 
 // Get corrections for a tile
 const corrections = await corrector.getCorrections(z, x, y);
@@ -30,32 +30,38 @@ const fixedTileData = await corrector.fixTile(
   corrections,
   originalTileArrayBuffer,
   layerConfig,
-  z,       // zoom level
-  256      // tile size (optional, defaults to 256)
+  z        // zoom level (tile size is derived from image)
 );
 ```
 
 ## API
 
-### `BoundaryCorrector`
+### `TileFixer`
+
+#### Static Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `TileFixer.getOrCreate(pmtilesUrl)` | `TileFixer` | Get or create a TileFixer for a URL (reuses existing instances) |
+| `TileFixer.setDefaultCacheMaxFeatures(count)` | `void` | Set default max features to cache for new instances (default: 25000) |
 
 #### Constructor
 
 ```javascript
-new BoundaryCorrector(pmtilesUrl, options?)
+new TileFixer(pmtilesUrl, options?)
 ```
 
 | Parameter | Type | Description |
 |-----------|------|-------------|
 | `pmtilesUrl` | string | URL to the PMTiles file |
-| `options.cacheSize` | number | Maximum tiles to cache (default: 64) |
+| `options.cacheMaxFeatures` | number | Maximum features to cache |
 
 #### Methods
 
 | Method | Returns | Description |
 |--------|---------|-------------|
 | `getCorrections(z, x, y)` | `Promise<Object>` | Get correction features for a tile. Supports overzoom beyond zoom 14. |
-| `fixTile(corrections, rasterTile, layerConfig, zoom, tileSize?)` | `Promise<ArrayBuffer>` | Apply corrections to a raster tile and return corrected PNG. |
+| `fixTile(corrections, rasterTile, layerConfig, zoom)` | `Promise<ArrayBuffer>` | Apply corrections to a raster tile and return corrected PNG. Tile size is derived from the image. |
 | `fetchAndFixTile(tileUrl, z, x, y, layerConfig, options?)` | `Promise<Object>` | Fetch a tile, apply corrections, and return result. See below. |
 | `getSource()` | `PMTiles` | Get the underlying PMTiles source object |
 | `clearCache()` | `void` | Clear the tile cache |
@@ -64,7 +70,6 @@ new BoundaryCorrector(pmtilesUrl, options?)
 
 ```javascript
 const result = await corrector.fetchAndFixTile(tileUrl, z, x, y, layerConfig, {
-  tileSize: 256,        // Tile size in pixels (default: 256)
   signal: abortSignal,  // AbortSignal for cancellation
   mode: 'cors',         // Fetch mode
 });

package/dist/index.cjs

@@ -3,6 +3,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,12 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/index.js
 var index_exports = {};
 __export(index_exports, {
-  BoundaryCorrector: () => BoundaryCorrector,
   MIN_LINE_WIDTH: () => MIN_LINE_WIDTH,
+  TileFetchError: () => TileFetchError,
+  TileFixer: () => TileFixer,
   getLineWidth: () => getLineWidth
 });
 module.exports = __toCommonJS(index_exports);
@@ -2052,10 +2055,16 @@ function writeUtf8(buf, str, pos) {
 }
 
 // src/corrections.js
-var DEFAULT_CACHE_SIZE = 64;
 function toIndex(z2, x2, y) {
   return `${x2}:${y}:${z2}`;
 }
+function countFeatures(corrections) {
+  let count = 0;
+  for (const features of Object.values(corrections)) {
+    count += features.length;
+  }
+  return count;
+}
 function parseTile(buffer) {
   const tile = new VectorTile(new Pbf(buffer));
   const result = {};
@@ -2104,16 +2113,19 @@ var CorrectionsSource = class {
   /**
    * @param {string} pmtilesUrl - URL to the PMTiles file
    * @param {Object} [options] - Options
-   * @param {number} [options.cacheSize=64] - Maximum number of tiles to cache
+   * @param {number} [options.cacheMaxFeatures=10000] - Maximum number of features to cache
    * @param {number} [options.maxDataZoom] - Maximum zoom level in PMTiles (auto-detected if not provided)
    */
   constructor(pmtilesUrl, options = {}) {
     this.pmtilesUrl = pmtilesUrl;
     this.pmtiles = new x(pmtilesUrl);
-    this.cacheSize = options.cacheSize ?? DEFAULT_CACHE_SIZE;
+    this.cacheMaxFeatures = options.cacheMaxFeatures;
     this.maxDataZoom = options.maxDataZoom;
     this.cache = /* @__PURE__ */ new Map();
     this.inflight = /* @__PURE__ */ new Map();
+    this.cachedFeatureCount = 0;
+    this.emptyKeys = /* @__PURE__ */ new Set();
+    this.nonEmptyKeys = /* @__PURE__ */ new Set();
   }
   /**
    * Get the PMTiles source object.
@@ -2128,6 +2140,35 @@ var CorrectionsSource = class {
   clearCache() {
     this.cache.clear();
     this.inflight.clear();
+    this.cachedFeatureCount = 0;
+    this.emptyKeys.clear();
+    this.nonEmptyKeys.clear();
+  }
+  /**
+   * Evict cache entries to stay under the feature limit.
+   * Empty entries are evicted first (cheap to re-fetch from PMTiles directory cache).
+   * Within each category, evicts LRU (least recently used) entries.
+   * @private
+   */
+  _evictIfNeeded() {
+    while (this.cachedFeatureCount > this.cacheMaxFeatures && this.cache.size > 1) {
+      const targetSet = this.emptyKeys.size > 0 ? this.emptyKeys : this.nonEmptyKeys;
+      if (targetSet.size === 0) break;
+      let evictKey = void 0;
+      let minUsed = Infinity;
+      for (const key of targetSet) {
+        const entry = this.cache.get(key);
+        if (entry && entry.used < minUsed) {
+          minUsed = entry.used;
+          evictKey = key;
+        }
+      }
+      if (!evictKey) break;
+      const evicted = this.cache.get(evictKey);
+      this.cachedFeatureCount -= evicted.featureCount;
+      targetSet.delete(evictKey);
+      this.cache.delete(evictKey);
+    }
   }
   /**
    * Auto-detect max zoom from PMTiles metadata.
@@ -2173,7 +2214,11 @@ var CorrectionsSource = class {
         } else {
           data = {};
         }
-        this.cache.set(idx, { used: performance.now(), data });
+        const featureCount = countFeatures(data);
+        const empty = featureCount === 0;
+        this.cache.set(idx, { used: performance.now(), data, featureCount, empty });
+        this.cachedFeatureCount += featureCount;
+        (empty ? this.emptyKeys : this.nonEmptyKeys).add(idx);
         const ifentry2 = this.inflight.get(idx);
         if (ifentry2) {
           for (const waiter of ifentry2) {
@@ -2182,19 +2227,7 @@ var CorrectionsSource = class {
         }
         this.inflight.delete(idx);
         resolve(data);
-        if (this.cache.size > this.cacheSize) {
-          let minUsed = Infinity;
-          let minKey = void 0;
-          this.cache.forEach((value, key) => {
-            if (value.used < minUsed) {
-              minUsed = value.used;
-              minKey = key;
-            }
-          });
-          if (minKey) {
-            this.cache.delete(minKey);
-          }
-        }
+        this._evictIfNeeded();
       }).catch((e) => {
         const ifentry2 = this.inflight.get(idx);
         if (ifentry2) {
@@ -2235,6 +2268,33 @@ var CorrectionsSource = class {
 };
 
 // src/index.js
+var TileFetchError = class _TileFetchError extends Error {
+  /**
+   * @param {number} status - HTTP status code
+   * @param {string} [url] - The URL that failed
+   * @param {string} [body] - Response body text
+   */
+  constructor(status, url, body) {
+    super(`Tile fetch failed: ${status}`);
+    this.name = "TileFetchError";
+    this.status = status;
+    this.url = url;
+    this.body = body;
+  }
+  /**
+   * Create a TileFetchError from a failed Response.
+   * @param {Response} response - The failed fetch response
+   * @returns {Promise<TileFetchError>}
+   */
+  static async fromResponse(response) {
+    let body;
+    try {
+      body = await response.text();
+    } catch {
+    }
+    return new _TileFetchError(response.status, response.url, body);
+  }
+};
 var MIN_LINE_WIDTH = 0.5;
 function getLineWidth(zoom, lineWidthStops) {
   const zooms = Object.keys(lineWidthStops).map(Number).sort((a, b2) => a - b2);
@@ -2452,11 +2512,34 @@ function drawFeatures(ctx, features, color, lineWidth, tileSize, dashArray, alph
     ctx.globalAlpha = prevAlpha;
   }
 }
-var BoundaryCorrector = class {
+var _TileFixer = class _TileFixer {
+  /**
+   * Set the default maximum features to cache for new TileFixer instances.
+   * @param {number} maxFeatures - Maximum features to cache
+   */
+  static setDefaultCacheMaxFeatures(maxFeatures) {
+    _TileFixer._defaultCacheMaxFeatures = maxFeatures;
+  }
+  /**
+   * Get or create a TileFixer instance for a given PMTiles URL.
+   * Reuses existing instances for the same URL.
+   * @param {string} pmtilesUrl - URL to the PMTiles file
+   * @returns {TileFixer}
+   */
+  static getOrCreate(pmtilesUrl) {
+    let instance = _TileFixer._instances.get(pmtilesUrl);
+    if (!instance) {
+      instance = new _TileFixer(pmtilesUrl, {
+        cacheMaxFeatures: _TileFixer._defaultCacheMaxFeatures
+      });
+      _TileFixer._instances.set(pmtilesUrl, instance);
+    }
+    return instance;
+  }
   /**
    * @param {string} pmtilesUrl - URL to the PMTiles file
    * @param {Object} [options] - Options
-   * @param {number} [options.cacheSize=64] - Maximum number of tiles to cache
+   * @param {number} [options.cacheMaxFeatures] - Maximum number of features to cache
    * @param {number} [options.maxDataZoom] - Maximum zoom level in PMTiles (auto-detected if not provided)
    */
   constructor(pmtilesUrl, options = {}) {
@@ -2493,10 +2576,9 @@ var BoundaryCorrector = class {
    * @param {ArrayBuffer} rasterTile - The original raster tile as ArrayBuffer
    * @param {Object} layerConfig - Layer configuration with colors and styles
    * @param {number} zoom - Current zoom level
-   * @param {number} [tileSize=256] - Size of the tile in pixels
    * @returns {Promise<ArrayBuffer>} The corrected tile as ArrayBuffer (PNG)
    */
-  async fixTile(corrections, rasterTile, layerConfig, zoom, tileSize = 256) {
+  async fixTile(corrections, rasterTile, layerConfig, zoom) {
     const {
       startZoom = 0,
       zoomThreshold,
@@ -2520,13 +2602,14 @@ var BoundaryCorrector = class {
     const useOsm = zoom >= zoomThreshold;
     const addLayerName = useOsm ? "to-add-osm" : "to-add-ne";
     const delLayerName = useOsm ? "to-del-osm" : "to-del-ne";
+    const blob = new Blob([rasterTile]);
+    const imageBitmap = await createImageBitmap(blob);
+    const tileSize = imageBitmap.width;
     if (!this._canvas || this._canvas.width !== tileSize) {
       this._canvas = new OffscreenCanvas(tileSize, tileSize);
     }
     const canvas = this._canvas;
     const ctx = canvas.getContext("2d", { willReadFrequently: true });
-    const blob = new Blob([rasterTile]);
-    const imageBitmap = await createImageBitmap(blob);
     ctx.drawImage(imageBitmap, 0, 0, tileSize, tileSize);
     const baseLineWidth = getLineWidth(zoom, lineWidthStops);
     const maxWidthFraction = activeLineStyles.length > 0 ? Math.max(...activeLineStyles.map((s) => s.widthFraction ?? 1)) : 1;
@@ -2563,24 +2646,24 @@ var BoundaryCorrector = class {
    * @param {number} y - Tile Y coordinate
    * @param {Object} layerConfig - Layer configuration with colors and styles
    * @param {Object} [options] - Fetch options
-   * @param {number} [options.tileSize=256] - Tile size in pixels
    * @param {AbortSignal} [options.signal] - Abort signal for fetch
    * @param {RequestMode} [options.mode] - Fetch mode (e.g., 'cors')
+   * @param {boolean} [options.fallbackOnCorrectionFailure=true] - Return original tile if corrections fail
    * @returns {Promise<{data: ArrayBuffer, wasFixed: boolean}>}
    */
   async fetchAndFixTile(tileUrl, z2, x2, y, layerConfig, options = {}) {
-    const { tileSize = 256, signal, mode } = options;
+    const { signal, mode, fallbackOnCorrectionFailure = true } = options;
     const fetchOptions = {};
     if (signal) fetchOptions.signal = signal;
     if (mode) fetchOptions.mode = mode;
     if (!layerConfig) {
       const response = await fetch(tileUrl, fetchOptions);
-      if (!response.ok) throw new Error(`Tile fetch failed: ${response.status}`);
+      if (!response.ok) throw await TileFetchError.fromResponse(response);
       return { data: await response.arrayBuffer(), wasFixed: false };
     }
     const [tileResult, correctionsResult] = await Promise.allSettled([
-      fetch(tileUrl, fetchOptions).then((r) => {
-        if (!r.ok) throw new Error(`Tile fetch failed: ${r.status}`);
+      fetch(tileUrl, fetchOptions).then(async (r) => {
+        if (!r.ok) throw await TileFetchError.fromResponse(r);
         return r.arrayBuffer();
       }),
       this.getCorrections(z2, x2, y)
@@ -2594,13 +2677,21 @@ var BoundaryCorrector = class {
     const tileData = tileResult.value;
     const correctionsFailed = correctionsResult.status === "rejected";
     const correctionsError = correctionsFailed ? correctionsResult.reason : null;
+    if (correctionsFailed && !fallbackOnCorrectionFailure) {
+      throw correctionsError;
+    }
     const corrections = correctionsResult.status === "fulfilled" ? correctionsResult.value : {};
     const hasCorrections = Object.values(corrections).some((arr) => arr && arr.length > 0);
     if (!hasCorrections) {
       return { data: tileData, wasFixed: false, correctionsFailed, correctionsError };
     }
-    const fixedData = await this.fixTile(corrections, tileData, layerConfig, z2, tileSize);
+    const fixedData = await this.fixTile(corrections, tileData, layerConfig, z2);
     return { data: fixedData, wasFixed: true, correctionsFailed: false, correctionsError: null };
   }
 };
+/** @type {Map<string, TileFixer>} */
+__publicField(_TileFixer, "_instances", /* @__PURE__ */ new Map());
+/** @type {number} */
+__publicField(_TileFixer, "_defaultCacheMaxFeatures", 25e3);
+var TileFixer = _TileFixer;
 //# sourceMappingURL=index.cjs.map