@sjvair/monitor-map 4.2.0 → 5.0.0-beta.0

package/dist/lib/map/integrations/click-manager.js

@@ -1,52 +0,0 @@
-import { mapManager } from "../map-manager.svelte.js";
-class ClickManager {
-    registrations = [];
-    isListening = false;
-    /** Must be called after `mapManager.map` is initialized (i.e. from within `apply()`). */
-    register(layerIds, handler) {
-        const incomingSet = new Set(layerIds);
-        const existing = this.registrations.find((r) => r.layerIds.some((id) => incomingSet.has(id)));
-        if (existing) {
-            existing.layerIds = layerIds;
-            existing.handler = handler;
-        }
-        else {
-            this.registrations.push({ layerIds, handler });
-        }
-        this.ensureListener();
-    }
-    unregister(layerIds) {
-        const set = new Set(layerIds);
-        this.registrations = this.registrations.filter((r) => !r.layerIds.some((id) => set.has(id)));
-        if (this.registrations.length === 0) {
-            this.removeListener();
-        }
-    }
-    ensureListener() {
-        if (this.isListening || !mapManager.map)
-            return;
-        mapManager.map.on("click", this.handleClick);
-        this.isListening = true;
-    }
-    removeListener() {
-        if (!this.isListening)
-            return;
-        mapManager.map?.off("click", this.handleClick);
-        this.isListening = false;
-    }
-    handleClick = (evt) => {
-        if (!mapManager.map)
-            return;
-        const allLayerIds = this.registrations.flatMap((r) => r.layerIds);
-        const features = mapManager.map.queryRenderedFeatures(evt.point, { layers: allLayerIds });
-        if (!features.length)
-            return;
-        const winningLayerId = features[0].layer.id;
-        const registration = this.registrations.find((r) => r.layerIds.includes(winningLayerId));
-        if (!registration)
-            return;
-        const ownFeatures = features.filter((f) => registration.layerIds.includes(f.layer.id));
-        registration.handler(ownFeatures, evt);
-    };
-}
-export const clickManager = new ClickManager();

package/dist/lib/map/integrations/integrations-manager.d.ts

@@ -1,8 +0,0 @@
-import type { SomeMapIntegration } from "./types";
-declare class IntegrationsManager {
-    private integrations;
-    register(...integrations: Array<SomeMapIntegration>): void;
-    refresh(): void;
-}
-export declare const integrationsManager: IntegrationsManager;
-export type { IntegrationsManager };

package/dist/lib/map/integrations/integrations-manager.js

@@ -1,20 +0,0 @@
-import { XMap } from "@tstk/builtin-extensions";
-class IntegrationsManager {
-    integrations = new XMap();
-    register(...integrations) {
-        for (const integration of integrations) {
-            this.integrations.set(integration.referenceId, integration);
-        }
-    }
-    refresh() {
-        for (const integration of this.integrations.values()) {
-            if (integration.enabled) {
-                integration.apply();
-            }
-            else if (integration.remove) {
-                integration.remove();
-            }
-        }
-    }
-}
-export const integrationsManager = new IntegrationsManager();

package/dist/lib/map/integrations/map-display-option.svelte.d.ts

@@ -1,7 +0,0 @@
-import { MapImageIcon } from "./types";
-export declare class MapDisplayOption {
-    icon?: MapImageIcon;
-    label: string;
-    value: boolean;
-    constructor(label: string, value: boolean, icon?: MapImageIcon);
-}

package/dist/lib/map/integrations/map-display-option.svelte.js

@@ -1,10 +0,0 @@
-export class MapDisplayOption {
-    icon;
-    label;
-    value;
-    constructor(label, value, icon) {
-        this.icon = icon;
-        this.label = label;
-        this.value = $state(value);
-    }
-}

package/dist/lib/map/integrations/map-geojson-integration.svelte.d.ts

