@india-boundary-corrector/leaflet-layer 0.0.1

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@india-boundary-corrector/leaflet-layer",
+  "version": "0.0.1",
+  "description": "Leaflet TileLayer plugin with India boundary corrections",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./src/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./src/index.d.ts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup"
+  },
+  "peerDependencies": {
+    "leaflet": ">=1.9.0"
+  },
+  "dependencies": {
+    "@india-boundary-corrector/data": "^0.0.1",
+    "@india-boundary-corrector/layer-configs": "^0.0.1",
+    "@india-boundary-corrector/tilefixer": "^0.0.1"
+  },
+  "keywords": [
+    "india",
+    "boundary",
+    "map",
+    "leaflet",
+    "tilelayer"
+  ],
+  "author": "ramSeraph",
+  "license": "Unlicense",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ramSeraph/india_boundary_corrector.git",
+    "directory": "packages/leaflet-layer"
+  },
+  "bugs": {
+    "url": "https://github.com/ramSeraph/india_boundary_corrector/issues"
+  },
+  "homepage": "https://github.com/ramSeraph/india_boundary_corrector#readme"
+}

package/src/index.d.ts

@@ -0,0 +1,50 @@
+import * as L from 'leaflet';
+import { LayerConfig } from '@india-boundary-corrector/layer-configs';
+import { BoundaryCorrector as TileFixer } from '@india-boundary-corrector/tilefixer';
+
+export { layerConfigs, LayerConfig } from '@india-boundary-corrector/layer-configs';
+export { getPmtilesUrl } from '@india-boundary-corrector/data';
+
+/**
+ * Options for L.TileLayer.IndiaBoundaryCorrected
+ */
+export interface IndiaBoundaryCorrectedTileLayerOptions extends L.TileLayerOptions {
+  /** URL to PMTiles file (defaults to CDN) */
+  pmtilesUrl?: string;
+  /** LayerConfig object or config ID string (auto-detected from URL if not provided) */
+  layerConfig?: LayerConfig | string;
+  /** Additional layer configs for matching */
+  extraLayerConfigs?: LayerConfig[];
+}
+
+/**
+ * Extended TileLayer with boundary corrections
+ */
+export interface IndiaBoundaryCorrectedTileLayer extends L.TileLayer {
+  /** Get the TileFixer instance */
+  getTileFixer(): TileFixer;
+  /** Get the resolved LayerConfig */
+  getLayerConfig(): LayerConfig | null;
+}
+
+declare module 'leaflet' {
+  namespace TileLayer {
+    class IndiaBoundaryCorrected extends L.TileLayer implements IndiaBoundaryCorrectedTileLayer {
+      constructor(url: string, options?: IndiaBoundaryCorrectedTileLayerOptions);
+      getTileFixer(): TileFixer;
+      getLayerConfig(): LayerConfig | null;
+    }
+  }
+
+  namespace tileLayer {
+    function indiaBoundaryCorrected(url: string, options?: IndiaBoundaryCorrectedTileLayerOptions): TileLayer.IndiaBoundaryCorrected;
+  }
+}
+
+/**
+ * Extend Leaflet with L.TileLayer.IndiaBoundaryCorrected and L.tileLayer.indiaBoundaryCorrected.
+ * Called automatically when Leaflet is available globally.
+ * Use this for ES module imports where L is not global.
+ * @param L - Leaflet namespace
+ */
+export declare function extendLeaflet(L: typeof import('leaflet')): void;

package/src/index.js

