@india-boundary-corrector/service-worker 0.0.1

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@india-boundary-corrector/service-worker",
+  "version": "0.0.1",
+  "description": "Service worker for automatic India boundary corrections on map tiles",
+  "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"
+      }
+    },
+    "./worker": {
+      "import": "./dist/worker.global.js",
+      "require": "./dist/worker.global.js"
+    }
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup"
+  },
+  "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",
+    "service-worker",
+    "tiles"
+  ],
+  "author": "ramSeraph",
+  "license": "Unlicense",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ramSeraph/india_boundary_corrector.git",
+    "directory": "packages/service-worker"
+  },
+  "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,94 @@
+import { LayerConfig } from '@india-boundary-corrector/layer-configs';
+
+export { layerConfigs, LayerConfig } from '@india-boundary-corrector/layer-configs';
+export { getPmtilesUrl } from '@india-boundary-corrector/data';
+
+/**
+ * Message types for communication with service worker
+ */
+export declare const MessageTypes: {
+  ADD_LAYER_CONFIG: 'ADD_LAYER_CONFIG';
+  REMOVE_LAYER_CONFIG: 'REMOVE_LAYER_CONFIG';
+  SET_PMTILES_URL: 'SET_PMTILES_URL';
+  SET_ENABLED: 'SET_ENABLED';
+  CLEAR_CACHE: 'CLEAR_CACHE';
+  GET_STATUS: 'GET_STATUS';
+  RESET_CONFIG: 'RESET_CONFIG';
+};
+
+/**
+ * Options for CorrectionServiceWorker
+ */
+export interface CorrectionServiceWorkerOptions {
+  /** Service worker scope (defaults to workerUrl directory) */
+  scope?: string;
+  /** PMTiles URL to set after registration */
+  pmtilesUrl?: string;
+  /** Timeout in ms to wait for SW to take control (default: 3000) */
+  controllerTimeout?: number;
+}
+
+/**
+ * Status returned by getStatus()
+ */
+export interface ServiceWorkerStatus {
+  enabled: boolean;
+  pmtilesUrl: string;
+  configIds: string[];
+}
+
+/**
+ * Controller for the boundary correction service worker.
+ */
+export declare class CorrectionServiceWorker {
+  constructor(workerUrl: string, options?: CorrectionServiceWorkerOptions);
+  
+  /** Register the service worker and wait for it to take control */
+  register(): Promise<CorrectionServiceWorker>;
+  
+  /** Check if the service worker is controlling the page */
+  isControlling(): boolean;
+  
+  /** Unregister the service worker */
+  unregister(): Promise<boolean>;
+  
+  /** Get the active service worker */
+  getWorker(): ServiceWorker | null;
+  
+  /** Send a message to the service worker */
+  sendMessage(message: object): Promise<any>;
+  
+  /** Add a layer config to the service worker */
+  addLayerConfig(layerConfig: LayerConfig): Promise<void>;
+  
+  /** Remove a layer config from the service worker */
+  removeLayerConfig(configId: string): Promise<void>;
+  
+  /** Set the PMTiles URL */
+  setPmtilesUrl(pmtilesUrl: string): Promise<void>;
+  
+  /** Enable or disable the correction service */
+  setEnabled(enabled: boolean): Promise<void>;
+  
+  /** Clear the tile cache */
+  clearCache(): Promise<void>;
+  
+  /** Get the status of the service worker */
+  getStatus(): Promise<ServiceWorkerStatus>;
+  
+  /** Reset configuration to defaults (pmtilesUrl and layer configs) */
+  resetConfig(): Promise<void>;
+}
+
+/**
+ * Register the correction service worker.
+ */
+export declare function registerCorrectionServiceWorker(
+  workerUrl: string,
+  options?: CorrectionServiceWorkerOptions
+): Promise<CorrectionServiceWorker>;
+
+/**
+ * Get the importScripts snippet for a service worker file.
+ */
+export declare function getWorkerImportSnippet(workerGlobalUrl: string): string;

package/src/index.js