@@ -1,32 +0,0 @@
-import type { Map as MaptilerMap } from "@maptiler/sdk";
-import type { Feature, Geometry } from "geojson";
-import type { MapIconManager } from "./map-icon-manager";
-import { MapLayerIntegration } from "./map-layer-integration.svelte";
-export declare abstract class MapGeoJSONIntegration<T = Record<string, unknown>> extends MapLayerIntegration {
-    abstract features: Array<Feature<Geometry, T>>;
-    abstract mapSource: Parameters<MaptilerMap["addSource"]>[1];
-    remove(): void;
-    /**
-     * Removes only this integration's own layer and source. Non-virtual on purpose: `apply()`
-     * paths call it to clear stale map state before re-adding, without triggering a subclass's
-     * `remove()` override (which also tears down tooltips/click handlers that apply just set up).
-     */
-    protected removeLayerAndSource(): void;
-}
-export declare abstract class MapIconLayerIntegration<T = Record<string, unknown>> extends MapGeoJSONIntegration<T> {
-    abstract icons: MapIconManager;
-    private generation;
-    /**
-     * Drops every callback still waiting on icons. `apply()` and `remove()` call it, so a
-     * subclass overriding `apply()` without calling `super.apply()` first must call it itself.
-     */
-    protected supersedePending(): void;
-    /**
-     * Runs `run` once the icons have loaded, unless an `apply()` or `remove()` has happened
-     * since (the state it was scheduled for is gone) or a basemap change is in flight (the
-     * refresh on "style.load" re-applies).
-     */
-    protected whenIconsLoad(run: () => void): void;
-    apply(): void;
-    remove(): void;
-}

package/dist/lib/map/integrations/map-geojson-integration.svelte.js

@@ -1,60 +0,0 @@
-import { MapLayerIntegration } from "./map-layer-integration.svelte";
-import { mapManager } from "../map-manager.svelte.js";
-export class MapGeoJSONIntegration extends MapLayerIntegration {
-    remove() {
-        this.removeLayerAndSource();
-    }
-    /**
-     * Removes only this integration's own layer and source. Non-virtual on purpose: `apply()`
-     * paths call it to clear stale map state before re-adding, without triggering a subclass's
-     * `remove()` override (which also tears down tooltips/click handlers that apply just set up).
-     */
-    removeLayerAndSource() {
-        if (mapManager.map?.getLayer(this.referenceId)) {
-            mapManager.map.removeLayer(this.referenceId);
-        }
-        if (mapManager.map?.getSource(this.referenceId)) {
-            mapManager.map.removeSource(this.referenceId);
-        }
-    }
-}
-export class MapIconLayerIntegration extends MapGeoJSONIntegration {
-    generation = 0;
-    /**
-     * Drops every callback still waiting on icons. `apply()` and `remove()` call it, so a
-     * subclass overriding `apply()` without calling `super.apply()` first must call it itself.
-     */
-    supersedePending() {
-        this.generation++;
-    }
-    /**
-     * Runs `run` once the icons have loaded, unless an `apply()` or `remove()` has happened
-     * since (the state it was scheduled for is gone) or a basemap change is in flight (the
-     * refresh on "style.load" re-applies).
-     */
-    whenIconsLoad(run) {
-        const generation = this.generation;
-        this.icons
-            .loadIcons()
-            .then(() => {
-            if (generation !== this.generation || mapManager.styleLoading)
-                return;
-            run();
-        })
-            .catch(console.error);
-    }
-    apply() {
-        if (!mapManager.map)
-            return;
-        this.supersedePending();
-        this.whenIconsLoad(() => {
-            this.removeLayerAndSource();
-            mapManager.map?.addSource(this.referenceId, this.mapSource);
-            super.apply();
-        });
-    }
-    remove() {
-        this.supersedePending();
-        super.remove();
-    }
-}

package/dist/lib/map/integrations/map-icon-manager.d.ts

@@ -1,15 +0,0 @@
-import type { Map as MaptilerMap } from "@maptiler/sdk";
-import type { MapImageIcon } from "./types";
-import { SvelteMap } from "svelte/reactivity";
-export declare class MapIconManager {
-    protected icons: SvelteMap<string, MapImageIcon>;
-    constructor(iconMap?: SvelteMap<string, MapImageIcon>);
-    get iter(): MapIterator<[string, MapImageIcon]>;
-    get(id: string): MapImageIcon | undefined;
-    has(id: string): boolean;
-    loadIcons(): Promise<void>;
-    register(id: string, icon: HTMLImageElement): void;
-    protected loadImage(icon: MapImageIcon, map: MaptilerMap): Promise<void>;
-    protected updateImage(icon: MapImageIcon, map: MaptilerMap): Promise<void>;
-    private applyImage;
-}

