@india-boundary-corrector/tilefixer 0.0.3 → 0.0.5

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,15 @@ 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,
+  buildFetchOptions: () => buildFetchOptions,
   getLineWidth: () => getLineWidth
 });
 module.exports = __toCommonJS(index_exports);
@@ -2052,10 +2056,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 +2114,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 +2141,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.
@@ -2148,10 +2190,11 @@ var CorrectionsSource = class {
    * @param {number} z
    * @param {number} x
    * @param {number} y
+   * @param {AbortSignal} [signal] - Optional abort signal
    * @returns {Promise<Object<string, Array>>}
    * @private
    */
-  async _fetchTile(z2, x2, y) {
+  async _fetchTile(z2, x2, y, signal) {
     const idx = toIndex(z2, x2, y);
     return new Promise((resolve, reject) => {
       const entry = this.cache.get(idx);
@@ -2166,14 +2209,18 @@ var CorrectionsSource = class {
         return;
       }
       this.inflight.set(idx, []);
-      this.pmtiles.getZxy(z2, x2, y).then((result) => {
+      this.pmtiles.getZxy(z2, x2, y, signal).then((result) => {
         let data;
         if (result) {
           data = parseTile(result.data);
         } 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 +2229,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) {
@@ -2213,9 +2248,10 @@ var CorrectionsSource = class {
    * @param {number} z - Zoom level
    * @param {number} x - Tile X coordinate
    * @param {number} y - Tile Y coordinate
+   * @param {AbortSignal} [signal] - Optional abort signal
    * @returns {Promise<Object<string, Array>>} Map of layer name to array of features
    */
-  async get(z2, x2, y) {
+  async get(z2, x2, y, signal) {
     const maxDataZoom = await this._getMaxDataZoom();
     if (z2 > maxDataZoom) {
       const zoomDiff = z2 - maxDataZoom;
@@ -2224,18 +2260,64 @@ var CorrectionsSource = class {
       const parentY = Math.floor(y / scale);
       const offsetX = x2 % scale;
       const offsetY = y % scale;
-      const corrections = await this._fetchTile(maxDataZoom, parentX, parentY);
+      const corrections = await this._fetchTile(maxDataZoom, parentX, parentY, signal);
       if (Object.keys(corrections).length > 0) {
         return transformForOverzoom(corrections, scale, offsetX, offsetY);
       }
       return {};
     }
-    return await this._fetchTile(z2, x2, y);
+    return await this._fetchTile(z2, x2, y, signal);
   }
 };
 
 // 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;
+var DEFAULT_TILE_EXTENT = 4096;
+var DEFAULT_LINE_WIDTH = 1;
+function buildFetchOptions(crossOrigin, referrerPolicy) {
+  const options = {};
+  if (crossOrigin === "use-credentials") {
+    options.mode = "cors";
+    options.credentials = "include";
+  } else if (crossOrigin === "anonymous" || crossOrigin === "" || crossOrigin === true) {
+    options.mode = "cors";
+    options.credentials = "omit";
+  } else {
+    options.mode = "cors";
+    options.credentials = "same-origin";
+  }
+  if (referrerPolicy) {
+    options.referrerPolicy = referrerPolicy;
+  }
+  return options;
+}
 function getLineWidth(zoom, lineWidthStops) {
   const zooms = Object.keys(lineWidthStops).map(Number).sort((a, b2) => a - b2);
   if (lineWidthStops[zoom] !== void 0) {
@@ -2267,7 +2349,7 @@ function getLineWidth(zoom, lineWidthStops) {
       return w1 + t * (w2 - w1);
     }
   }
-  return 1;
+  return DEFAULT_LINE_WIDTH;
 }
 function getFeaturesBoundingBox(features, tileSize, padding = 0) {
   let minX = Infinity, minY = Infinity;
@@ -2421,6 +2503,14 @@ function extendFeaturesEnds(features, extensionLength) {
     return { ...feature, geometry: newGeometry };
   });
 }
+function extendFeaturesByFactor(features, extensionFactor, delLineWidth, tileSize) {
+  if (!features || features.length === 0 || extensionFactor <= 0) {
+    return features;
+  }
+  const extent = features[0]?.extent || DEFAULT_TILE_EXTENT;
+  const extensionLength = delLineWidth * extensionFactor / tileSize * extent;
+  return extendFeaturesEnds(features, extensionLength);
+}
 function drawFeatures(ctx, features, color, lineWidth, tileSize, dashArray, alpha) {
   const prevAlpha = ctx.globalAlpha;
   if (alpha !== void 0) {
@@ -2452,15 +2542,39 @@ 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 = {}) {
     this.correctionsSource = new CorrectionsSource(pmtilesUrl, options);
+    this._canvas = null;
     this._maskCanvas = null;
   }
   /**
@@ -2482,10 +2596,11 @@ var BoundaryCorrector = class {
    * @param {number} z - Zoom level
    * @param {number} x - Tile X coordinate
    * @param {number} y - Tile Y coordinate
+   * @param {AbortSignal} [signal] - Optional abort signal
    * @returns {Promise<Object<string, Array>>} Map of layer name to array of features
    */
-  async getCorrections(z2, x2, y) {
-    return await this.correctionsSource.get(z2, x2, y);
+  async getCorrections(z2, x2, y, signal) {
+    return await this.correctionsSource.get(z2, x2, y, signal);
   }
   /**
    * Apply corrections to a raster tile.
@@ -2493,10 +2608,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,16 +2634,17 @@ 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;
+    const maxWidthFraction = activeLineStyles.length > 0 ? Math.max(...activeLineStyles.map((s) => s.widthFraction)) : 1;
     const delLineWidth = baseLineWidth * maxWidthFraction * delWidthFactor;
     const delFeatures = corrections[delLayerName] || [];
     if (delFeatures.length > 0) {
@@ -2540,14 +2655,11 @@ var BoundaryCorrector = class {
     }
     let addFeatures = corrections[addLayerName] || [];
     if (addFeatures.length > 0 && activeLineStyles.length > 0) {
-      const extensionFactor = layerConfig.lineExtensionFactor ?? 0.5;
-      if (extensionFactor > 0 && delFeatures.length > 0) {
-        const extent = addFeatures[0]?.extent || 4096;
-        const extensionLength = delLineWidth * extensionFactor / tileSize * extent;
-        addFeatures = extendFeaturesEnds(addFeatures, extensionLength);
+      if (delFeatures.length > 0) {
+        addFeatures = extendFeaturesByFactor(addFeatures, layerConfig.lineExtensionFactor, delLineWidth, tileSize);
       }
       for (const style of activeLineStyles) {
-        const { color, widthFraction = 1, dashArray, alpha = 1 } = style;
+        const { color, widthFraction, dashArray, alpha } = style;
         const lineWidth = baseLineWidth * widthFraction;
         drawFeatures(ctx, addFeatures, color, lineWidth, tileSize, dashArray, alpha);
       }
@@ -2562,45 +2674,51 @@ var BoundaryCorrector = class {
    * @param {number} x - Tile X coordinate
    * @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 {Object} [fetchOptions] - Fetch options passed to fetch()
+   * @param {AbortSignal} [fetchOptions.signal] - Abort signal for fetch
+   * @param {RequestMode} [fetchOptions.mode] - Fetch mode (e.g., 'cors')
+   * @param {RequestCredentials} [fetchOptions.credentials] - Fetch credentials (e.g., 'omit', 'include')
+   * @param {string} [fetchOptions.referrer] - Referrer URL or empty string for none
+   * @param {ReferrerPolicy} [fetchOptions.referrerPolicy] - Referrer policy (e.g., 'no-referrer', 'origin')
+   * @param {boolean} [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 fetchOptions = {};
-    if (signal) fetchOptions.signal = signal;
-    if (mode) fetchOptions.mode = mode;
+  async fetchAndFixTile(tileUrl, z2, x2, y, layerConfig, fetchOptions = {}, fallbackOnCorrectionFailure = true) {
+    const { signal } = fetchOptions;
     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)
+      this.getCorrections(z2, x2, y, signal)
     ]);
-    if (signal?.aborted) {
-      throw new DOMException("Aborted", "AbortError");
-    }
+    signal?.throwIfAborted();
     if (tileResult.status === "rejected") {
       throw tileResult.reason;
     }
     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