@honua/app-platform 0.0.20-alpha.0

package/map/feature-service-adapter.js

@@ -0,0 +1,279 @@
+/**
+ * MapLibre runtime adapter for Honua feature-service sources.
+ *
+ * {@link createHonuaFeatureServiceLayer} (and the migration codemod) emit a
+ * custom `honua-feature-service` source type that MapLibre's renderer does not
+ * understand — adding it to a `maplibre-gl` `Map` directly is a silent no-op.
+ *
+ * This module bridges that gap. It fetches features through the SDK query path
+ * ({@link HonuaFeatureLayer}) and converts the Esri feature set into a standard
+ * GeoJSON `FeatureCollection`, then exposes it as a plain MapLibre `geojson`
+ * source spec that the renderer renders natively. Callers either:
+ *
+ *  - call {@link loadHonuaFeatureServiceGeoJson} to obtain a `geojson` source
+ *    spec they add to their style themselves, or
+ *  - call {@link registerHonuaFeatureServiceSources} to walk a {@link HonuaMap}
+ *    and live-patch every `honua-feature-service` source on a real MapLibre map
+ *    into a fetched `geojson` source.
+ *
+ * Raster Honua sources (`honua-map-service`, tile services) already project
+ * onto MapLibre-native sources and need no adapter; this fills in the feature
+ * (vector) asymmetry.
+ *
+ * @module
+ */
+import { HonuaFeatureLayer } from "../core/surfaces.js";
+import { parseFeatureLayerUrl } from "../esri-compat/url.js";
+/**
+ * Convert a single Esri geometry into a GeoJSON geometry.
+ *
+ * Handles the geometry kinds a feature-service query returns (point,
+ * multipoint, polyline, polygon, envelope). Returns `null` when the geometry is
+ * absent or unrecognised so the feature still renders attribute-only.
+ */
+export function esriGeometryToGeoJson(geometry, geometryType) {
+    if (!geometry) {
+        return null;
+    }
+    // Point geometries are recognisable structurally even without a declared
+    // type (queries that elide geometryType still return {x, y}).
+    if (geometryType === "esriGeometryPoint" || (geometry.x !== undefined && geometry.y !== undefined)) {
+        const x = asFiniteNumber(geometry.x);
+        const y = asFiniteNumber(geometry.y);
+        if (x === undefined || y === undefined)
+            return null;
+        return { type: "Point", coordinates: [x, y] };
+    }
+    if (geometryType === "esriGeometryMultipoint") {
+        const points = asArray(geometry.points)
+            .map(asCoordinatePair)
+            .filter((value) => value !== undefined);
+        return { type: "MultiPoint", coordinates: points };
+    }
+    if (geometryType === "esriGeometryPolyline") {
+        const paths = asArray(geometry.paths)
+            .map(asCoordinateArray)
+            .filter((path) => path.length > 0);
+        if (paths.length === 1) {
+            return { type: "LineString", coordinates: paths[0] };
+        }
+        return { type: "MultiLineString", coordinates: paths };
+    }
+    if (geometryType === "esriGeometryPolygon") {
+        const rings = asArray(geometry.rings)
+            .map(asCoordinateArray)
+            .filter((ring) => ring.length > 0);
+        // MapLibre does not enforce GeoJSON ring winding for rendering, so the
+        // adapter passes Esri rings through as a Polygon without re-nesting.
+        return { type: "Polygon", coordinates: rings };
+    }
+    if (geometryType === "esriGeometryEnvelope") {
+        const xmin = asFiniteNumber(geometry.xmin);
+        const ymin = asFiniteNumber(geometry.ymin);
+        const xmax = asFiniteNumber(geometry.xmax);
+        const ymax = asFiniteNumber(geometry.ymax);
+        if (xmin === undefined || ymin === undefined || xmax === undefined || ymax === undefined) {
+            return null;
+        }
+        return {
+            type: "Polygon",
+            coordinates: [
+                [
+                    [xmin, ymin],
+                    [xmax, ymin],
+                    [xmax, ymax],
+                    [xmin, ymax],
+                    [xmin, ymin],
+                ],
+            ],
+        };
+    }
+    return null;
+}
+/**
+ * Convert an array of Esri features (attributes + geometry) into a GeoJSON
+ * `FeatureCollection`.
+ */
+export function esriFeaturesToGeoJson(features, geometryType) {
+    return {
+        type: "FeatureCollection",
+        features: features.map((feature) => ({
+            type: "Feature",
+            geometry: esriGeometryToGeoJson(feature.geometry ?? null, geometryType),
+            properties: { ...(feature.attributes ?? {}) },
+        })),
+    };
+}
+/**
+ * Fetch a Honua feature-service layer through the SDK and return a standard
+ * MapLibre `geojson` source specification that the renderer renders natively.
+ *
+ * @example
+ * ```ts
+ * const source = await loadHonuaFeatureServiceGeoJson(client, layer.source.url);
+ * map.addSource(layer.sourceId, source);
+ * map.addLayer(layer.layer);
+ * ```
+ */
+export async function loadHonuaFeatureServiceGeoJson(client, url, options = {}) {
+    const parsed = parseFeatureLayerUrl(url);
+    const layer = new HonuaFeatureLayer({
+        client,
+        serviceId: parsed.serviceId,
+        layerId: parsed.layerId,
+    });
+    // GeoJSON is lon/lat (WGS84). Default outSR to 4326 so the rendered
+    // coordinates land where MapLibre expects them.
+    const outSR = options.outSR ?? 4326;
+    const request = {
+        where: options.definitionExpression ?? "1=1",
+        outFields: options.outFields ?? ["*"],
+        returnGeometry: true,
+        outSr: outSR,
+        ...(options.pageSize !== undefined ? { pageSize: options.pageSize } : {}),
+        ...(options.maxPages !== undefined ? { maxPages: options.maxPages } : {}),
+        ...(options.signal ? { signal: options.signal } : {}),
+    };
+    const metadataPromise = layer.metadata(options.signal ? { signal: options.signal } : {}).catch(() => undefined);
+    const features = await layer.queryFeaturesAll(request);
+    const geometryType = (await metadataPromise)?.geometryType;
+    const data = esriFeaturesToGeoJson(features, geometryType);
+    return {
+        type: "geojson",
+        data,
+        ...(options.attribution ? { attribution: options.attribution } : {}),
+    };
+}
+/** Default fetch fan-out for {@link registerHonuaFeatureServiceSources}. */
+const DEFAULT_REGISTER_CONCURRENCY = 6;
+/**
+ * Walk a {@link HonuaMap} and replace every `honua-feature-service` source on a
+ * real MapLibre map with a fetched standard `geojson` source so feature layers
+ * actually render.
+ *
+ * Existing `geojson` sources are updated in place via `setData`; otherwise a new
+ * source is added. Layers should be added by the caller (or already present in
+ * the style) — this only manages the data sources.
+ *
+ * @param map - A `maplibre-gl` `Map` (or any {@link FeatureServiceAdapterMap}).
+ * @param honuaMap - The {@link HonuaMap} whose feature-service sources to wire.
+ * @param client - The Honua client used to fetch features.
+ */
+export async function registerHonuaFeatureServiceSources(map, honuaMap, client, options = {}) {
+    const registered = [];
+    const failed = [];
+    // Collect the feature-service sources to load, validating `url` up front so a
+    // missing url fails fast without consuming a fetch slot.
+    const pending = [];
+    for (const sourceId of honuaMap.sourceIds) {
+        const spec = honuaMap.getSourceSpec(sourceId);
+        if (!spec || spec.type !== "honua-feature-service") {
+            continue;
+        }
+        const url = spec.url;
+        if (typeof url !== "string" || url.length === 0) {
+            failed.push({ sourceId, error: new Error(`feature-service source "${sourceId}" is missing url`) });
+            continue;
+        }
+        pending.push({ sourceId, url, spec });
+    }
+    // Fetch sources with bounded concurrency: total latency becomes the max of the
+    // per-source fetches instead of their sum (a startup cliff for multi-layer maps).
+    const concurrency = typeof options.concurrency === "number" && Number.isFinite(options.concurrency)
+        ? Math.max(1, Math.trunc(options.concurrency))
+        : DEFAULT_REGISTER_CONCURRENCY;
+    const results = await allSettledLimited(pending, concurrency, (item) => loadHonuaFeatureServiceGeoJson(client, item.url, {
+        ...options,
+        ...featureServiceSpecOverrides(item.spec),
+    }));
+    // Apply the fetched sources to the map sequentially, preserving source order.
+    // Map mutations are synchronous and must stay single-threaded.
+    for (let index = 0; index < pending.length; index += 1) {
+        const { sourceId } = pending[index];
+        const result = results[index];
+        if (result.status === "rejected") {
+            failed.push({ sourceId, error: result.reason });
+            continue;
+        }
+        try {
+            const source = result.value;
+            const existing = map.getSource(sourceId);
+            if (existing && typeof existing.setData === "function") {
+                existing.setData(source.data);
+            }
+            else {
+                if (existing) {
+                    map.removeSource(sourceId);
+                }
+                map.addSource(sourceId, source);
+            }
+            registered.push(sourceId);
+        }
+        catch (error) {
+            failed.push({ sourceId, error });
+        }
+    }
+    return { registered, failed };
+}
+/** Derive per-source query overrides from a `honua-feature-service` source spec. */
+function featureServiceSpecOverrides(spec) {
+    return {
+        ...(typeof spec.definitionExpression === "string"
+            ? { definitionExpression: spec.definitionExpression }
+            : {}),
+        ...(Array.isArray(spec.outFields)
+            ? { outFields: spec.outFields }
+            : {}),
+        ...(typeof spec.outSR === "number" ? { outSR: spec.outSR } : {}),
+        ...(typeof spec.attribution === "string"
+            ? { attribution: spec.attribution }
+            : {}),
+    };
+}
+/**
+ * Run `worker` over `values` with at most `concurrency` in flight, collecting
+ * settled results in input order. Mirrors the limiter in `runtime/query-tiles`;
+ * kept local to avoid coupling the map layer to the runtime tile pipeline.
+ */
+async function allSettledLimited(values, concurrency, worker) {
+    const results = new Array(values.length);
+    let nextIndex = 0;
+    async function run() {
+        for (;;) {
+            const index = nextIndex;
+            nextIndex += 1;
+            if (index >= values.length)
+                return;
+            try {
+                results[index] = { status: "fulfilled", value: await worker(values[index]) };
+            }
+            catch (reason) {
+                results[index] = { status: "rejected", reason };
+            }
+        }
+    }
+    const workers = Array.from({ length: Math.min(concurrency, values.length) }, () => run());
+    await Promise.all(workers);
+    return results;
+}
+// ── Coercion helpers ─────────────────────────────────────────
+function asFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function asCoordinatePair(value) {
+    if (!Array.isArray(value) || value.length < 2)
+        return undefined;
+    const x = asFiniteNumber(value[0]);
+    const y = asFiniteNumber(value[1]);
+    if (x === undefined || y === undefined)
+        return undefined;
+    return [x, y];
+}
+function asCoordinateArray(value) {
+    return asArray(value)
+        .map(asCoordinatePair)
+        .filter((pair) => pair !== undefined);
+}

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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"}