@india-boundary-corrector/leaflet-layer 0.0.4 → 0.0.5

package/dist/index.cjs

@@ -151,7 +151,166 @@ function templateToTemplateRegex(template) {
   });
   return new RegExp("^" + pattern + "(\\?.*)?$", "i");
 }
+function isValidColor(color) {
+  if (typeof color !== "string" || !color.trim()) return false;
+  if (typeof CSS !== "undefined" && CSS.supports) {
+    return CSS.supports("color", color);
+  }
+  const trimmed = color.trim().toLowerCase();
+  if (/^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/.test(trimmed)) return true;
+  if (/^(rgb|hsl)a?\(/.test(trimmed)) return true;
+  if (/^[a-z]+$/.test(trimmed)) return true;
+  return false;
+}
+var LineStyle = class _LineStyle {
+  /**
+   * Validate a LineStyle configuration object.
+   * @param {Object} obj - The object to validate
+   * @param {number} [index] - Optional index for error messages (when validating in an array)
+   * @throws {Error} If validation fails
+   */
+  static validateJSON(obj, index) {
+    const prefix = index !== void 0 ? `lineStyles[${index}]` : "LineStyle";
+    if (!obj || typeof obj !== "object") {
+      throw new Error(`${prefix}: must be an object`);
+    }
+    if (!obj.color || typeof obj.color !== "string") {
+      throw new Error(`${prefix}: color must be a non-empty string`);
+    }
+    if (!isValidColor(obj.color)) {
+      throw new Error(`${prefix}: color "${obj.color}" is not a valid CSS color`);
+    }
+    if (obj.widthFraction !== void 0 && (typeof obj.widthFraction !== "number" || obj.widthFraction <= 0)) {
+      throw new Error(`${prefix}: widthFraction must be a positive number`);
+    }
+    if (obj.dashArray !== void 0 && !Array.isArray(obj.dashArray)) {
+      throw new Error(`${prefix}: dashArray must be an array`);
+    }
+    if (obj.alpha !== void 0 && (typeof obj.alpha !== "number" || obj.alpha < 0 || obj.alpha > 1)) {
+      throw new Error(`${prefix}: alpha must be a number between 0 and 1`);
+    }
+    if (obj.startZoom !== void 0 && (typeof obj.startZoom !== "number" || obj.startZoom < 0)) {
+      throw new Error(`${prefix}: startZoom must be a non-negative number`);
+    }
+    if (obj.endZoom !== void 0 && (typeof obj.endZoom !== "number" || obj.endZoom < 0)) {
+      throw new Error(`${prefix}: endZoom must be a non-negative number`);
+    }
+  }
+  /**
+   * @param {Object} options
+   * @param {string} options.color - CSS color string
+   * @param {number} [options.widthFraction=1.0] - Multiplier for base line width
+   * @param {number[]} [options.dashArray] - Dash pattern for dashed lines
+   * @param {number} [options.alpha=1.0] - Opacity (0-1)
+   * @param {number} [options.startZoom] - Minimum zoom level for this style
+   * @param {number} [options.endZoom=Infinity] - Maximum zoom level for this style
+   */
+  constructor({ color, widthFraction = 1, dashArray, alpha = 1, startZoom, endZoom = Infinity }) {
+    this.color = color;
+    this.widthFraction = widthFraction;
+    this.dashArray = dashArray;
+    this.alpha = alpha;
+    this.startZoom = startZoom;
+    this.endZoom = endZoom;
+  }
+  /**
+   * Check if this style is active at the given zoom level.
+   * @param {number} z - Zoom level
+   * @returns {boolean}
+   */
+  isActiveAtZoom(z2) {
+    return z2 >= this.startZoom && z2 <= this.endZoom;
+  }
+  /**
+   * Serialize to plain object.
+   * @returns {Object}
+   */
+  toJSON() {
+    const obj = { color: this.color };
+    if (this.widthFraction !== 1) obj.widthFraction = this.widthFraction;
+    if (this.dashArray) obj.dashArray = this.dashArray;
+    if (this.alpha !== 1) obj.alpha = this.alpha;
+    if (this.startZoom !== void 0) obj.startZoom = this.startZoom;
+    if (this.endZoom !== Infinity) obj.endZoom = this.endZoom;
+    return obj;
+  }
+  /**
+   * Create from plain object with validation.
+   * @param {Object} obj
+   * @param {number} [defaultStartZoom=0] - Default startZoom if not specified
+   * @param {number} [index] - Optional index for error messages
+   * @returns {LineStyle}
+   */
+  static fromJSON(obj, defaultStartZoom = 0, index) {
+    _LineStyle.validateJSON(obj, index);
+    return new _LineStyle({
+      ...obj,
+      startZoom: obj.startZoom ?? defaultStartZoom
+    });
+  }
+};
 var LayerConfig = class _LayerConfig {
+  /**
+   * Validate a LayerConfig configuration object.
+   * Also validates all lineStyles within the config.
+   * @param {Object} obj - The object to validate
+   * @throws {Error} If validation fails
+   */
+  static validateJSON(obj) {
+    if (!obj || typeof obj !== "object") {
+      throw new Error("LayerConfig: must be an object");
+    }
+    if (!obj.id || typeof obj.id !== "string") {
+      throw new Error("LayerConfig: id must be a non-empty string");
+    }
+    if (obj.id.includes("/")) {
+      throw new Error(`LayerConfig: id cannot contain slashes: "${obj.id}"`);
+    }
+    const id = obj.id;
+    if (obj.startZoom !== void 0 && (typeof obj.startZoom !== "number" || obj.startZoom < 0)) {
+      throw new Error(`LayerConfig "${id}": startZoom must be a non-negative number`);
+    }
+    if (obj.zoomThreshold !== void 0 && (typeof obj.zoomThreshold !== "number" || obj.zoomThreshold < 0)) {
+      throw new Error(`LayerConfig "${id}": zoomThreshold must be a non-negative number`);
+    }
+    const startZoom = obj.startZoom ?? 0;
+    const zoomThreshold = obj.zoomThreshold ?? 5;
+    if (startZoom > zoomThreshold) {
+      throw new Error(`LayerConfig "${id}": startZoom (${startZoom}) must be <= zoomThreshold (${zoomThreshold})`);
+    }
+    if (obj.lineWidthStops !== void 0) {
+      if (!obj.lineWidthStops || typeof obj.lineWidthStops !== "object" || Array.isArray(obj.lineWidthStops)) {
+        throw new Error(`LayerConfig "${id}": lineWidthStops must be an object`);
+      }
+      const stopKeys = Object.keys(obj.lineWidthStops);
+      if (stopKeys.length < 2) {
+        throw new Error(`LayerConfig "${id}": lineWidthStops must have at least 2 entries`);
+      }
+      for (const key of stopKeys) {
+        const zoom = Number(key);
+        if (!Number.isInteger(zoom) || zoom < 0) {
+          throw new Error(`LayerConfig "${id}": lineWidthStops keys must be non-negative integers, got "${key}"`);
+        }
+        if (typeof obj.lineWidthStops[key] !== "number" || obj.lineWidthStops[key] <= 0) {
+          throw new Error(`LayerConfig "${id}": lineWidthStops values must be positive numbers`);
+        }
+      }
+    }
+    if (obj.lineStyles !== void 0) {
+      if (!Array.isArray(obj.lineStyles) || obj.lineStyles.length === 0) {
+        throw new Error(`LayerConfig "${id}": lineStyles must be a non-empty array`);
+      }
+      for (let i2 = 0; i2 < obj.lineStyles.length; i2++) {
+        LineStyle.validateJSON(obj.lineStyles[i2], i2);
+      }
+    }
+    if (obj.delWidthFactor !== void 0 && (typeof obj.delWidthFactor !== "number" || obj.delWidthFactor <= 0)) {
+      throw new Error(`LayerConfig "${id}": delWidthFactor must be a positive number`);
+    }
+    if (obj.lineExtensionFactor !== void 0 && (typeof obj.lineExtensionFactor !== "number" || obj.lineExtensionFactor < 0)) {
+      throw new Error(`LayerConfig "${id}": lineExtensionFactor must be a non-negative number`);
+    }
+  }
   constructor({
     id,
     startZoom = 0,
@@ -174,66 +333,30 @@ var LayerConfig = class _LayerConfig {
     // Set to 0 to disable extension
     lineExtensionFactor = 0.5
   }) {
-    if (!id || typeof id !== "string") {
-      throw new Error("LayerConfig requires a non-empty string id");
-    }
-    if (id.includes("/")) {
-      throw new Error(`LayerConfig id cannot contain slashes: "${id}"`);
-    }
     this.id = id;
     this.startZoom = startZoom;
     this.zoomThreshold = zoomThreshold;
-    if (startZoom > zoomThreshold) {
-      throw new Error(`LayerConfig "${id}": startZoom (${startZoom}) must be <= zoomThreshold (${zoomThreshold})`);
-    }
     const templates = Array.isArray(tileUrlTemplates) ? tileUrlTemplates : tileUrlTemplates ? [tileUrlTemplates] : [];
     this.tileUrlTemplates = templates;
     this._compiledPatterns = templates.map((t) => templateToRegex(t));
     this._templatePatterns = templates.map((t) => templateToTemplateRegex(t));
-    if (!lineWidthStops || typeof lineWidthStops !== "object" || Array.isArray(lineWidthStops)) {
-      throw new Error(`LayerConfig "${id}": lineWidthStops must be an object`);
-    }
-    const stopKeys = Object.keys(lineWidthStops);
-    if (stopKeys.length < 2) {
-      throw new Error(`LayerConfig "${id}": lineWidthStops must have at least 2 entries`);
-    }
-    for (const key of stopKeys) {
-      const zoom = Number(key);
-      if (!Number.isInteger(zoom) || zoom < 0) {
-        throw new Error(`LayerConfig "${id}": lineWidthStops keys must be non-negative integers, got "${key}"`);
-      }
-      if (typeof lineWidthStops[key] !== "number" || lineWidthStops[key] <= 0) {
-        throw new Error(`LayerConfig "${id}": lineWidthStops values must be positive numbers`);
-      }
-    }
     this.lineWidthStops = lineWidthStops;
-    if (!Array.isArray(lineStyles) || lineStyles.length === 0) {
-      throw new Error(`LayerConfig "${id}": lineStyles must be a non-empty array`);
-    }
-    for (let i2 = 0; i2 < lineStyles.length; i2++) {
-      const style = lineStyles[i2];
-      if (!style || typeof style !== "object") {
-        throw new Error(`LayerConfig "${id}": lineStyles[${i2}] must be an object`);
-      }
-      if (!style.color || typeof style.color !== "string") {
-        throw new Error(`LayerConfig "${id}": lineStyles[${i2}].color must be a non-empty string`);
-      }
-    }
-    this.lineStyles = lineStyles.map((style) => ({
-      ...style,
-      startZoom: style.startZoom ?? startZoom,
-      endZoom: style.endZoom ?? Infinity
-    }));
+    this.lineStyles = lineStyles.map(
+      (style) => style instanceof LineStyle ? style : new LineStyle({
+        ...style,
+        startZoom: style.startZoom ?? startZoom
+      })
+    );
     this.delWidthFactor = delWidthFactor;
     this.lineExtensionFactor = lineExtensionFactor;
   }
   /**
    * Get line styles active at a given zoom level
    * @param {number} z - Zoom level
-   * @returns {Array<{color: string, widthFraction?: number, dashArray?: number[]}>}
+   * @returns {LineStyle[]}
    */
   getLineStylesForZoom(z2) {
-    return this.lineStyles.filter((style) => z2 >= style.startZoom && z2 <= style.endZoom);
+    return this.lineStyles.filter((style) => style.isActiveAtZoom(z2));
   }
   /**
    * Check if this config matches the given template URLs (with {z}/{x}/{y} placeholders)
@@ -296,17 +419,19 @@ var LayerConfig = class _LayerConfig {
       zoomThreshold: this.zoomThreshold,
       tileUrlTemplates: this.tileUrlTemplates,
       lineWidthStops: this.lineWidthStops,
-      lineStyles: this.lineStyles,
+      lineStyles: this.lineStyles.map((s) => s.toJSON()),
       delWidthFactor: this.delWidthFactor,
       lineExtensionFactor: this.lineExtensionFactor
     };
   }
   /**
-   * Create a LayerConfig from a plain object (e.g., from postMessage)
+   * Create a LayerConfig from a plain object with validation.
    * @param {Object} obj
    * @returns {LayerConfig}
+   * @throws {Error} If validation fails
    */
   static fromJSON(obj) {
+    _LayerConfig.validateJSON(obj);
     return new _LayerConfig(obj);
   }
 };
@@ -2554,10 +2679,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, x22, y) {
+  async _fetchTile(z2, x22, y, signal) {
     const idx = toIndex(z2, x22, y);
     return new Promise((resolve, reject) => {
       const entry = this.cache.get(idx);
@@ -2572,7 +2698,7 @@ var CorrectionsSource = class {
         return;
       }
       this.inflight.set(idx, []);
-      this.pmtiles.getZxy(z2, x22, y).then((result) => {
+      this.pmtiles.getZxy(z2, x22, y, signal).then((result) => {
         let data;
         if (result) {
           data = parseTile(result.data);
@@ -2611,9 +2737,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, x22, y) {
+  async get(z2, x22, y, signal) {
     const maxDataZoom = await this._getMaxDataZoom();
     if (z2 > maxDataZoom) {
       const zoomDiff = z2 - maxDataZoom;
@@ -2622,13 +2749,13 @@ var CorrectionsSource = class {
       const parentY = Math.floor(y / scale);
       const offsetX = x22 % 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, x22, y);
+    return await this._fetchTile(z2, x22, y, signal);
   }
 };
 var TileFetchError = class _TileFetchError extends Error {
@@ -2659,6 +2786,25 @@ var TileFetchError = class _TileFetchError extends Error {
   }
 };
 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) {
@@ -2690,7 +2836,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;
@@ -2844,6 +2990,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) {
@@ -2907,6 +3061,7 @@ var _TileFixer = class _TileFixer2 {
    */
   constructor(pmtilesUrl, options = {}) {
     this.correctionsSource = new CorrectionsSource(pmtilesUrl, options);
+    this._canvas = null;
     this._maskCanvas = null;
   }
   /**
@@ -2928,10 +3083,11 @@ var _TileFixer = class _TileFixer2 {
    * @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, x22, y) {
-    return await this.correctionsSource.get(z2, x22, y);
+  async getCorrections(z2, x22, y, signal) {
+    return await this.correctionsSource.get(z2, x22, y, signal);
   }
   /**
    * Apply corrections to a raster tile.
@@ -2975,7 +3131,7 @@ var _TileFixer = class _TileFixer2 {
     const ctx = canvas.getContext("2d", { willReadFrequently: true });
     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) {
@@ -2986,14 +3142,11 @@ var _TileFixer = class _TileFixer2 {
     }
     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);
       }
@@ -3008,17 +3161,17 @@ var _TileFixer = class _TileFixer2 {
    * @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 {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
+   * @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, x22, y, layerConfig, options = {}) {
-    const { signal, mode, fallbackOnCorrectionFailure = true } = options;
-    const fetchOptions = {};
-    if (signal) fetchOptions.signal = signal;
-    if (mode) fetchOptions.mode = mode;
+  async fetchAndFixTile(tileUrl, z2, x22, y, layerConfig, fetchOptions = {}, fallbackOnCorrectionFailure = true) {
+    const { signal } = fetchOptions;
     if (!layerConfig) {
       const response = await fetch(tileUrl, fetchOptions);
       if (!response.ok) throw await TileFetchError.fromResponse(response);
@@ -3029,11 +3182,9 @@ var _TileFixer = class _TileFixer2 {
         if (!r.ok) throw await TileFetchError.fromResponse(r);
         return r.arrayBuffer();
       }),
-      this.getCorrections(z2, x22, y)
+      this.getCorrections(z2, x22, y, signal)
     ]);
-    if (signal?.aborted) {
-      throw new DOMException("Aborted", "AbortError");
-    }
+    signal?.throwIfAborted();
     if (tileResult.status === "rejected") {
       throw tileResult.reason;
     }
@@ -3087,6 +3238,9 @@ function extendLeaflet(L2) {
     },
     createTile: function(coords, done) {
       const tile = document.createElement("img");
+      const controller = new AbortController();
+      const signal = controller.signal;
+      tile.cancel = () => controller.abort();
       tile.alt = "";
       if (this.options.crossOrigin || this.options.crossOrigin === "") {
         tile.crossOrigin = this.options.crossOrigin === true ? "" : this.options.crossOrigin;
@@ -3105,13 +3259,16 @@ function extendLeaflet(L2) {
       const x3 = coords.x;
       const y = coords.y;
       const fallbackOnCorrectionFailure = this.options.fallbackOnCorrectionFailure;
-      this._tileFixer.fetchAndFixTile(tileUrl, z2, x3, y, this._layerConfig, { fallbackOnCorrectionFailure }).then(({ data, correctionsFailed, correctionsError }) => {
+      const fetchOptions = buildFetchOptions(this.options.crossOrigin, this.options.referrerPolicy);
+      fetchOptions.signal = signal;
+      this._tileFixer.fetchAndFixTile(tileUrl, z2, x3, y, this._layerConfig, fetchOptions, fallbackOnCorrectionFailure).then(({ data, correctionsFailed, correctionsError }) => {
         if (correctionsFailed) {
           console.warn("[L.TileLayer.IndiaBoundaryCorrected] Corrections fetch failed:", correctionsError);
           this.fire("correctionerror", { error: correctionsError, coords: { z: z2, x: x3, y }, tileUrl });
         }
         const blob = new Blob([data]);
         tile.src = URL.createObjectURL(blob);
+        tile.cancel = void 0;
         tile.onload = () => {
           URL.revokeObjectURL(tile.src);
           done(null, tile);
@@ -3121,11 +3278,19 @@ function extendLeaflet(L2) {
           done(e, tile);
         };
       }).catch((err2) => {
-        console.warn("[L.TileLayer.IndiaBoundaryCorrected] Tile fetch failed:", err2);
-        done(err2, tile);
+        if (err2.name !== "AbortError") {
+          console.warn("[L.TileLayer.IndiaBoundaryCorrected] Tile fetch failed:", err2);
+          done(err2, tile);
+        }
       });
       return tile;
     },
+    _removeTile: function(key) {
+      const tile = this._tiles[key];
+      if (!tile) return;
+      if (tile.el.cancel) tile.el.cancel();
+      L2.TileLayer.prototype._removeTile.call(this, key);
+    },
     getTileFixer: function() {
       return this._tileFixer;
     },