@sjvair/map-sdk 0.0.0-stage → 0.1.0-beta.10

package/dist/core/plugin-host.svelte.js

@@ -0,0 +1,445 @@
+import { untrack } from "svelte";
+/** Setup runs on whichever of these fires first. */
+const STYLE_READY_EVENTS = ["style.load", "idle"];
+/**
+ * Marks a plugin object with the host it is set up on, while it is. A plugin object keeps
+ * per-map state (its source and layer ids, its features), so it belongs to one map at a time.
+ * A property on the plugin, not a registry: nothing here is shared between maps.
+ */
+const OWNER = Symbol("map-sdk plugin host");
+function ownedElsewhere(plugin, host) {
+    const owner = plugin[OWNER];
+    return owner !== undefined && owner !== host;
+}
+function ownershipError(plugin) {
+    return new Error(`map-sdk: plugin "${plugin.id}" is already set up on another map; create one plugin per map`);
+}
+/**
+ * Runs plugins against a GL map. Plugins are set up only when the map's style is loaded, and
+ * everything they add through their `PluginContext` is removed on teardown, whatever their own
+ * teardown does. The plugin list outlives any one GL map.
+ *
+ * Setup never runs inside the caller's code. When `add` or `attach` would set plugins up, they
+ * are queued and set up in one microtask, where no effect is active: Svelte cuts loose the
+ * `$effect.root`s created inside an effect when that effect re-runs, and their effects can stop
+ * (see docs/superpowers/specs/2026-11-07-plugin-setup-outside-effects-design.md). Setup on a
+ * style load or `restyle` comes from map events, not host code, and stays synchronous.
+ *
+ * Plugins draw in list order, later on top: each plugin's layers stay together, below the first
+ * layer of the next plugin in the list that has any.
+ */
+export class PluginHost {
+    #opts;
+    #plugins = $state.raw([]);
+    // Bookkeeping only; nothing reads it reactively.
+    // eslint-disable-next-line svelte/prefer-svelte-reactivity
+    #running = new Map();
+    #gl = null;
+    /** True once the current gl's style has loaded and plugins are set up on it. */
+    #live = false;
+    /**
+     * The pending one-shot listener on `#gl` for `style.load` and `idle`, if waiting. `idle` covers
+     * a style that already loaded while `isStyleLoaded()` is false because sources are loading.
+     */
+    #onStyleLoad = null;
+    /** True from scheduling a queued setup run until it starts. */
+    #setupQueued = false;
+    constructor(opts) {
+        this.#opts = opts;
+    }
+    /** In draw order, bottom first. Reactive. */
+    get plugins() {
+        return this.#plugins;
+    }
+    /** True while a setup run is queued and has not started. Not reactive. */
+    get pending() {
+        return this.#setupQueued;
+    }
+    /**
+     * The host's own reads are untracked, so calling `add`, `attach`, etc. from inside an effect
+     * doesn't make that effect depend on the plugin list.
+     */
+    get #list() {
+        return untrack(() => this.#plugins);
+    }
+    /**
+     * Adds `plugin` on top, or just below the plugin `before` names. It is in `plugins` at once;
+     * on a live map its setup runs in a microtask. Throws when the same plugin object is set up on
+     * another map at the moment (one plugin object per map).
+     */
+    add(plugin, before) {
+        if (this.#list.some((p) => p.id === plugin.id)) {
+            throw new Error(`map-sdk: a plugin with id "${plugin.id}" is already added`);
+        }
+        if (ownedElsewhere(plugin, this))
+            throw ownershipError(plugin);
+        this.#plugins = this.#inserted(this.#list, plugin, before);
+        if (this.#live)
+            this.#queueSetup();
+    }
+    /**
+     * Moves a plugin to the top, or just below the plugin `before` names, with its layers. Does
+     * nothing for an unknown `id` or when `before` is `id`.
+     */
+    move(id, before) {
+        const plugin = this.#list.find((p) => p.id === id);
+        if (!plugin || before === id)
+            return;
+        this.#plugins = this.#inserted(this.#list.filter((p) => p !== plugin), plugin, before);
+        const running = this.#running.get(id);
+        if (!running || running.gl !== this.#gl)
+            return;
+        const { gl } = running;
+        const beforeId = this.#layerAbove(id);
+        for (const layerId of running.layers) {
+            try {
+                if (gl.getLayer(layerId))
+                    gl.moveLayer(layerId, beforeId);
+            }
+            catch (error) {
+                console.error(`map-sdk: plugin "${id}" moving layer ${layerId} failed`, error);
+            }
+        }
+    }
+    /** `list` with `plugin` inserted before `before` (at the end without it). */
+    #inserted(list, plugin, before) {
+        if (before === undefined)
+            return [...list, plugin];
+        const at = list.findIndex((p) => p.id === before);
+        if (at < 0)
+            throw new Error(`map-sdk: no plugin with id "${before}"`);
+        return [...list.slice(0, at), plugin, ...list.slice(at)];
+    }
+    /**
+     * The bottom layer of the plugins drawn above `pluginId` on the current gl: where its layers
+     * go. `undefined` (the top) when none above has a layer.
+     */
+    #layerAbove(pluginId) {
+        const gl = this.#gl;
+        if (!gl)
+            return undefined;
+        const list = this.#list;
+        for (const plugin of list.slice(list.findIndex((p) => p.id === pluginId) + 1)) {
+            const running = this.#running.get(plugin.id);
+            if (running?.gl !== gl)
+                continue;
+            const layerId = running.layers.find((l) => gl.getLayer(l));
+            if (layerId !== undefined)
+                return layerId;
+        }
+        return undefined;
+    }
+    remove(id) {
+        if (!this.#list.some((p) => p.id === id))
+            return;
+        this.#teardown(id);
+        const plugin = this.#list.find((p) => p.id === id);
+        if (plugin)
+            this.#release(plugin);
+        this.#plugins = this.#list.filter((p) => p.id !== id);
+    }
+    /**
+     * Uses `gl` from now on, setting up every plugin once its style is loaded (in a microtask when
+     * it already is).
+     */
+    attach(gl) {
+        if (this.#gl === gl)
+            return;
+        if (this.#gl)
+            this.detach();
+        this.#gl = gl;
+        this.#whenStyleLoaded(false);
+    }
+    /**
+     * Tears every plugin down and stops waiting for a style, before the map's style is replaced:
+     * nothing may touch a style on its way out. `restyle` sets them up again.
+     */
+    suspend() {
+        if (!this.#gl)
+            return;
+        this.#cancelStyleWait();
+        this.#teardownAll();
+    }
+    /**
+     * Tears down and sets up every plugin again (after a basemap or theme change), once the style
+     * loads. Pass `styleLoaded` from a `style.load` listener: `isStyleLoaded()` stays false there
+     * until every tile has loaded, and `style.load` has already fired, so waiting would last until
+     * `idle`. A live host's style is loaded too (`suspend` comes before every `setStyle`), so a theme
+     * change sets up at once as well. On a loaded style the setup is synchronous, so only map events
+     * and theme watching call this, never code inside an effect: roots created there can stop (see
+     * the class comment).
+     */
+    restyle(styleLoaded = false) {
+        if (!this.#gl)
+            return;
+        const loaded = styleLoaded || this.#live;
+        this.#teardownAll();
+        if (loaded) {
+            this.#cancelStyleWait();
+            this.#setupAll();
+        }
+        else {
+            this.#whenStyleLoaded(true);
+        }
+    }
+    /** Tears down every plugin. The gl is not touched after this returns. */
+    detach() {
+        const gl = this.#gl;
+        if (!gl)
+            return;
+        this.#cancelStyleWait();
+        this.#teardownAll();
+        this.#gl = null;
+    }
+    /**
+     * Sets every plugin up once the style is loaded. On a style that already is, `now` sets them up
+     * synchronously (only for callers that never run inside an effect); otherwise they are queued.
+     */
+    #whenStyleLoaded(now) {
+        const gl = this.#gl;
+        this.#cancelStyleWait();
+        if (gl.isStyleLoaded()) {
+            if (now) {
+                this.#setupAll();
+            }
+            else {
+                // Live already, so an `add` before the microtask joins the queued run.
+                this.#live = true;
+                this.#queueSetup();
+            }
+            return;
+        }
+        const onStyleLoad = () => {
+            // Stale if the host was detached, re-attached, or restyled since.
+            if (this.#onStyleLoad !== onStyleLoad || this.#gl !== gl)
+                return;
+            this.#cancelStyleWait();
+            this.#setupAll();
+        };
+        this.#onStyleLoad = onStyleLoad;
+        for (const type of STYLE_READY_EVENTS)
+            gl.on(type, onStyleLoad);
+    }
+    /**
+     * Sets every plugin that isn't running up in a microtask, on whichever gl is live by then.
+     * Detach, suspend, and restyle clear `#live`, and only a loaded current gl sets it again, so
+     * the run never touches a gl that left. One run covers every request made before it starts.
+     */
+    #queueSetup() {
+        // Claim the queued plugins now, so another map can't take one before the run.
+        for (const plugin of this.#list)
+            this.#claim(plugin);
+        if (this.#setupQueued)
+            return;
+        this.#setupQueued = true;
+        queueMicrotask(() => {
+            this.#setupQueued = false;
+            if (this.#live)
+                this.#setupAll();
+            this.#opts.onSettled?.();
+        });
+    }
+    /** Marks `plugin` as this host's, unless another map holds it. */
+    #claim(plugin) {
+        if (!ownedElsewhere(plugin, this) && Object.isExtensible(plugin)) {
+            plugin[OWNER] = this;
+        }
+    }
+    /** Releases a plugin this host claimed but isn't running (queued, then removed or left). */
+    #release(plugin) {
+        const owned = plugin;
+        if (owned[OWNER] === this && !this.#running.has(plugin.id))
+            delete owned[OWNER];
+    }
+    #cancelStyleWait() {
+        const listener = this.#onStyleLoad;
+        if (listener && this.#gl) {
+            for (const type of STYLE_READY_EVENTS)
+                this.#gl.off(type, listener);
+        }
+        this.#onStyleLoad = null;
+    }
+    #setupAll() {
+        const gl = this.#gl;
+        this.#live = true;
+        for (const plugin of this.#list) {
+            // A plugin's setup may add, remove, or detach; follow the host's current state.
+            if (this.#gl !== gl || !this.#live)
+                return;
+            if (!this.#list.includes(plugin) || this.#running.has(plugin.id))
+                continue;
+            // Another map set this plugin object up after it was added here.
+            if (ownedElsewhere(plugin, this)) {
+                console.error(ownershipError(plugin));
+                continue;
+            }
+            this.#setup(plugin);
+        }
+    }
+    #teardownAll() {
+        this.#live = false;
+        for (const plugin of this.#list) {
+            this.#teardown(plugin.id);
+            this.#release(plugin);
+        }
+    }
+    #setup(plugin) {
+        const gl = this.#gl;
+        const running = {
+            plugin,
+            gl,
+            dead: false,
+            teardown: null,
+            effects: [],
+            layers: [],
+            sources: [],
+            images: [],
+            listeners: [],
+            unregisters: []
+        };
+        this.#running.set(plugin.id, running);
+        if (Object.isExtensible(plugin))
+            plugin[OWNER] = this;
+        const ctx = this.#context(plugin.id, running);
+        let teardown;
+        try {
+            // Untracked, in case a plugin's setup reads state (setup runs from a microtask or a map
+            // event, never inside the caller's effect).
+            teardown = untrack(() => plugin.setup(ctx));
+        }
+        catch (error) {
+            console.error(`map-sdk: plugin "${plugin.id}" setup failed`, error);
+            if (this.#running.get(plugin.id) === running)
+                this.#teardown(plugin.id);
+            return;
+        }
+        if (!running.dead) {
+            running.teardown = teardown;
+            return;
+        }
+        // Torn down during its own setup (it removed itself or detached the host).
+        try {
+            untrack(teardown);
+        }
+        catch (error) {
+            console.error(`map-sdk: plugin "${plugin.id}" teardown failed`, error);
+        }
+    }
+    #teardown(pluginId) {
+        const running = this.#running.get(pluginId);
+        if (!running)
+            return;
+        this.#running.delete(pluginId);
+        running.dead = true;
+        const owned = running.plugin;
+        if (owned[OWNER] === this)
+            delete owned[OWNER];
+        const { gl } = running;
+        const attempt = (what, fn) => {
+            try {
+                fn();
+            }
+            catch (error) {
+                console.error(`map-sdk: plugin "${pluginId}" ${what} failed`, error);
+            }
+        };
+        // Effects stop first so none re-runs against a half-removed plugin.
+        for (const stop of running.effects)
+            attempt("effect cleanup", stop);
+        if (running.teardown)
+            attempt("teardown", untrack.bind(null, running.teardown));
+        // A style change may already have dropped these, so check before removing.
+        for (const id of running.layers.toReversed()) {
+            attempt(`removing layer ${id}`, () => gl.getLayer(id) && gl.removeLayer(id));
+        }
+        for (const id of running.sources.toReversed()) {
+            attempt(`removing source ${id}`, () => gl.getSource(id) && gl.removeSource(id));
+        }
+        for (const id of running.images) {
+            attempt(`removing image ${id}`, () => gl.hasImage(id) && gl.removeImage(id));
+        }
+        for (const { type, layerId, listener } of running.listeners) {
+            attempt(`removing ${type} listener`, () => gl.off(type, layerId, listener));
+        }
+        for (const unregister of running.unregisters)
+            attempt("unregistering", unregister);
+    }
+    #context(pluginId, running) {
+        const { mapUid, providers, router, selectedKeys } = this.#opts;
+        const { gl } = running;
+        const layerAbove = () => this.#layerAbove(pluginId);
+        const id = (local) => `${mapUid}:${pluginId}:${local}`;
+        const addTracked = (full, layer) => {
+            if (running.dead)
+                return full;
+            gl.addLayer(layer, layerAbove());
+            // A re-added layer (a plugin rebuilding its layers) is now its plugin's top layer.
+            const at = running.layers.indexOf(full);
+            if (at >= 0)
+                running.layers.splice(at, 1);
+            running.layers.push(full);
+            return full;
+        };
+        return {
+            gl,
+            id,
+            metadata: providers.metadata,
+            messages: providers.messages,
+            format: providers.format,
+            addSource(local, spec) {
+                const full = id(local);
+                if (running.dead)
+                    return full;
+                gl.addSource(full, spec);
+                running.sources.push(full);
+                return full;
+            },
+            addLayer(local, spec) {
+                return addTracked(id(local), { ...spec, id: id(local) });
+            },
+            addCustomLayer(local, create) {
+                const full = id(local);
+                if (running.dead)
+                    return full;
+                const layer = create(full);
+                if (layer.id !== full) {
+                    throw new Error(`map-sdk: custom layer "${local}" must use the id it is given (${full})`);
+                }
+                return addTracked(full, layer);
+            },
+            addImage(local, image) {
+                if (running.dead)
+                    return;
+                const full = id(local);
+                gl.addImage(full, image);
+                running.images.push(full);
+            },
+            interactive(layerIds, toHit) {
+                if (running.dead)
+                    return;
+                running.unregisters.push(router.register(pluginId, layerIds, toHit, running.plugin.hoverPriority ?? 0, running.plugin.hoverable ?? true));
+            },
+            blocking(layerIds, toHover, onClick) {
+                if (running.dead)
+                    return;
+                running.unregisters.push(router.registerBlocking(pluginId, layerIds, toHover, onClick, running.plugin.hoverPriority ?? 0, running.plugin.hoverable ?? true));
+            },
+            on(type, layerId, listener) {
+                if (running.dead)
+                    return;
+                gl.on(type, layerId, listener);
+                running.listeners.push({ type, layerId, listener });
+            },
+            get selectedKeys() {
+                return selectedKeys(pluginId);
+            },
+            effect(fn) {
+                if (running.dead)
+                    return;
+                running.effects.push($effect.root(() => {
+                    $effect(fn);
+                }));
+            }
+        };
+    }
+}

package/dist/core/plugin.d.ts

@@ -0,0 +1,190 @@
+import type { CustomLayerInterface, LayerSpecification, SourceSpecification } from "@maptiler/sdk";
+import type { Geometry } from "geojson";
+import type { Snippet } from "svelte";
+import type { FormatProvider } from "../data/format.js";
+import type { MessageProvider } from "../data/messages.js";
+import type { MetadataProvider } from "../data/metadata.js";
+import type { NO_LEVEL } from "../data/scale.js";
+import type { Level, Scale } from "../data/scale-types.js";
+import type { DataStatus, FeatureRef } from "../data/types.js";
+import type { GlMapLike } from "./gl.js";
+export type Providers = {
+    metadata: MetadataProvider;
+    messages: MessageProvider;
+    format: FormatProvider;
+};
+/**
+ * A layer spec without its id (the host assigns it). Distributive: `Omit` over the
+ * `LayerSpecification` union would keep only the keys every layer type shares, losing `source`.
+ */
+export type LayerSpecWithoutId = LayerSpecification extends infer L ? L extends unknown ? Omit<L, "id"> : never : never;
+export interface FeatureHit {
+    pluginId: string;
+    ref: FeatureRef;
+    refKey: string;
+    name: string;
+    /**
+     * The rendered feature's properties, for hover content of a hit no plugin lists (e.g. a
+     * cluster bubble's count and aggregates). Unset for ordinary hits.
+     */
+    properties?: Readonly<Record<string, unknown>>;
+}
+/** The topmost feature of a blocking layer that was clicked. */
+export interface BlockingClick {
+    properties: Record<string, unknown>;
+    geometry: Geometry;
+}
+export interface FeatureListItem {
+    refKey: string;
+    ref: FeatureRef;
+    name: string;
+    value: number | string | null;
+    level: Level | typeof NO_LEVEL;
+    units: string;
+    /**
+     * Decimal places to show a numeric `value` with (the built-in plugins take it from the
+     * metadata's display hint). Without it the value is formatted as given.
+     */
+    precision?: number;
+    /**
+     * Cut a numeric `value` off at `precision` instead of rounding it, so the number never reads
+     * as the next level (e.g. fire power: 9.96 MW shows "9.9", not "10.0", beside "<10"). Default
+     * false.
+     */
+    truncate?: boolean;
+    lngLat: [number, number];
+    /**
+     * The feature's shape. When given, the item is in view (the feature list, the view summary)
+     * when the shape overlaps the view, not only when `lngLat` is inside it, and focusing or
+     * hovering it while `lngLat` is off-screen pins its tooltip at a point of the shape in view
+     * (focus then leaves the camera where it is).
+     */
+    geometry?: Geometry;
+    /**
+     * `geometry`'s bounding box, `[west, south, east, north]` (`geometryBbox`). Optional; computed
+     * from `geometry` when missing. A plugin listing many shapes should measure it once per data
+     * load, since the list and summary test every item on every move.
+     */
+    bbox?: [number, number, number, number];
+    selectable: boolean;
+    /**
+     * A short text about a feature with no level (e.g. "Level 2 charger"), shown where its level
+     * would be: in the feature list, its row's accessible name, and the generic tooltip. Ignored
+     * when the item has a level.
+     */
+    detail?: string;
+}
+export type LegendData = {
+    pluginId: string;
+    title: string;
+    units: string;
+    scale: Scale;
+    /**
+     * `"gradient"` or `"blocks"` (labeled swatches with the levels' own labels). Absent: a
+     * gradient for range scales and blocks for category scales.
+     */
+    display?: "gradient" | "blocks";
+} | {
+    pluginId: string;
+    status: DataStatus;
+};
+export interface ClickEvent {
+    hits: FeatureHit[];
+    /** `modifier || touch`: today's "add to the selection" in multiple mode. */
+    additive: boolean;
+    /** Shift, ⌘, or Ctrl was held. */
+    modifier: boolean;
+    /** A touch tap. */
+    touch: boolean;
+    /**
+     * A Shift-click that MapLibre's box zoom swallowed (it fires `boxzoomcancel` instead of
+     * `click`). Only `"modifier"` mode acts on it, so other maps behave as before.
+     */
+    boxZoom?: boolean;
+    lngLat: [number, number];
+}
+/**
+ * What a plugin's `setup` gets. Everything added through it is removed automatically when the
+ * plugin is torn down, whether or not the plugin's own teardown cleans up.
+ */
+export interface PluginContext {
+    /**
+     * The GL map. Don't use it after teardown: do late async work (an image that finishes
+     * loading, a fetch) through the context's methods, which do nothing once torn down.
+     */
+    readonly gl: GlMapLike;
+    /** `${mapUid}:${pluginId}:${local}` */
+    id(local: string): string;
+    readonly metadata: MetadataProvider;
+    readonly messages: MessageProvider;
+    readonly format: FormatProvider;
+    /** Returns the namespaced id; removed on teardown. */
+    addSource(local: string, spec: SourceSpecification): string;
+    /** Returns the namespaced id; removed on teardown, before sources. */
+    addLayer(local: string, spec: LayerSpecWithoutId): string;
+    /**
+     * Adds a MapLibre custom layer (e.g. a wind layer from a library the host adds) in the
+     * plugin's draw-order slot, with the same lifecycle as `addLayer`. `create` gets the
+     * namespaced id, which the layer must use; the object it returns is added as is, never copied,
+     * and `create` runs again on each restyle, so build a fresh layer every time. Returns the id.
+     */
+    addCustomLayer(local: string, create: (id: string) => CustomLayerInterface): string;
+    /** Adds the image as `id(local)`; removed on teardown. */
+    addImage(local: string, image: HTMLImageElement | ImageData): void;
+    /** Registers layers for click, hover, tooltip, and `featuresAt`. */
+    interactive(layerIds: string[], toHit: (props: Record<string, unknown>) => FeatureHit | null): void;
+    /**
+     * Layers that hide what is beneath them (e.g. cluster bubbles): where one is topmost, a click
+     * picks nothing and calls `onClick` with that feature, and the hover is `toHover`'s hit for it
+     * (for its tooltip), or nothing. `toHover` must have no side effects (lookups call it too).
+     */
+    blocking(layerIds: string[], toHover?: (props: Record<string, unknown>) => FeatureHit | null, onClick?: (feature: BlockingClick) => void): void;
+    /** A layer event listener (e.g. a cluster click), removed on teardown. */
+    on(type: string, layerId: string, listener: (e: any) => void): void;
+    /** Reactive. */
+    readonly selectedKeys: ReadonlySet<string>;
+    /** An `$effect.root` torn down with the plugin. */
+    effect(fn: () => void | (() => void)): void;
+}
+/**
+ * A layer of data on a map. A plugin object keeps per-map state, so it belongs to one map: create
+ * one plugin per map (adding an object that is set up on another map throws).
+ */
+export interface MapPlugin {
+    id: string;
+    /** Already-translated layer name, for the selection bar and view summary. */
+    label?: string;
+    /** The metadata dataset the plugin's data comes from (for attribution); may change with its source. */
+    readonly dataset?: string;
+    /** Adds sources, layers, and icons; returns its teardown. Runs only once a style is loaded. */
+    setup(ctx: PluginContext): () => void;
+    legend?(): LegendData | null;
+    features?(): FeatureListItem[];
+    selectable?: boolean;
+    /**
+     * Which plugin's feature the hover tooltip shows where several are under the pointer: the
+     * highest wins, the topmost on a tie. Default 0. Over a blocking layer (a cluster bubble), a
+     * feature beneath shows only if its plugin's priority is higher than the blocking plugin's.
+     * Clicks ignore this (topmost first), and a blocking layer on top still blocks them.
+     */
+    hoverPriority?: number;
+    /**
+     * False: the plugin's features never take the hover (so no hover tooltip and no pointer
+     * cursor) and never hide a feature beneath from it, as if they weren't rendered. Clicks,
+     * `featuresAt`, and keyboard focus from the list are unchanged. Default true.
+     */
+    hoverable?: boolean;
+    displayOptions?: Snippet;
+    /** Richer tooltip content for one of this plugin's features, below its name. */
+    tooltip?(item: FeatureListItem): Snippet | undefined;
+    /**
+     * Set when this plugin's `tooltip` content shows the feature's name itself, so the generic
+     * tooltip leaves its name header out. Default false.
+     */
+    tooltipShowsName?: boolean;
+    /**
+     * Tooltip content for a hovered hit that isn't a listed feature (e.g. a cluster bubble's hover
+     * hit from `PluginContext.blocking`).
+     */
+    hoverTooltip?(hit: FeatureHit): Snippet | undefined;
+}

package/dist/core/plugin.js

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

package/dist/core/scoped-context.d.ts

@@ -0,0 +1,7 @@
+import type { PluginContext } from "./plugin.js";
+/**
+ * A view of `ctx` whose local ids all start with `prefix`, so several plugins can be set up
+ * inside one (one id, one teardown) without their sources, layers, and images colliding.
+ * Everything else is the parent's, read live (`selectedKeys` stays reactive).
+ */
+export declare function scopedContext(ctx: PluginContext, prefix: string): PluginContext;

package/dist/core/scoped-context.js

@@ -0,0 +1,34 @@
+/**
+ * A view of `ctx` whose local ids all start with `prefix`, so several plugins can be set up
+ * inside one (one id, one teardown) without their sources, layers, and images colliding.
+ * Everything else is the parent's, read live (`selectedKeys` stays reactive).
+ */
+export function scopedContext(ctx, prefix) {
+    const local = (name) => `${prefix}${name}`;
+    return {
+        get gl() {
+            return ctx.gl;
+        },
+        get metadata() {
+            return ctx.metadata;
+        },
+        get messages() {
+            return ctx.messages;
+        },
+        get format() {
+            return ctx.format;
+        },
+        get selectedKeys() {
+            return ctx.selectedKeys;
+        },
+        id: (name) => ctx.id(local(name)),
+        addSource: (name, spec) => ctx.addSource(local(name), spec),
+        addLayer: (name, spec) => ctx.addLayer(local(name), spec),
+        addCustomLayer: (name, create) => ctx.addCustomLayer(local(name), create),
+        addImage: (name, image) => ctx.addImage(local(name), image),
+        interactive: (layerIds, toHit) => ctx.interactive(layerIds, toHit),
+        blocking: (layerIds, toHover, onClick) => ctx.blocking(layerIds, toHover, onClick),
+        on: (type, layerId, listener) => ctx.on(type, layerId, listener),
+        effect: (fn) => ctx.effect(fn)
+    };
+}