package/dist/lib/map/integrations/map-icon-manager.js

@@ -1,52 +0,0 @@
-import { mapManager } from "../map-manager.svelte.js";
-import { SvelteMap } from "svelte/reactivity";
-export class MapIconManager {
-    icons = new SvelteMap();
-    constructor(iconMap) {
-        if (iconMap) {
-            this.icons = iconMap;
-        }
-    }
-    get iter() {
-        return this.icons.entries();
-    }
-    get(id) {
-        return this.icons.get(id);
-    }
-    has(id) {
-        return this.icons.has(id);
-    }
-    async loadIcons() {
-        if (!mapManager.map)
-            return;
-        await Promise.all(this.icons.values().map((icon) => this.loadImage(icon, mapManager.map)));
-    }
-    register(id, icon) {
-        const imageIcon = { id, image: icon };
-        this.icons.set(id, imageIcon);
-    }
-    loadImage(icon, map) {
-        return this.applyImage("add", icon, map);
-    }
-    updateImage(icon, map) {
-        return this.applyImage("update", icon, map);
-    }
-    applyImage(action, icon, map) {
-        const apply = () => action === "add" ? map.addImage(icon.id, icon.image) : map.updateImage(icon.id, icon.image);
-        if (!icon.image.complete) {
-            return new Promise((resolve, reject) => {
-                icon.image.onload = () => {
-                    apply();
-                    resolve();
-                };
-                icon.image.onerror = (err) => {
-                    reject(new Error(`Failed to load image ${icon.id}: ${err}`, { cause: err }));
-                };
-            });
-        }
-        else {
-            apply();
-            return Promise.resolve();
-        }
-    }
-}

package/dist/lib/map/integrations/map-integration.svelte.d.ts

@@ -1,6 +0,0 @@
-export declare abstract class MapIntegration {
-    abstract referenceId: string;
-    abstract enabled: boolean;
-    abstract apply(): void;
-    remove?(): void;
-}

package/dist/lib/map/integrations/map-integration.svelte.js

@@ -1,2 +0,0 @@
-export class MapIntegration {
-}

package/dist/lib/map/integrations/map-layer-integration.svelte.d.ts

@@ -1,11 +0,0 @@
-import type { Map as MaptilerMap } from "@maptiler/sdk";
-import { MapIntegration } from "./map-integration.svelte";
-export declare abstract class MapLayerIntegration extends MapIntegration {
-    abstract referenceId: string;
-    abstract mapLayer: Parameters<MaptilerMap["addLayer"]>[0];
-    abstract enabled: boolean;
-    beforeLayer?: string;
-    constructor();
-    apply(): void;
-    remove(): void;
-}

package/dist/lib/map/integrations/map-layer-integration.svelte.js

@@ -1,40 +0,0 @@
-import { untrack } from "svelte";
-import { mapManager } from "../map-manager.svelte.js";
-import { MapIntegration } from "./map-integration.svelte";
-export class MapLayerIntegration extends MapIntegration {
-    beforeLayer;
-    constructor() {
-        super();
-        // Each integration manages its own lifecycle. Tracking both mapManager.map and
-        // this.enabled means apply/remove fire automatically on map load and on enabled
-        // changes. untrack on the call itself prevents reactive reads inside apply/remove
-        // from leaking back into this effect's dependency graph. While a new basemap style is
-        // loading nothing is applied or removed: the refresh on "style.load" does both.
-        $effect.root(() => {
-            $effect(() => {
-                const enabled = this.enabled;
-                if (!mapManager.map || mapManager.styleLoading)
-                    return;
-                if (enabled) {
-                    untrack(() => this.apply());
-                }
-                else {
-                    untrack(() => this.remove());
-                }
-            });
-        });
-    }
-    apply() {
-        if (!mapManager.map)
-            return;
-        if (!mapManager.map.getLayer(this.referenceId)) {
-            mapManager.map.addLayer(this.mapLayer, this.beforeLayer);
-        }
-        mapManager.map.setLayoutProperty(this.referenceId, "visibility", this.enabled ? "visible" : "none");
-    }
-    remove() {
-        if (mapManager.map?.getLayer(this.referenceId)) {
-            mapManager.map.removeLayer(this.referenceId);
-        }
-    }
-}