@@ -0,0 +1,134 @@
+import { getPmtilesUrl } from '@india-boundary-corrector/data';
+import { layerConfigs } from '@india-boundary-corrector/layer-configs';
+import { BoundaryCorrector as TileFixer } from '@india-boundary-corrector/tilefixer';
+
+// Re-export for convenience
+export { layerConfigs, LayerConfig } from '@india-boundary-corrector/layer-configs';
+export { getPmtilesUrl } from '@india-boundary-corrector/data';
+
+/**
+ * Extend Leaflet with IndiaBoundaryCorrectedTileLayer.
+ * @param {L} L - Leaflet namespace
+ */
+function extendLeaflet(L) {
+  // Avoid re-extending
+  if (L.TileLayer.IndiaBoundaryCorrected) {
+    return;
+  }
+
+  L.TileLayer.IndiaBoundaryCorrected = L.TileLayer.extend({
+    options: {
+      pmtilesUrl: null,
+      layerConfig: null,
+      extraLayerConfigs: null,
+    },
+
+    initialize: function (url, options) {
+      L.TileLayer.prototype.initialize.call(this, url, options);
+      
+      this._pmtilesUrl = this.options.pmtilesUrl ?? getPmtilesUrl();
+      this._tileFixer = new TileFixer(this._pmtilesUrl);
+      this._registry = layerConfigs.createMergedRegistry(this.options.extraLayerConfigs);
+      
+      if (typeof this.options.layerConfig === 'string') {
+        this._layerConfig = this._registry.get(this.options.layerConfig);
+      } else if (this.options.layerConfig) {
+        this._layerConfig = this.options.layerConfig;
+      } else {
+        this._layerConfig = this._registry.detectFromTemplates([url]);
+      }
+      
+      if (!this._layerConfig) {
+        console.warn('[L.TileLayer.IndiaBoundaryCorrected] Could not detect layer config from URL. Corrections will not be applied.');
+      }
+    },
+
+    /**
+     * Handle tile fetching and correction application logic.
+     * This method is extracted for testability.
+     * @param {string} tileUrl - URL of the raster tile
+     * @param {number} z - Zoom level
+     * @param {number} x - Tile X coordinate
+     * @param {number} y - Tile Y coordinate
+     * @param {number} tileSize - Tile size in pixels
+     * @returns {Promise<{blob: Blob, wasFixed: boolean, correctionsFailed: boolean, correctionsError: Error|null}>}
+     * @private
+     */
+    _fetchAndFixTile: async function (tileUrl, z, x, y, tileSize) {
+      const { data, wasFixed, correctionsFailed, correctionsError } = await this._tileFixer.fetchAndFixTile(
+        tileUrl, z, x, y, this._layerConfig, { tileSize }
+      );
+      const blob = new Blob([data], { type: wasFixed ? 'image/png' : undefined });
+      return { blob, wasFixed, correctionsFailed, correctionsError };
+    },
+
+    createTile: function (coords, done) {
+      const tile = document.createElement('img');
+      
+      tile.alt = '';
+      
+      if (this.options.crossOrigin || this.options.crossOrigin === '') {
+        tile.crossOrigin = this.options.crossOrigin === true ? '' : this.options.crossOrigin;
+      }
+      
+      if (typeof this.options.referrerPolicy === 'string') {
+        tile.referrerPolicy = this.options.referrerPolicy;
+      }
+
+      if (!this._layerConfig) {
+        tile.onload = () => done(null, tile);
+        tile.onerror = (e) => done(e, tile);
+        tile.src = this.getTileUrl(coords);
+        return tile;
+      }
+
+      const tileUrl = this.getTileUrl(coords);
+      const z = coords.z;
+      const x = coords.x;
+      const y = coords.y;
+      const tileSize = this.options.tileSize || 256;
+
+      // TODO: Pass AbortSignal to _fetchAndFixTile to cancel in-flight requests when tiles
+      // go off-screen. This would require creating an AbortController per tile and hooking
+      // into Leaflet's _removeTile/_abortLoading. Deferred due to complexity - will revisit
+      // if performance becomes an issue during rapid panning.
+      this._fetchAndFixTile(tileUrl, z, x, y, tileSize)
+        .then(({ blob, wasFixed, correctionsFailed, correctionsError }) => {
+          if (correctionsFailed) {
+            console.warn('[L.TileLayer.IndiaBoundaryCorrected] Corrections fetch failed:', correctionsError);
+            this.fire('correctionerror', { error: correctionsError, coords: { z, x, y }, tileUrl });
+          }
+          tile.src = URL.createObjectURL(blob);
+          tile.onload = () => {
+            URL.revokeObjectURL(tile.src);
+            done(null, tile);
+          };
+          tile.onerror = (e) => {
+            URL.revokeObjectURL(tile.src);
+            done(e, tile);
+          };
+        })
+        .catch((err) => {
+          console.warn('[L.TileLayer.IndiaBoundaryCorrected] Tile fetch failed:', err);
+          done(err, tile);
+        });
+
+      return tile;
+    },
+
+    getTileFixer: function () {
+      return this._tileFixer;
+    },
+
+    getLayerConfig: function () {
+      return this._layerConfig;
+    },
+  });
+
+  L.tileLayer.indiaBoundaryCorrected = function (url, options) {
+    return new L.TileLayer.IndiaBoundaryCorrected(url, options);
+  };
+}
+
+// Export for manual extension if needed (e.g., ES modules with imported L)
+export { extendLeaflet };