@honua/react 0.0.20-alpha.0

package/map/honua-map.d.ts

@@ -0,0 +1,203 @@
+/**
+ * HonuaMap — Source/Layer separation for multi-protocol geospatial maps.
+ *
+ * Manages named data sources (protocol-aware: Feature Service, Map Service,
+ * OGC Features) separately from named rendering layers. One source can back
+ * multiple layers; layers reference sources by name.
+ *
+ * Does **not** depend on `maplibre-gl` at runtime. Produces a
+ * MapLibre-compatible style via {@link HonuaMap.toStyle} and exposes the
+ * underlying SDK surface instances via {@link HonuaMap.getSource}.
+ *
+ * @module
+ */
+import type { HonuaClient } from "../core/client.js";
+import { HonuaFeatureLayer, HonuaMapService, type HonuaOgcFeatureCollection } from "../core/surfaces.js";
+import type { HonuaWms, HonuaWmsLayer } from "../core/wms.js";
+import type { HonuaWmts, HonuaWmtsLayer, HonuaWmtsTileset } from "../core/wmts.js";
+import type { HonuaLayerSpecification, HonuaSourceSpecification, HonuaStyleSpecification } from "../style/specification.js";
+/** A resolved Honua source: either an SDK surface instance or `null` for native MapLibre sources. */
+export type ResolvedMapSource = HonuaFeatureLayer | HonuaMapService | HonuaOgcFeatureCollection | HonuaWms | HonuaWmsLayer | HonuaWmts | HonuaWmtsLayer | HonuaWmtsTileset | null;
+/** Options for constructing a {@link HonuaMap}. */
+export interface HonuaMapOptions {
+    /** The Honua client used to instantiate protocol surfaces. */
+    client: HonuaClient;
+    /** Optional initial style. Sources and layers are loaded from this. */
+    style?: HonuaStyleSpecification;
+}
+/** Snapshot of a layer with its current properties. */
+export interface LayerSnapshot extends HonuaLayerSpecification {
+    /** The source this layer references. */
+    source: string;
+}
+/** Events emitted by HonuaMap. */
+export type HonuaMapEvent = {
+    type: "source-added";
+    sourceId: string;
+} | {
+    type: "source-updated";
+    sourceId: string;
+} | {
+    type: "source-removed";
+    sourceId: string;
+} | {
+    type: "layer-added";
+    layerId: string;
+} | {
+    type: "layer-updated";
+    layerId: string;
+} | {
+    type: "layer-removed";
+    layerId: string;
+} | {
+    type: "layer-moved";
+    layerId: string;
+    beforeId: string | undefined;
+};
+export type HonuaMapEventListener = (event: HonuaMapEvent) => void;
+/**
+ * A protocol-aware map that separates data sources from rendering layers.
+ *
+ * @example
+ * ```ts
+ * const map = new HonuaMap({ client });
+ *
+ * map.addSource("parcels", {
+ *   type: "honua-feature-service",
+ *   url: "https://gis.example.com/rest/services/parcels/FeatureServer/0",
+ *   definitionExpression: "status = 'active'",
+ * });
+ *
+ * map.addLayer({
+ *   id: "parcel-fill",
+ *   source: "parcels",
+ *   type: "fill",
+ *   paint: { "fill-color": "#088", "fill-opacity": 0.5 },
+ * });
+ *
+ * map.addLayer({
+ *   id: "parcel-labels",
+ *   source: "parcels",
+ *   type: "symbol",
+ *   layout: { "text-field": ["get", "parcel_id"] },
+ * });
+ *
+ * // Access the underlying surface for queries
+ * const parcels = map.getSource("parcels"); // HonuaFeatureLayer
+ * const count = await (parcels as HonuaFeatureLayer).queryFeatureCount();
+ * ```
+ */
+export declare class HonuaMap {
+    #private;
+    constructor(options: HonuaMapOptions);
+    /**
+     * Register a named data source.
+     *
+     * Honua sources (`honua-feature-service`, `honua-map-service`,
+     * `honua-ogc-features`) are resolved into SDK surface instances.
+     * Native MapLibre sources (`vector`, `raster`, `geojson`) are stored
+     * as-is and resolve to `null`.
+     *
+     * @throws If a source with the same name already exists.
+     */
+    addSource(name: string, spec: HonuaSourceSpecification | {
+        type: string;
+        [key: string]: unknown;
+    }): void;
+    /**
+     * Remove a named data source and all layers that reference it.
+     *
+     * @returns The IDs of layers that were removed.
+     */
+    removeSource(name: string): string[];
+    /**
+     * Get the resolved SDK surface for a source.
+     *
+     * Returns `null` for native MapLibre sources (they should be handled
+     * by MapLibre directly). Returns `undefined` if the source does not exist.
+     */
+    getSource(name: string): ResolvedMapSource | undefined;
+    /** Get the raw specification for a source. */
+    getSourceSpec(name: string): HonuaSourceSpecification | {
+        type: string;
+        [key: string]: unknown;
+    } | undefined;
+    /**
+     * Replace a source specification while preserving layers that reference it.
+     *
+     * This updates the resolved SDK surface for Honua custom source types and
+     * leaves render layers in place so callers can decide how to patch the
+     * renderer.
+     *
+     * @throws If the source does not exist.
+     */
+    updateSource(name: string, spec: HonuaSourceSpecification | {
+        type: string;
+        [key: string]: unknown;
+    }): void;
+    /** Check whether a source with the given name exists. */
+    hasSource(name: string): boolean;
+    /** Get all registered source names. */
+    get sourceIds(): string[];
+    /**
+     * Add a rendering layer.
+     *
+     * Layers reference a source by name. Multiple layers can reference the
+     * same source (e.g. a fill layer and a symbol layer over the same
+     * Feature Service).
+     *
+     * @param spec - Layer specification (must include `id`, `source`, `type`).
+     * @param beforeId - Insert this layer before the layer with this ID.
+     *   If omitted, appends to the end.
+     * @throws If the referenced source does not exist.
+     * @throws If a layer with the same ID already exists.
+     */
+    addLayer(spec: HonuaLayerSpecification, beforeId?: string): void;
+    /** Remove a layer by ID. Returns `true` if the layer was found and removed. */
+    removeLayer(id: string): boolean;
+    /** Get a layer specification by ID. */
+    getLayer(id: string): HonuaLayerSpecification | undefined;
+    /**
+     * Patch a layer specification by ID. The layer ID remains stable.
+     *
+     * @throws If the layer does not exist.
+     * @throws If the patched source does not exist.
+     */
+    updateLayer(id: string, patch: Partial<Omit<HonuaLayerSpecification, "id">>): HonuaLayerSpecification;
+    /** Check whether a layer with the given ID exists. */
+    hasLayer(id: string): boolean;
+    /**
+     * Move a layer to a new position in the render order.
+     *
+     * @param id - The layer to move.
+     * @param beforeId - Place it before this layer. If omitted, moves to end.
+     */
+    moveLayer(id: string, beforeId?: string): void;
+    /** Get all layer IDs in render order. */
+    get layerIds(): string[];
+    /** Get all layers in render order. */
+    get layers(): ReadonlyArray<HonuaLayerSpecification>;
+    /** Get all layers that reference a given source. */
+    getLayersForSource(sourceId: string): HonuaLayerSpecification[];
+    /**
+     * Produce a MapLibre-compatible style specification.
+     *
+     * Honua sources are included with their original custom `type` values.
+     * Use this to feed into a MapLibre map via `map.setStyle(honuaMap.toStyle())`
+     * alongside a MapLibre source-type plugin that handles the Honua types.
+     */
+    toStyle(options?: {
+        name?: string;
+    }): HonuaStyleSpecification;
+    /** Subscribe to map structure changes. Returns a remove handle. */
+    on(listener: HonuaMapEventListener): {
+        remove(): void;
+    };
+    /** Number of registered sources. */
+    get sourceCount(): number;
+    /** Number of registered layers. */
+    get layerCount(): number;
+    /** Remove all sources and layers. */
+    clear(): void;
+}
+//# sourceMappingURL=honua-map.d.ts.map