package/dist/lib/map/integrations/tooltip.svelte.d.ts

@@ -1,36 +0,0 @@
-import type { MapLayerEventType, Popup } from "@maptiler/sdk";
-export type TooltipBuilder = (evt: MapLayerEventType["mousemove"] & object) => Popup | void;
-export declare class TooltipManager {
-    static activeHandle: TooltipHandle | null;
-    /**
-     * Host-controlled master switch. When false, enable() is a no-op
-     * regardless of how many times or when internal code (e.g. a map
-     * integration's apply()) calls it -- unlike isEnabled below, this is
-     * checked fresh on every enable() call, so it can't be raced by an
-     * apply() invocation that fires before a host sets this to false.
-     */
-    enabled: boolean;
-    private isEnabled;
-    private _tooltips;
-    get tooltips(): MapIterator<TooltipHandle>;
-    enable(layerId?: string): void;
-    disable(layerId?: string): void;
-    get(layerId: string): TooltipHandle | undefined;
-    has(layerId: string): boolean;
-    register(layerId: string, builder: TooltipBuilder, priority?: number): TooltipHandle;
-    with(layerId: string | Array<string>, cb: (tooltip: TooltipHandle) => void): void;
-    private forEachHandle;
-}
-declare class TooltipHandle {
-    layerId: string;
-    priority: number;
-    tooltip: Popup | null;
-    private activeFeatureId;
-    private isEnabled;
-    clearTooltip: () => void;
-    private setTooltip;
-    constructor(layerId: string, builder: TooltipBuilder, priority?: number);
-    enable(): void;
-    disable(): void;
-}
-export {};

package/dist/lib/map/integrations/tooltip.svelte.js

