teda-weather 0.1.0

package/dist/chunk-ROJRWJ7L.js

@@ -0,0 +1,534 @@
+import {
+  Client,
+  ColormapLayer,
+  ColormapTileLayer,
+  FeatherLayer,
+  ParticleAnimationLayer,
+  createCanvasOverlay,
+  mountCanvasOverlay,
+  syncCanvasLikeData,
+  syncCanvasOverlaySize,
+  unmountCanvasOverlay
+} from "./chunk-Y3HFQZGE.js";
+
+// src/adapters/mapbox/mapbox-client.ts
+var mountIdSequence = 0;
+var MapboxClient = class extends Client {
+  constructor() {
+    super(...arguments);
+    this.defaultOptionsEnabled = false;
+    this.cleanupHandles = [];
+    this.destroyed = false;
+  }
+  useDefault(value) {
+    this.assertNotDestroyed();
+    if (typeof value === "boolean") {
+      this.defaultOptionsEnabled = value;
+    }
+    if (typeof value === "undefined" || this.defaultOptionsEnabled) {
+      this.ensureDefaultLayers();
+    }
+    return this.defaultOptionsEnabled;
+  }
+  setColorMapTileOption(option) {
+    this.assertNotDestroyed();
+    this.ensureDefaultLayers();
+    this.colorMapTileLayer?.setOption(option);
+  }
+  clearColorMapTile() {
+    this.assertNotDestroyed();
+    this.ensureDefaultLayers();
+    const layer = this.colorMapTileLayer;
+    const canvas = layer?.overlay.canvas;
+    if (!canvas) {
+      return;
+    }
+    layer?.source?.clear?.();
+    canvas.data = new Uint8ClampedArray(canvas.width * canvas.height * 4);
+    syncCanvasLikeData(canvas);
+    delete layer?.source;
+  }
+  getColorMapTileCanvas() {
+    this.assertNotDestroyed();
+    this.ensureDefaultLayers();
+    return this.colorMapTileLayer?.overlay.canvas;
+  }
+  setColorMapOption(option) {
+    this.assertNotDestroyed();
+    this.ensureDefaultLayers();
+    this.colorMapLayer?.setOption(option);
+  }
+  getColorMapCanvas() {
+    this.assertNotDestroyed();
+    this.ensureDefaultLayers();
+    return this.colorMapLayer?.overlay.canvas;
+  }
+  decodeColorMapTile(pixel, extent, worldZoom) {
+    this.assertNotDestroyed();
+    this.ensureDefaultLayers();
+    if (!this.colorMapTileLayer?.source) {
+      return null;
+    }
+    return this.colorMapTileLayer?.decodeFromCanvasPixel(
+      pixel,
+      extent,
+      worldZoom
+    );
+  }
+  decodeColorMapTileValue(pixel, extent, worldZoom) {
+    return this.decodeColorMapTile(pixel, extent, worldZoom);
+  }
+  decodeColorMapTileValueByLngLat(lngLat, worldZoom) {
+    this.assertNotDestroyed();
+    this.ensureDefaultLayers();
+    if (!this.colorMapTileLayer?.source) {
+      return null;
+    }
+    return this.colorMapTileLayer?.source?.decodeTextByLngLat(
+      lngLat,
+      worldZoom
+    );
+  }
+  initColorMapTileLayer(map, mapDiv, layerConfig) {
+    this.assertNotDestroyed();
+    if (this.tileMount) {
+      this.ensureMountedResources(this.tileMount, layerConfig);
+      return;
+    }
+    const mountedLayer = this.mountTileLayer(map, mapDiv, layerConfig);
+    this.colorMapTileLayer = mountedLayer.layer;
+    this.tileMount = mountedLayer;
+  }
+  initColorMapLayer(map, mapDiv, layerConfig) {
+    this.assertNotDestroyed();
+    if (this.colorMount) {
+      this.ensureMountedResources(this.colorMount, layerConfig);
+      return;
+    }
+    const mountedLayer = this.mountColorLayer(map, mapDiv, layerConfig);
+    this.colorMapLayer = mountedLayer.layer;
+    this.colorMount = mountedLayer;
+  }
+  initParticleLayer(map, mapDiv, layerConfig) {
+    this.assertNotDestroyed();
+    if (this.particleMount) {
+      this.ensureMountedResources(this.particleMount, layerConfig);
+      return;
+    }
+    const mountedLayer = this.mountParticleLayer(map, mapDiv, layerConfig);
+    this.particleLayer = mountedLayer.layer;
+    this.particleMount = mountedLayer;
+  }
+  initFeatherLayer(map, mapDiv, layerConfig) {
+    this.assertNotDestroyed();
+    if (this.featherMount) {
+      this.ensureMountedResources(this.featherMount, layerConfig);
+      return;
+    }
+    const mountedLayer = this.mountFeatherLayer(map, mapDiv, layerConfig);
+    this.featherLayer = mountedLayer.layer;
+    this.featherMount = mountedLayer;
+  }
+  renderColorMapTileFunction(map = this.tileMount?.map, mapDiv = this.tileMount?.container, weatherOptionOrOnerror, layerConfig) {
+    this.assertNotDestroyed();
+    const mountedLayer = this.resolveTileMount(map, mapDiv, layerConfig);
+    if (!mountedLayer) {
+      return;
+    }
+    this.colorMapTileLayer = mountedLayer.layer;
+    const weatherOption = normalizeWeatherOption(
+      weatherOptionOrOnerror
+    );
+    if (weatherOption) {
+      mountedLayer.layer.setOption(weatherOption);
+    }
+    syncCanvasOverlaySize(mountedLayer.overlay, mountedLayer.overlay.container);
+    let renderedCanvas = mountedLayer.overlay.canvas;
+    if (mountedLayer.layer.source) {
+      renderedCanvas = this.renderTileCanvas(mountedLayer);
+      copyCanvasLike(renderedCanvas, mountedLayer.overlay);
+    }
+    this.syncMountedSource(mountedLayer);
+    return mountedLayer.overlay.canvas;
+  }
+  renderColorMapFunction(map = this.colorMount?.map, mapDiv = this.colorMount?.container, weatherOptionOrOnerror, layerConfig) {
+    this.assertNotDestroyed();
+    const mountedLayer = this.resolveColorMount(map, mapDiv, layerConfig);
+    if (!mountedLayer) {
+      return;
+    }
+    this.colorMapLayer = mountedLayer.layer;
+    const weatherOption = normalizeWeatherOption(
+      weatherOptionOrOnerror
+    );
+    if (weatherOption) {
+      mountedLayer.layer.setOption(weatherOption);
+    }
+    syncCanvasOverlaySize(mountedLayer.overlay, mountedLayer.overlay.container);
+    let renderedCanvas = mountedLayer.overlay.canvas;
+    if (mountedLayer.layer.source) {
+      renderedCanvas = this.renderColorCanvas(mountedLayer);
+      copyCanvasLike(renderedCanvas, mountedLayer.overlay);
+    }
+    this.syncMountedSource(mountedLayer);
+    return mountedLayer.overlay.canvas;
+  }
+  renderParticleFunction(map = this.particleMount?.map, mapDiv = this.particleMount?.container, weatherOptionOrOnerror, layerConfig) {
+    this.assertNotDestroyed();
+    const mountedLayer = this.resolveParticleMount(map, mapDiv, layerConfig);
+    if (!mountedLayer) {
+      return;
+    }
+    this.particleLayer = mountedLayer.layer;
+    const weatherOption = normalizeWeatherOption(
+      weatherOptionOrOnerror
+    );
+    if (weatherOption) {
+      mountedLayer.layer.setOption(weatherOption);
+    }
+    syncCanvasOverlaySize(mountedLayer.overlay, mountedLayer.overlay.container);
+    this.setParticleView(mountedLayer);
+    mountedLayer.layer.start();
+    this.syncMountedSource(mountedLayer);
+    return mountedLayer.overlay.canvas;
+  }
+  renderFeatherFunction(map = this.featherMount?.map, mapDiv = this.featherMount?.container, weatherOptionOrOnerror, layerConfig) {
+    this.assertNotDestroyed();
+    const mountedLayer = this.resolveFeatherMount(map, mapDiv, layerConfig);
+    if (!mountedLayer) {
+      return;
+    }
+    this.featherLayer = mountedLayer.layer;
+    const weatherOption = normalizeWeatherOption(
+      weatherOptionOrOnerror
+    );
+    if (weatherOption) {
+      mountedLayer.layer.setOption(weatherOption);
+    }
+    syncCanvasOverlaySize(mountedLayer.overlay, mountedLayer.overlay.container);
+    this.renderFeatherCanvas(mountedLayer);
+    this.syncMountedSource(mountedLayer);
+    return mountedLayer.overlay.canvas;
+  }
+  startParticle(config) {
+    this.assertNotDestroyed();
+    this.ensureDefaultLayers();
+    const mountedLayer = this.particleMount;
+    if (mountedLayer) {
+      syncCanvasOverlaySize(mountedLayer.overlay, mountedLayer.overlay.container);
+      this.setParticleView(mountedLayer);
+      const canvas = mountedLayer.layer.start(config);
+      this.syncMountedSource(mountedLayer);
+      return canvas;
+    }
+    return this.particleLayer?.start(config);
+  }
+  clearParticle() {
+    this.assertNotDestroyed();
+    this.ensureDefaultLayers();
+    this.particleLayer?.stop();
+    const canvas = this.particleLayer?.overlay.canvas;
+    if (!canvas) {
+      return;
+    }
+    canvas.data = new Uint8ClampedArray(canvas.width * canvas.height * 4);
+    syncCanvasLikeData(canvas);
+  }
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    this.colorMapTileLayer?.source?.clear?.();
+    this.colorMapLayer?.source?.clear?.();
+    this.featherLayer?.destroy?.();
+    this.particleLayer?.destroy?.();
+    for (const cleanupHandle of this.cleanupHandles.splice(0)) {
+      cleanupHandle();
+    }
+    this.colorMapTileLayer = void 0;
+    this.colorMapLayer = void 0;
+    this.featherLayer = void 0;
+    this.particleLayer = void 0;
+    this.tileMount = void 0;
+    this.colorMount = void 0;
+    this.featherMount = void 0;
+    this.particleMount = void 0;
+  }
+  assertNotDestroyed() {
+    if (this.destroyed) {
+      throw new Error("MapboxClient has been destroyed");
+    }
+  }
+  resolveTileMount(map, mapDiv, layerConfig) {
+    if (this.tileMount || !map || !mapDiv) {
+      return this.tileMount;
+    }
+    const mountedLayer = this.mountTileLayer(map, mapDiv, layerConfig);
+    this.tileMount = mountedLayer;
+    this.colorMapTileLayer = mountedLayer.layer;
+    return mountedLayer;
+  }
+  resolveColorMount(map, mapDiv, layerConfig) {
+    if (this.colorMount || !map || !mapDiv) {
+      return this.colorMount;
+    }
+    const mountedLayer = this.mountColorLayer(map, mapDiv, layerConfig);
+    this.colorMount = mountedLayer;
+    this.colorMapLayer = mountedLayer.layer;
+    return mountedLayer;
+  }
+  resolveParticleMount(map, mapDiv, layerConfig) {
+    if (this.particleMount || !map || !mapDiv) {
+      return this.particleMount;
+    }
+    const mountedLayer = this.mountParticleLayer(map, mapDiv, layerConfig);
+    this.particleMount = mountedLayer;
+    this.particleLayer = mountedLayer.layer;
+    return mountedLayer;
+  }
+  resolveFeatherMount(map, mapDiv, layerConfig) {
+    if (this.featherMount || !map || !mapDiv) {
+      return this.featherMount;
+    }
+    const mountedLayer = this.mountFeatherLayer(map, mapDiv, layerConfig);
+    this.featherMount = mountedLayer;
+    this.featherLayer = mountedLayer.layer;
+    return mountedLayer;
+  }
+  mountTileLayer(map, container, layerConfig) {
+    return this.mountLayer({
+      map,
+      container,
+      layer: new ColormapTileLayer({
+        sourceDependencies: { retainQueryBuffer: true }
+      }),
+      sourceIdBase: "teda-weather-color-map-tile-source",
+      defaultLayerIdBase: "teda-weather-color-map-tile-layer",
+      layerConfig,
+      render: () => this.renderColorMapTileFunction()
+    });
+  }
+  mountColorLayer(map, container, layerConfig) {
+    return this.mountLayer({
+      map,
+      container,
+      layer: new ColormapLayer(),
+      sourceIdBase: "teda-weather-color-map-source",
+      defaultLayerIdBase: "teda-weather-color-map-layer",
+      layerConfig,
+      render: () => this.renderColorMapFunction()
+    });
+  }
+  mountParticleLayer(map, container, layerConfig) {
+    return this.mountLayer({
+      map,
+      container,
+      layer: new ParticleAnimationLayer(),
+      sourceIdBase: "teda-weather-particle-source",
+      defaultLayerIdBase: "teda-weather-particle-layer",
+      layerConfig,
+      render: () => this.startParticle()
+    });
+  }
+  mountFeatherLayer(map, container, layerConfig) {
+    return this.mountLayer({
+      map,
+      container,
+      layer: new FeatherLayer(),
+      sourceIdBase: "teda-weather-feather-source",
+      defaultLayerIdBase: "teda-weather-feather-layer",
+      layerConfig,
+      render: () => this.renderFeatherFunction()
+    });
+  }
+  mountLayer(options) {
+    const overlay = createCanvasOverlay(options.container);
+    const mountedLayer = Object.assign(options.layer, { overlay });
+    attachOverlayCanvas(mountedLayer, overlay.canvas);
+    const mountId = ++mountIdSequence;
+    const sourceId = `${options.sourceIdBase}-${mountId}`;
+    const layerId = options.layerConfig?.layerId ?? options.layerConfig?.id ?? `${options.defaultLayerIdBase}-${mountId}`;
+    const syncAndRender = () => {
+      syncCanvasOverlaySize(overlay, options.container);
+      options.render();
+    };
+    mountCanvasOverlay(overlay, options.container);
+    this.ensureSource(options.map, sourceId, overlay);
+    this.ensureLayer(options.map, sourceId, layerId, options.layerConfig);
+    options.map.on("move", syncAndRender);
+    options.map.on("resize", syncAndRender);
+    this.cleanupHandles.push(
+      () => options.map.off("move", syncAndRender),
+      () => options.map.off("resize", syncAndRender),
+      () => options.map.removeLayer?.(layerId),
+      () => options.map.removeSource?.(sourceId),
+      () => unmountCanvasOverlay(overlay)
+    );
+    return {
+      map: options.map,
+      overlay,
+      container: options.container,
+      layer: mountedLayer,
+      sourceId,
+      layerId
+    };
+  }
+  ensureDefaultLayers() {
+    if (!this.colorMapTileLayer) {
+      this.colorMapTileLayer = Object.assign(
+        new ColormapTileLayer({
+          sourceDependencies: { retainQueryBuffer: true }
+        }),
+        {
+          overlay: createCanvasOverlay({ offsetWidth: 1, offsetHeight: 1 })
+        }
+      );
+    }
+    if (!this.colorMapLayer) {
+      this.colorMapLayer = Object.assign(new ColormapLayer(), {
+        overlay: createCanvasOverlay({ offsetWidth: 1, offsetHeight: 1 })
+      });
+    }
+    if (!this.featherLayer) {
+      const overlay = createCanvasOverlay({ offsetWidth: 1, offsetHeight: 1 });
+      this.featherLayer = Object.assign(new FeatherLayer(), { overlay });
+      attachOverlayCanvas(this.featherLayer, overlay.canvas);
+    }
+    if (!this.particleLayer) {
+      const overlay = createCanvasOverlay({ offsetWidth: 1, offsetHeight: 1 });
+      this.particleLayer = Object.assign(new ParticleAnimationLayer(), {
+        overlay
+      });
+      attachOverlayCanvas(this.particleLayer, overlay.canvas);
+    }
+  }
+  renderTileCanvas(mountedLayer) {
+    const viewState = getMapViewState(mountedLayer.map, mountedLayer.container);
+    return mountedLayer.layer.renderExtent(
+      viewState.extent,
+      viewState.zoom,
+      viewState.viewSize,
+      viewState.pixelRatio
+    );
+  }
+  renderColorCanvas(mountedLayer) {
+    const viewState = getMapViewState(mountedLayer.map, mountedLayer.container);
+    return mountedLayer.layer.renderExtent(
+      viewState.extent,
+      viewState.zoom,
+      viewState.viewSize,
+      viewState.pixelRatio
+    );
+  }
+  renderFeatherCanvas(mountedLayer) {
+    const viewState = getMapViewState(mountedLayer.map, mountedLayer.container);
+    return mountedLayer.layer.renderExtent(
+      viewState.extent,
+      viewState.zoom,
+      viewState.viewSize,
+      viewState.pixelRatio
+    );
+  }
+  setParticleView(mountedLayer) {
+    if (!mountedLayer) {
+      return;
+    }
+    const viewState = getMapViewState(mountedLayer.map, mountedLayer.container);
+    mountedLayer.layer.setView(
+      viewState.extent,
+      viewState.zoom,
+      viewState.viewSize
+    );
+  }
+  syncMountedSource(mountedLayer) {
+    const coordinates = getCanvasCoordinates(mountedLayer.map);
+    const source = this.ensureMountedResources(mountedLayer);
+    if (source.setCoordinates) {
+      source.setCoordinates(coordinates);
+      return;
+    }
+    source.coordinates = coordinates;
+  }
+  ensureMountedResources(mountedLayer, layerConfig) {
+    this.ensureSource(
+      mountedLayer.map,
+      mountedLayer.sourceId,
+      mountedLayer.overlay
+    );
+    this.ensureLayer(
+      mountedLayer.map,
+      mountedLayer.sourceId,
+      mountedLayer.layerId,
+      layerConfig
+    );
+    return mountedLayer.map.getSource(mountedLayer.sourceId) ?? {};
+  }
+  ensureSource(map, sourceId, overlay, coordinates = getCanvasCoordinates(map)) {
+    if (map.getSource(sourceId)) {
+      return;
+    }
+    map.addSource(sourceId, {
+      type: "canvas",
+      canvas: overlay.canvas,
+      coordinates,
+      animate: true
+    });
+  }
+  ensureLayer(map, sourceId, layerId, layerConfig) {
+    if (map.getLayer(layerId)) {
+      return;
+    }
+    map.addLayer(
+      {
+        id: layerId,
+        type: "raster",
+        source: sourceId,
+        paint: layerConfig?.paint,
+        layout: layerConfig?.layout
+      },
+      layerConfig?.beforeId
+    );
+  }
+};
+function getCanvasCoordinates(map) {
+  const bounds = map.getBounds();
+  return [
+    [bounds.getWest(), bounds.getNorth()],
+    [bounds.getEast(), bounds.getNorth()],
+    [bounds.getEast(), bounds.getSouth()],
+    [bounds.getWest(), bounds.getSouth()]
+  ];
+}
+function getMapViewState(map, container) {
+  const bounds = map.getBounds();
+  return {
+    extent: [
+      bounds.getWest(),
+      bounds.getSouth(),
+      bounds.getEast(),
+      bounds.getNorth()
+    ],
+    zoom: map.getZoom() + 1,
+    viewSize: [container.offsetWidth ?? 1, container.offsetHeight ?? 1],
+    pixelRatio: typeof globalThis.devicePixelRatio === "number" ? globalThis.devicePixelRatio : 1
+  };
+}
+function attachOverlayCanvas(layer, canvas) {
+  layer.setCanvas?.(canvas);
+}
+function copyCanvasLike(source, overlay) {
+  overlay.width = source.width;
+  overlay.height = source.height;
+  overlay.canvas.width = source.width;
+  overlay.canvas.height = source.height;
+  overlay.canvas.data = new Uint8ClampedArray(source.data);
+  syncCanvasLikeData(overlay.canvas);
+}
+function normalizeWeatherOption(value) {
+  return typeof value === "function" ? void 0 : value;
+}
+
+export {
+  MapboxClient
+};