@@ -0,0 +1,255 @@
+/**
+ * Main entry point - exports utilities for registering the service worker
+ * from the main thread.
+ */
+
+export { layerConfigs, LayerConfig } from '@india-boundary-corrector/layer-configs';
+export { getPmtilesUrl } from '@india-boundary-corrector/data';
+
+/**
+ * Message types for communication with service worker
+ */
+export const MessageTypes = {
+  ADD_LAYER_CONFIG: 'ADD_LAYER_CONFIG',
+  REMOVE_LAYER_CONFIG: 'REMOVE_LAYER_CONFIG',
+  SET_PMTILES_URL: 'SET_PMTILES_URL',
+  SET_ENABLED: 'SET_ENABLED',
+  CLEAR_CACHE: 'CLEAR_CACHE',
+  GET_STATUS: 'GET_STATUS',
+  RESET_CONFIG: 'RESET_CONFIG',
+};
+
+/**
+ * Controller for the boundary correction service worker.
+ * Use this to register the service worker and communicate with it.
+ */
+export class CorrectionServiceWorker {
+  /**
+   * @param {string} workerUrl - URL to the service worker script
+   * @param {Object} [options]
+   * @param {string} [options.scope] - Service worker scope (defaults to workerUrl directory)
+   * @param {string} [options.pmtilesUrl] - PMTiles URL to set after registration
+   * @param {number} [options.controllerTimeout=3000] - Timeout in ms to wait for SW to take control
+   */
+  constructor(workerUrl, options = {}) {
+    this._workerUrl = workerUrl;
+    this._scope = options.scope;
+    this._pmtilesUrl = options.pmtilesUrl;
+    this._controllerTimeout = options.controllerTimeout ?? 3000;
+    this._registration = null;
+  }
+
+  /**
+   * Register the service worker and wait for it to take control.
+   * @returns {Promise<CorrectionServiceWorker>} Returns this instance for chaining
+   * @throws {Error} If service workers not supported or registration fails
+   */
+  async register() {
+    if (!('serviceWorker' in navigator)) {
+      throw new Error('Service workers not supported');
+    }
+
+    const regOptions = this._scope ? { scope: this._scope } : undefined;
+    this._registration = await navigator.serviceWorker.register(
+      this._workerUrl,
+      regOptions
+    );
+
+    // Wait for the service worker to be ready
+    await navigator.serviceWorker.ready;
+
+    // Wait for controller if not already controlling
+    if (!navigator.serviceWorker.controller) {
+      await this._waitForController();
+    }
+
+    // Reset config to defaults when connecting to an existing service worker
+    await this.resetConfig();
+
+    // Set PMTiles URL if provided
+    if (this._pmtilesUrl) {
+      await this.setPmtilesUrl(this._pmtilesUrl);
+    }
+
+    return this;
+  }
+
+  /**
+   * Wait for the service worker to take control of the page.
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _waitForController() {
+    return new Promise((resolve) => {
+      const onControllerChange = () => {
+        navigator.serviceWorker.removeEventListener('controllerchange', onControllerChange);
+        resolve();
+      };
+      navigator.serviceWorker.addEventListener('controllerchange', onControllerChange);
+      // Timeout fallback - SW may already be controlling after registration
+      setTimeout(resolve, this._controllerTimeout);
+    });
+  }
+
+  /**
+   * Check if the service worker is controlling the page.
+   * @returns {boolean}
+   */
+  isControlling() {
+    return !!navigator.serviceWorker.controller;
+  }
+
+  /**
+   * Unregister the service worker.
+   * @returns {Promise<boolean>}
+   */
+  async unregister() {
+    if (this._registration) {
+      return this._registration.unregister();
+    }
+    return false;
+  }
+
+  /**
+   * Get the active service worker.
+   * @returns {ServiceWorker|null}
+   */
+  getWorker() {
+    return this._registration?.active ?? navigator.serviceWorker.controller;
+  }
+
+  /**
+   * Send a message to the service worker.
+   * @param {Object} message
+   * @returns {Promise<any>}
+   */
+  async sendMessage(message) {
+    const worker = this.getWorker();
+    if (!worker) {
+      throw new Error('Service worker not active');
+    }
+
+    return new Promise((resolve, reject) => {
+      const channel = new MessageChannel();
+      channel.port1.onmessage = (event) => {
+        if (event.data.error) {
+          reject(new Error(event.data.error));
+        } else {
+          resolve(event.data);
+        }
+      };
+      worker.postMessage(message, [channel.port2]);
+    });
+  }
+
+  /**
+   * Add a layer config to the service worker.
+   * @param {Object} layerConfig
+   * @returns {Promise<void>}
+   */
+  async addLayerConfig(layerConfig) {
+    // Use toJSON if available to properly serialize the config
+    const serialized = typeof layerConfig.toJSON === 'function' 
+      ? layerConfig.toJSON() 
+      : layerConfig;
+    await this.sendMessage({
+      type: MessageTypes.ADD_LAYER_CONFIG,
+      layerConfig: serialized,
+    });
+  }
+
+  /**
+   * Remove a layer config from the service worker.
+   * @param {string} configId
+   * @returns {Promise<void>}
+   */
+  async removeLayerConfig(configId) {
+    await this.sendMessage({
+      type: MessageTypes.REMOVE_LAYER_CONFIG,
+      configId,
+    });
+  }
+
+  /**
+   * Set the PMTiles URL.
+   * @param {string} pmtilesUrl
+   * @returns {Promise<void>}
+   */
+  async setPmtilesUrl(pmtilesUrl) {
+    await this.sendMessage({
+      type: MessageTypes.SET_PMTILES_URL,
+      pmtilesUrl,
+    });
+  }
+
+  /**
+   * Enable or disable the correction service.
+   * @param {boolean} enabled
+   * @returns {Promise<void>}
+   */
+  async setEnabled(enabled) {
+    await this.sendMessage({
+      type: MessageTypes.SET_ENABLED,
+      enabled,
+    });
+  }
+
+  /**
+   * Clear the tile cache.
+   * @returns {Promise<void>}
+   */
+  async clearCache() {
+    await this.sendMessage({
+      type: MessageTypes.CLEAR_CACHE,
+    });
+  }
+
+  /**
+   * Get the status of the service worker.
+   * @returns {Promise<Object>}
+   */
+  async getStatus() {
+    return this.sendMessage({
+      type: MessageTypes.GET_STATUS,
+    });
+  }
+
+  /**
+   * Reset the service worker configuration to defaults.
+   * Resets pmtilesUrl to default and restores default layer configs.
+   * @returns {Promise<void>}
+   */
+  async resetConfig() {
+    await this.sendMessage({
+      type: MessageTypes.RESET_CONFIG,
+    });
+  }
+}
+
+/**
+ * Register the correction service worker with simplified setup.
+ * @param {string} workerUrl - URL to the service worker script
+ * @param {Object} [options]
+ * @param {string} [options.scope] - Service worker scope
+ * @param {string} [options.pmtilesUrl] - PMTiles URL to set
+ * @param {number} [options.controllerTimeout] - Timeout in ms to wait for SW control
+ * @returns {Promise<CorrectionServiceWorker>}
+ */
+export async function registerCorrectionServiceWorker(workerUrl, options = {}) {
+  const sw = new CorrectionServiceWorker(workerUrl, options);
+  await sw.register();
+  return sw;
+}
+
+/**
+ * Get the importScripts snippet for a service worker file.
+ * This can be used to create a minimal sw.js file.
+ * @param {string} workerGlobalUrl - URL to the worker.global.js file
+ * @returns {string} JavaScript code to put in sw.js
+ * @example
+ * // Create sw.js with:
+ * // importScripts('https://unpkg.com/@india-boundary-corrector/service-worker/dist/worker.global.js');
+ */
+export function getWorkerImportSnippet(workerGlobalUrl) {
+  return `importScripts('${workerGlobalUrl}');`;
+}