@@ -1,131 +0,0 @@
-import { mapManager } from "../map-manager.svelte.js";
-import { XMap } from "@tstk/builtin-extensions";
-function handleZoom() {
-    TooltipManager.activeHandle?.clearTooltip();
-}
-function setCursorPointer() {
-    mapManager.map.getCanvas().style.cursor = "pointer";
-}
-function setCursorDefault() {
-    mapManager.map.getCanvas().style.cursor = "";
-}
-export class TooltipManager {
-    static activeHandle = null;
-    /**
-     * Host-controlled master switch. When false, enable() is a no-op
-     * regardless of how many times or when internal code (e.g. a map
-     * integration's apply()) calls it -- unlike isEnabled below, this is
-     * checked fresh on every enable() call, so it can't be raced by an
-     * apply() invocation that fires before a host sets this to false.
-     */
-    enabled = true;
-    isEnabled = false;
-    _tooltips = new XMap();
-    get tooltips() {
-        return this._tooltips.values();
-    }
-    enable(layerId) {
-        if (!this.enabled || !mapManager.map || this.isEnabled)
-            return;
-        mapManager.map.on("zoom", handleZoom);
-        this.forEachHandle(layerId, (h) => h.enable());
-        this.isEnabled = true;
-    }
-    disable(layerId) {
-        if (!mapManager.map || !this.isEnabled)
-            return;
-        mapManager.map.off("zoom", handleZoom);
-        this.forEachHandle(layerId, (h) => h.disable());
-        this.isEnabled = false;
-    }
-    get(layerId) {
-        return this._tooltips.get(layerId);
-    }
-    has(layerId) {
-        return this._tooltips.has(layerId);
-    }
-    register(layerId, builder, priority = 0) {
-        const tooltipHandle = new TooltipHandle(layerId, builder, priority);
-        this._tooltips.set(layerId, tooltipHandle);
-        return tooltipHandle;
-    }
-    with(layerId, cb) {
-        const ids = Array.isArray(layerId) ? layerId : [layerId];
-        for (const id of ids) {
-            const tooltip = this._tooltips.get(id);
-            if (tooltip)
-                cb(tooltip);
-        }
-    }
-    forEachHandle(layerId, cb) {
-        if (layerId !== undefined && this._tooltips.has(layerId)) {
-            cb(this._tooltips.get(layerId));
-        }
-        else {
-            for (const h of this.tooltips)
-                cb(h);
-        }
-    }
-}
-class TooltipHandle {
-    layerId;
-    priority;
-    tooltip = null;
-    activeFeatureId = undefined;
-    isEnabled = false;
-    clearTooltip = () => {
-        if (TooltipManager.activeHandle !== this)
-            return;
-        this.tooltip?.remove();
-        this.tooltip = null;
-        TooltipManager.activeHandle = null;
-        this.activeFeatureId = undefined;
-    };
-    setTooltip;
-    constructor(layerId, builder, priority = 0) {
-        this.layerId = layerId;
-        this.priority = priority;
-        this.setTooltip = (evt) => {
-            if (!mapManager.map || !evt.features)
-                return;
-            const featureId = evt.features[0]?.id;
-            const isOwner = TooltipManager.activeHandle === this;
-            const sameFeature = featureId === this.activeFeatureId;
-            if (isOwner && this.tooltip && sameFeature) {
-                this.tooltip.setLngLat(evt.lngLat);
-                return;
-            }
-            const activeHandle = TooltipManager.activeHandle;
-            if (activeHandle !== null && activeHandle !== this && activeHandle.priority >= this.priority)
-                return;
-            activeHandle?.clearTooltip();
-            this.activeFeatureId = undefined;
-            const tooltip = builder(evt);
-            if (tooltip) {
-                this.tooltip = tooltip;
-                TooltipManager.activeHandle = this;
-                this.activeFeatureId = featureId;
-                tooltip.addTo(mapManager.map);
-            }
-        };
-    }
-    enable() {
-        if (!mapManager.map || this.isEnabled)
-            return;
-        mapManager.map.on("mousemove", this.layerId, setCursorPointer);
-        mapManager.map.on("mouseleave", this.layerId, setCursorDefault);
-        mapManager.map.on("mousemove", this.layerId, this.setTooltip);
-        mapManager.map.on("mouseleave", this.layerId, this.clearTooltip);
-        this.isEnabled = true;
-    }
-    disable() {
-        if (!mapManager.map || !this.isEnabled)
-            return;
-        this.clearTooltip();
-        mapManager.map.off("mousemove", this.layerId, setCursorPointer);
-        mapManager.map.off("mouseleave", this.layerId, setCursorDefault);
-        mapManager.map.off("mousemove", this.layerId, this.setTooltip);
-        mapManager.map.off("mouseleave", this.layerId, this.clearTooltip);
-        this.isEnabled = false;
-    }
-}

package/dist/lib/map/integrations/types.d.ts

@@ -1,14 +0,0 @@
-import type { MapLayerEventType, Map as MaptilerMap, Popup } from "@maptiler/sdk";
-import type { MapIntegration } from "./map-integration.svelte";
-import type { MapGeoJSONIntegration, MapIconLayerIntegration } from "./map-geojson-integration.svelte";
-export type TooltipPopup = <T extends TooltipController>(mapCtrl: T) => (evt: MapLayerEventType["mousemove"] & object) => void;
-export type SomeMapIntegration = MapIntegration | MapGeoJSONIntegration<Record<string, unknown>> | MapIconLayerIntegration<Record<string, unknown>>;
-interface TooltipController {
-    tooltip: Popup | null;
-    map?: MaptilerMap;
-}
-export interface MapImageIcon {
-    id: string;
-    image: HTMLImageElement;
-}
-export {};

package/dist/lib/map/integrations/types.js

@@ -1 +0,0 @@
-export {};

package/dist/lib/map/map-manager.svelte.d.ts