package/map/honua-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"honua-map.d.ts","sourceRoot":"","sources":["../../../src/map/honua-map.ts"],"names":[],"mappings":"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"}

package/map/honua-map.js

@@ -0,0 +1,347 @@
+/**
+ * HonuaMap — Source/Layer separation for multi-protocol geospatial maps.
+ *
+ * Manages named data sources (protocol-aware: Feature Service, Map Service,
+ * OGC Features) separately from named rendering layers. One source can back
+ * multiple layers; layers reference sources by name.
+ *
+ * Does **not** depend on `maplibre-gl` at runtime. Produces a
+ * MapLibre-compatible style via {@link HonuaMap.toStyle} and exposes the
+ * underlying SDK surface instances via {@link HonuaMap.getSource}.
+ *
+ * @module
+ */
+import { HonuaFeatureLayer, HonuaMapService, HonuaOgcFeatures, } from "../core/surfaces.js";
+import { parseFeatureLayerUrl, parseMapServiceUrl } from "../esri-compat/url.js";
+import { isFeatureServiceSource, isHonuaSource, isMapServiceSource, isOgcFeaturesSource, isWmsSource, isWmtsSource, parseOgcFeaturesUrl, } from "../style/specification.js";
+import { resolveWmsSpec, resolveWmtsSpec } from "../style/wms-wmts-resolvers.js";
+// ── HonuaMap ──────────────────────────────────────────────────
+/**
+ * A protocol-aware map that separates data sources from rendering layers.
+ *
+ * @example
+ * ```ts
+ * const map = new HonuaMap({ client });
+ *
+ * map.addSource("parcels", {
+ *   type: "honua-feature-service",
+ *   url: "https://gis.example.com/rest/services/parcels/FeatureServer/0",
+ *   definitionExpression: "status = 'active'",
+ * });
+ *
+ * map.addLayer({
+ *   id: "parcel-fill",
+ *   source: "parcels",
+ *   type: "fill",
+ *   paint: { "fill-color": "#088", "fill-opacity": 0.5 },
+ * });
+ *
+ * map.addLayer({
+ *   id: "parcel-labels",
+ *   source: "parcels",
+ *   type: "symbol",
+ *   layout: { "text-field": ["get", "parcel_id"] },
+ * });
+ *
+ * // Access the underlying surface for queries
+ * const parcels = map.getSource("parcels"); // HonuaFeatureLayer
+ * const count = await (parcels as HonuaFeatureLayer).queryFeatureCount();
+ * ```
+ */
+export class HonuaMap {
+    #client;
+    #sources = new Map();
+    #layers = [];
+    #listeners = new Set();
+    constructor(options) {
+        this.#client = options.client;
+        if (options.style) {
+            this.#loadStyle(options.style);
+        }
+    }
+    // ── Source management ───────────────────────────────────────
+    /**
+     * Register a named data source.
+     *
+     * Honua sources (`honua-feature-service`, `honua-map-service`,
+     * `honua-ogc-features`) are resolved into SDK surface instances.
+     * Native MapLibre sources (`vector`, `raster`, `geojson`) are stored
+     * as-is and resolve to `null`.
+     *
+     * @throws If a source with the same name already exists.
+     */
+    addSource(name, spec) {
+        if (this.#sources.has(name)) {
+            throw new Error(`Source "${name}" already exists. Remove it first.`);
+        }
+        const resolved = this.#resolveSource(spec);
+        this.#sources.set(name, { spec, resolved });
+        this.#emit({ type: "source-added", sourceId: name });
+    }
+    /**
+     * Remove a named data source and all layers that reference it.
+     *
+     * @returns The IDs of layers that were removed.
+     */
+    removeSource(name) {
+        if (!this.#sources.has(name))
+            return [];
+        // Collect dependent layers in order, then remove back-to-front
+        const removed = [];
+        const indicesToRemove = [];
+        for (let i = 0; i < this.#layers.length; i++) {
+            if (this.#layers[i].spec.source === name) {
+                removed.push(this.#layers[i].id);
+                indicesToRemove.push(i);
+            }
+        }
+        for (let i = indicesToRemove.length - 1; i >= 0; i--) {
+            this.#layers.splice(indicesToRemove[i], 1);
+        }
+        for (const id of removed) {
+            this.#emit({ type: "layer-removed", layerId: id });
+        }
+        this.#sources.delete(name);
+        this.#emit({ type: "source-removed", sourceId: name });
+        return removed;
+    }
+    /**
+     * Get the resolved SDK surface for a source.
+     *
+     * Returns `null` for native MapLibre sources (they should be handled
+     * by MapLibre directly). Returns `undefined` if the source does not exist.
+     */
+    getSource(name) {
+        return this.#sources.get(name)?.resolved;
+    }
+    /** Get the raw specification for a source. */
+    getSourceSpec(name) {
+        return this.#sources.get(name)?.spec;
+    }
+    /**
+     * Replace a source specification while preserving layers that reference it.
+     *
+     * This updates the resolved SDK surface for Honua custom source types and
+     * leaves render layers in place so callers can decide how to patch the
+     * renderer.
+     *
+     * @throws If the source does not exist.
+     */
+    updateSource(name, spec) {
+        if (!this.#sources.has(name)) {
+            throw new Error(`Source "${name}" not found.`);
+        }
+        const resolved = this.#resolveSource(spec);
+        this.#sources.set(name, { spec, resolved });
+        this.#emit({ type: "source-updated", sourceId: name });
+    }
+    /** Check whether a source with the given name exists. */
+    hasSource(name) {
+        return this.#sources.has(name);
+    }
+    /** Get all registered source names. */
+    get sourceIds() {
+        return [...this.#sources.keys()];
+    }
+    // ── Layer management ────────────────────────────────────────
+    /**
+     * Add a rendering layer.
+     *
+     * Layers reference a source by name. Multiple layers can reference the
+     * same source (e.g. a fill layer and a symbol layer over the same
+     * Feature Service).
+     *
+     * @param spec - Layer specification (must include `id`, `source`, `type`).
+     * @param beforeId - Insert this layer before the layer with this ID.
+     *   If omitted, appends to the end.
+     * @throws If the referenced source does not exist.
+     * @throws If a layer with the same ID already exists.
+     */
+    addLayer(spec, beforeId) {
+        const layerSource = spec.source;
+        if (layerSource && !this.#sources.has(layerSource)) {
+            throw new Error(`Cannot add layer "${spec.id}": source "${layerSource}" does not exist.`);
+        }
+        if (this.#layers.some((l) => l.id === spec.id)) {
+            throw new Error(`Layer "${spec.id}" already exists.`);
+        }
+        if (beforeId) {
+            const idx = this.#layers.findIndex((l) => l.id === beforeId);
+            if (idx === -1) {
+                throw new Error(`Cannot insert before "${beforeId}": layer not found.`);
+            }
+            this.#layers.splice(idx, 0, { id: spec.id, spec });
+        }
+        else {
+            this.#layers.push({ id: spec.id, spec });
+        }
+        this.#emit({ type: "layer-added", layerId: spec.id });
+    }
+    /** Remove a layer by ID. Returns `true` if the layer was found and removed. */
+    removeLayer(id) {
+        const idx = this.#layers.findIndex((l) => l.id === id);
+        if (idx === -1)
+            return false;
+        this.#layers.splice(idx, 1);
+        this.#emit({ type: "layer-removed", layerId: id });
+        return true;
+    }
+    /** Get a layer specification by ID. */
+    getLayer(id) {
+        return this.#layers.find((l) => l.id === id)?.spec;
+    }
+    /**
+     * Patch a layer specification by ID. The layer ID remains stable.
+     *
+     * @throws If the layer does not exist.
+     * @throws If the patched source does not exist.
+     */
+    updateLayer(id, patch) {
+        const entry = this.#layers.find((l) => l.id === id);
+        if (!entry) {
+            throw new Error(`Layer "${id}" not found.`);
+        }
+        const next = { ...entry.spec, ...patch, id };
+        if (next.source && !this.#sources.has(next.source)) {
+            throw new Error(`Cannot update layer "${id}": source "${next.source}" does not exist.`);
+        }
+        entry.spec = next;
+        this.#emit({ type: "layer-updated", layerId: id });
+        return next;
+    }
+    /** Check whether a layer with the given ID exists. */
+    hasLayer(id) {
+        return this.#layers.some((l) => l.id === id);
+    }
+    /**
+     * Move a layer to a new position in the render order.
+     *
+     * @param id - The layer to move.
+     * @param beforeId - Place it before this layer. If omitted, moves to end.
+     */
+    moveLayer(id, beforeId) {
+        const fromIdx = this.#layers.findIndex((l) => l.id === id);
+        if (fromIdx === -1)
+            throw new Error(`Layer "${id}" not found.`);
+        const [entry] = this.#layers.splice(fromIdx, 1);
+        if (beforeId) {
+            const toIdx = this.#layers.findIndex((l) => l.id === beforeId);
+            if (toIdx === -1)
+                throw new Error(`Target layer "${beforeId}" not found.`);
+            this.#layers.splice(toIdx, 0, entry);
+        }
+        else {
+            this.#layers.push(entry);
+        }
+        this.#emit({ type: "layer-moved", layerId: id, beforeId });
+    }
+    /** Get all layer IDs in render order. */
+    get layerIds() {
+        return this.#layers.map((l) => l.id);
+    }
+    /** Get all layers in render order. */
+    get layers() {
+        return this.#layers.map((l) => l.spec);
+    }
+    /** Get all layers that reference a given source. */
+    getLayersForSource(sourceId) {
+        return this.#layers.filter((l) => l.spec.source === sourceId).map((l) => l.spec);
+    }
+    // ── Style serialization ─────────────────────────────────────
+    /**
+     * Produce a MapLibre-compatible style specification.
+     *
+     * Honua sources are included with their original custom `type` values.
+     * Use this to feed into a MapLibre map via `map.setStyle(honuaMap.toStyle())`
+     * alongside a MapLibre source-type plugin that handles the Honua types.
+     */
+    toStyle(options) {
+        const sources = {};
+        for (const [name, { spec }] of this.#sources) {
+            sources[name] = spec;
+        }
+        return {
+            version: 8,
+            name: options?.name,
+            sources,
+            layers: this.#layers.map((l) => ({ ...l.spec })),
+        };
+    }
+    // ── Events ──────────────────────────────────────────────────
+    /** Subscribe to map structure changes. Returns a remove handle. */
+    on(listener) {
+        this.#listeners.add(listener);
+        return {
+            remove: () => {
+                this.#listeners.delete(listener);
+            },
+        };
+    }
+    // ── Bulk operations ─────────────────────────────────────────
+    /** Number of registered sources. */
+    get sourceCount() {
+        return this.#sources.size;
+    }
+    /** Number of registered layers. */
+    get layerCount() {
+        return this.#layers.length;
+    }
+    /** Remove all sources and layers. */
+    clear() {
+        const layerIds = [...this.layerIds];
+        const sourceIds = [...this.sourceIds];
+        this.#layers.length = 0;
+        for (const id of layerIds) {
+            this.#emit({ type: "layer-removed", layerId: id });
+        }
+        this.#sources.clear();
+        for (const id of sourceIds) {
+            this.#emit({ type: "source-removed", sourceId: id });
+        }
+    }
+    // ── Private ─────────────────────────────────────────────────
+    #loadStyle(style) {
+        for (const [name, spec] of Object.entries(style.sources)) {
+            const resolved = this.#resolveSource(spec);
+            this.#sources.set(name, { spec, resolved });
+        }
+        for (const layer of style.layers) {
+            this.#layers.push({ id: layer.id, spec: layer });
+        }
+    }
+    #resolveSource(spec) {
+        if (isFeatureServiceSource(spec)) {
+            const parsed = parseFeatureLayerUrl(spec.url);
+            return new HonuaFeatureLayer({
+                client: this.#client,
+                serviceId: parsed.serviceId,
+                layerId: parsed.layerId,
+            });
+        }
+        if (isMapServiceSource(spec)) {
+            const parsed = parseMapServiceUrl(spec.url);
+            return new HonuaMapService({
+                client: this.#client,
+                serviceId: parsed.serviceId,
+            });
+        }
+        if (isOgcFeaturesSource(spec)) {
+            const parsed = parseOgcFeaturesUrl(spec.url);
+            const ogcRoot = new HonuaOgcFeatures({ client: this.#client });
+            const collectionId = spec.collectionId ?? parsed.collectionId ?? "";
+            return ogcRoot.collection(collectionId);
+        }
+        if (isWmsSource(spec)) {
+            return resolveWmsSpec(this.#client, spec);
+        }
+        if (isWmtsSource(spec)) {
+            return resolveWmtsSpec(this.#client, spec);
+        }
+        return null;
+    }
+    #emit(event) {
+        for (const listener of this.#listeners) {
+            listener(event);
+        }
+    }
+}

package/map/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `@honua/sdk-js/map` — `HonuaMap` programmatic map container.
+ *
+ * A small, renderer-neutral map handle for tests and headless workflows that
+ * mirrors the subset of the MapLibre / Cesium runtime API the SDK contracts
+ * against.
+ *
+ * @example
+ * ```ts
+ * import { HonuaMap } from "@honua/sdk-js/map";
+ *
+ * const map = new HonuaMap({ extent: { xmin: -158, ymin: 21, xmax: -157, ymax: 22 } });
+ * map.on("extentchange", (event) => console.log(event.extent));
+ * map.setSourceVisible("parcels", false);
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { HonuaMap } from "./honua-map.js";
+export type { HonuaMapOptions, HonuaMapEvent, HonuaMapEventListener, LayerSnapshot, ResolvedMapSource, } from "./honua-map.js";
+export { createHonuaFeatureServiceLayer, createHonuaMapLibreMapOptions, createHonuaMapLibreStyle, createHonuaMapServiceLayer, createHonuaTileServiceLayer, } from "./maplibre-target.js";
+export type { HonuaFeatureServiceLayerOptions, HonuaMapLibreLayerDefinition, HonuaMapLibreLayerOptionsBase, HonuaMapLibreMapOptions, HonuaMapLibreRasterSourceSpecification, HonuaMapLibreStyleOptions, HonuaMapServiceLayerOptions, HonuaTileServiceLayerOptions, } from "./maplibre-target.js";
+export { esriFeaturesToGeoJson, esriGeometryToGeoJson, loadHonuaFeatureServiceGeoJson, registerHonuaFeatureServiceSources, } from "./feature-service-adapter.js";
+export type { AdapterGeoJsonFeature, AdapterGeoJsonFeatureCollection, AdapterGeoJsonGeometry, FeatureServiceAdapterMap, LoadHonuaFeatureServiceGeoJsonOptions, MapLibreGeoJsonSourceSpecification, RegisterHonuaFeatureServiceSourcesResult, } from "./feature-service-adapter.js";
+export { webmapJsonToMapLibreStyle } from "./webmap-maplibre.js";
+export type { WebMapJsonToMapLibreStyleOptions, WebMapJsonToMapLibreStyleResult, WebMapMapLibreGapKind, WebMapMapLibreManualGap, } from "./webmap-maplibre.js";
+//# sourceMappingURL=index.d.ts.map

package/map/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/map/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,YAAY,EACV,eAAe,EACf,aAAa,EACb,qBAAqB,EACrB,aAAa,EACb,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,8BAA8B,EAC9B,6BAA6B,EAC7B,wBAAwB,EACxB,0BAA0B,EAC1B,2BAA2B,GAC5B,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,+BAA+B,EAC/B,4BAA4B,EAC5B,6BAA6B,EAC7B,uBAAuB,EACvB,sCAAsC,EACtC,yBAAyB,EACzB,2BAA2B,EAC3B,4BAA4B,GAC7B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,8BAA8B,EAC9B,kCAAkC,GACnC,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,qBAAqB,EACrB,+BAA+B,EAC/B,sBAAsB,EACtB,wBAAwB,EACxB,qCAAqC,EACrC,kCAAkC,EAClC,wCAAwC,GACzC,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACjE,YAAY,EACV,gCAAgC,EAChC,+BAA+B,EAC/B,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,sBAAsB,CAAC"}

package/map/index.js

@@ -0,0 +1,22 @@
+/**
+ * `@honua/sdk-js/map` — `HonuaMap` programmatic map container.
+ *
+ * A small, renderer-neutral map handle for tests and headless workflows that
+ * mirrors the subset of the MapLibre / Cesium runtime API the SDK contracts
+ * against.
+ *
+ * @example
+ * ```ts
+ * import { HonuaMap } from "@honua/sdk-js/map";
+ *
+ * const map = new HonuaMap({ extent: { xmin: -158, ymin: 21, xmax: -157, ymax: 22 } });
+ * map.on("extentchange", (event) => console.log(event.extent));
+ * map.setSourceVisible("parcels", false);
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { HonuaMap } from "./honua-map.js";
+export { createHonuaFeatureServiceLayer, createHonuaMapLibreMapOptions, createHonuaMapLibreStyle, createHonuaMapServiceLayer, createHonuaTileServiceLayer, } from "./maplibre-target.js";
+export { esriFeaturesToGeoJson, esriGeometryToGeoJson, loadHonuaFeatureServiceGeoJson, registerHonuaFeatureServiceSources, } from "./feature-service-adapter.js";
+export { webmapJsonToMapLibreStyle } from "./webmap-maplibre.js";