package/src/worker.js

@@ -0,0 +1,189 @@
+/**
+ * Service Worker script for intercepting tile requests and applying
+ * India boundary corrections.
+ * 
+ * This file should be served as the service worker script.
+ * It bundles all dependencies for standalone use.
+ */
+
+import { getPmtilesUrl } from '@india-boundary-corrector/data';
+import { layerConfigs, LayerConfig } from '@india-boundary-corrector/layer-configs';
+import { BoundaryCorrector as TileFixer } from '@india-boundary-corrector/tilefixer';
+
+// Message types
+const MessageTypes = {
+  ADD_LAYER_CONFIG: 'ADD_LAYER_CONFIG',
+  REMOVE_LAYER_CONFIG: 'REMOVE_LAYER_CONFIG',
+  SET_PMTILES_URL: 'SET_PMTILES_URL',
+  SET_ENABLED: 'SET_ENABLED',
+  CLEAR_CACHE: 'CLEAR_CACHE',
+  GET_STATUS: 'GET_STATUS',
+  RESET_CONFIG: 'RESET_CONFIG',
+};
+
+// State
+let registry = layerConfigs.createMergedRegistry();
+let tileFixer = null;
+let pmtilesUrl = null; // Will be set lazily or via message
+let enabled = true;
+let tileSize = 256;
+
+// Reset to default configuration
+function resetConfig() {
+  pmtilesUrl = null;
+  tileFixer = null;
+  enabled = true;
+  registry = layerConfigs.createMergedRegistry();
+}
+
+// Initialize TileFixer lazily
+function getTileFixer() {
+  if (!tileFixer) {
+    if (!pmtilesUrl) {
+      pmtilesUrl = getPmtilesUrl();
+    }
+    tileFixer = new TileFixer(pmtilesUrl);
+  }
+  return tileFixer;
+}
+
+// Reinitialize TileFixer with new URL
+function reinitTileFixer() {
+  tileFixer = new TileFixer(pmtilesUrl);
+}
+
+/**
+ * Check if a request is for a map tile that we should intercept.
+ * @param {Request} request
+ * @returns {{ layerConfig: Object, coords: { z: number, x: number, y: number } } | null}
+ */
+function shouldIntercept(request) {
+  if (!enabled) return null;
+  if (request.method !== 'GET') return null;
+  
+  return registry.parseTileUrl(request.url);
+}
+
+/**
+ * Fetch and fix a tile for service worker.
+ * 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 {TileFixer} tileFixer - TileFixer instance
+ * @param {Object} layerConfig - Layer configuration
+ * @param {number} tileSize - Tile size in pixels
+ * @param {Object} [options] - Fetch options
+ * @returns {Promise<Response>}
+ */
+async function fetchAndFixTile(tileUrl, z, x, y, tileFixer, layerConfig, tileSize, options = {}) {
+  const { data, wasFixed } = await tileFixer.fetchAndFixTile(
+    tileUrl, z, x, y, layerConfig, { tileSize, mode: 'cors', ...options }
+  );
+  
+  return new Response(data, {
+    status: 200,
+    headers: {
+      'Content-Type': 'image/png',
+      'Cache-Control': 'max-age=3600',
+      'X-Boundary-Corrected': wasFixed ? 'true' : 'false',
+    },
+  });
+}
+
+/**
+ * Apply corrections to a tile.
+ * @param {Request} request
+ * @param {Object} layerConfig
+ * @param {{ z: number, x: number, y: number }} coords
+ * @returns {Promise<Response>}
+ */
+async function applyCorrectedTile(request, layerConfig, coords) {
+  const { z, x, y } = coords;
+  const fixer = getTileFixer();
+  
+  return fetchAndFixTile(request.url, z, x, y, fixer, layerConfig, tileSize);
+}
+
+// Install event
+self.addEventListener('install', (event) => {
+  self.skipWaiting();
+});
+
+// Activate event
+self.addEventListener('activate', (event) => {
+  event.waitUntil(self.clients.claim());
+});
+
+// Fetch event - intercept tile requests
+self.addEventListener('fetch', (event) => {
+  const intercept = shouldIntercept(event.request);
+  
+  if (intercept) {
+    event.respondWith(
+      applyCorrectedTile(event.request, intercept.layerConfig, intercept.coords)
+        .catch((error) => {
+          console.warn('[CorrectionSW] Error applying corrections:', error);
+          // Fallback to original request
+          return fetch(event.request);
+        })
+    );
+  }
+});
+
+// Message event - handle commands from main thread
+self.addEventListener('message', (event) => {
+  const { type, ...data } = event.data;
+  const port = event.ports[0];
+  
+  try {
+    switch (type) {
+      case MessageTypes.ADD_LAYER_CONFIG:
+        // Reconstruct LayerConfig from plain object
+        const config = LayerConfig.fromJSON(data.layerConfig);
+        registry.register(config);
+        port?.postMessage({ success: true });
+        break;
+        
+      case MessageTypes.REMOVE_LAYER_CONFIG:
+        const removed = registry.remove(data.configId);
+        port?.postMessage({ success: removed });
+        break;
+        
+      case MessageTypes.SET_PMTILES_URL:
+        pmtilesUrl = data.pmtilesUrl;
+        reinitTileFixer();
+        port?.postMessage({ success: true });
+        break;
+        
+      case MessageTypes.SET_ENABLED:
+        enabled = data.enabled;
+        port?.postMessage({ success: true });
+        break;
+        
+      case MessageTypes.CLEAR_CACHE:
+        tileFixer?.clearCache();
+        port?.postMessage({ success: true });
+        break;
+        
+      case MessageTypes.RESET_CONFIG:
+        resetConfig();
+        port?.postMessage({ success: true });
+        break;
+        
+      case MessageTypes.GET_STATUS:
+        port?.postMessage({
+          enabled,
+          pmtilesUrl: pmtilesUrl || getPmtilesUrl(),
+          configIds: registry.getAvailableIds(),
+        });
+        break;
+        
+      default:
+        port?.postMessage({ error: `Unknown message type: ${type}` });
+    }
+  } catch (error) {
+    port?.postMessage({ error: error.message });
+  }
+});