@@ -1,20 +0,0 @@
-import { MapStyleVariant, Map as MaptilerMap } from "@maptiler/sdk";
-import type { Attachment } from "svelte/attachments";
-import type { Feature, GeoJsonProperties, Geometry } from "geojson";
-export declare const DefaultMapStyle: MapStyleVariant;
-declare class MapManager {
-    map: MaptilerMap | null;
-    /**
-     * True between `setStyle()` and the new style's "style.load". Plain (non-reactive) on purpose:
-     * integrations skip touching the style while it's set, and the `integrationsManager.refresh()`
-     * that runs on "style.load" applies/removes every integration afterwards.
-     */
-    styleLoading: boolean;
-    setDataSource(sourceId: string, features: Array<Feature<Geometry, GeoJsonProperties>>): void;
-    refreshMap(): void;
-    removeExcludedLayers(): void;
-    removeMap(): void;
-}
-export declare const mapManager: MapManager;
-export type { MapManager };
-export declare const initializeMap: Attachment<HTMLDivElement>;

package/dist/lib/map/map-manager.svelte.js

@@ -1,63 +0,0 @@
-import { MapStyle, config as MaptilerConfig, Map as MaptilerMap } from "@maptiler/sdk";
-import { isGeoJSONSource } from "./utils";
-MaptilerConfig.apiKey = import.meta.env.VITE_MAPTILER_KEY;
-export const DefaultMapStyle = MapStyle.STREETS_V4.DEFAULT;
-const excludeLayers = ["Sport", "Tourism", "Culture", "Shopping", "Food", "Transport"];
-class MapManager {
-    map = $state(null);
-    /**
-     * True between `setStyle()` and the new style's "style.load". Plain (non-reactive) on purpose:
-     * integrations skip touching the style while it's set, and the `integrationsManager.refresh()`
-     * that runs on "style.load" applies/removes every integration afterwards.
-     */
-    styleLoading = false;
-    setDataSource(sourceId, features) {
-        const source = mapManager.map?.getSource(sourceId);
-        if (isGeoJSONSource(source)) {
-            source.setData({
-                type: "FeatureCollection",
-                features
-            });
-        }
-    }
-    refreshMap() {
-        if (mapManager.map) {
-            this.removeExcludedLayers();
-        }
-    }
-    removeExcludedLayers() {
-        for (const toExclude of excludeLayers) {
-            if (mapManager.map?.getLayer(toExclude)) {
-                mapManager.map.removeLayer(toExclude);
-            }
-        }
-    }
-    removeMap() {
-        return mapManager.map?.remove();
-    }
-}
-export const mapManager = new MapManager();
-export const initializeMap = (container) => {
-    const map = new MaptilerMap({
-        container: container,
-        center: [-119.7987626619462, 36.76272050981146],
-        zoom: 7,
-        style: DefaultMapStyle,
-        projection: "globe",
-        space: {
-            preset: "milkyway"
-        }
-    });
-    // "load" fires once the style and initial viewport tiles have loaded --
-    // in practice this can hang indefinitely (observed: never fires, even
-    // after 20+s, despite the style/tiles being independently fetchable) for
-    // reasons that don't affect "idle", which fires once the map has
-    // finished rendering after becoming idle. MapShell's own effect no
-    // longer waits for a *second* idle event to hide the load screen (see
-    // its comment), so listening for "idle" here doesn't reintroduce the
-    // hang that change was fixing.
-    map.once("idle", () => {
-        mapManager.map = map;
-    });
-    return () => map.remove();
-};

package/dist/lib/map/map-style-state.svelte.d.ts

@@ -1,23 +0,0 @@
-import type { MapStyleVariant, ReferenceMapStyle } from "@maptiler/sdk";
-/** Basemap + theme selection, shared so the Settings menu and Reset Map Options agree. */
-declare class MapStyleState {
-    referenceStyle: ReferenceMapStyle;
-    variant: MapStyleVariant;
-    private applied;
-    private loaded;
-    private stopWaiting;
-    selectReferenceStyle(style: ReferenceMapStyle): void;
-    selectVariant(variant: MapStyleVariant): void;
-    reset(): void;
-    private apply;
-    private load;
-    /**
-     * A style that fails to load leaves the map with no style at all, so go back to the last one
-     * that loaded and make the selection say so. When that one fails too (e.g. offline) there is
-     * nothing to draw on: `styleLoading` stays set, since integrations cannot add layers to a
-     * missing style, and the next selection starts a fresh attempt.
-     */
-    private recover;
-}
-export declare const mapStyleState: MapStyleState;
-export type { MapStyleState };