@honua/app-platform 0.0.20-alpha.0

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

package/map/maplibre-target.d.ts

@@ -0,0 +1,103 @@
+import type { HonuaFeatureServiceSourceSpecification, HonuaLayerSpecification, HonuaMapServiceSourceSpecification, HonuaStyleSpecification } from "../style/specification.js";
+/** Standard MapLibre raster source shape used by migrated tiled services. */
+export interface HonuaMapLibreRasterSourceSpecification {
+    [key: string]: unknown;
+    type: "raster";
+    tiles: string[];
+    tileSize?: number;
+    attribution?: string;
+}
+/** Layer/source pair consumed by {@link createHonuaMapLibreStyle}. */
+export interface HonuaMapLibreLayerDefinition {
+    id: string;
+    sourceId: string;
+    source: HonuaFeatureServiceSourceSpecification | HonuaMapServiceSourceSpecification | HonuaMapLibreRasterSourceSpecification;
+    layer: HonuaLayerSpecification;
+}
+/** Shared options for migrated ArcGIS layer constructors. */
+export interface HonuaMapLibreLayerOptionsBase {
+    id?: string;
+    title?: string;
+    visible?: boolean;
+    opacity?: number;
+    minScale?: number;
+    maxScale?: number;
+    attribution?: string;
+    paint?: Record<string, unknown>;
+    layout?: Record<string, unknown>;
+}
+/** Options for an ArcGIS FeatureLayer migrated into a Honua feature-service source. */
+export interface HonuaFeatureServiceLayerOptions extends HonuaMapLibreLayerOptionsBase {
+    url: string;
+    outFields?: string[];
+    definitionExpression?: string;
+    returnGeometry?: boolean;
+    outSR?: number;
+    layerType?: "circle" | "line" | "fill";
+}
+/** Options for an ArcGIS MapImageLayer migrated into a Honua map-service source. */
+export interface HonuaMapServiceLayerOptions extends HonuaMapLibreLayerOptionsBase {
+    url: string;
+    sublayers?: unknown;
+    layers?: string;
+    dpi?: number;
+    format?: "png" | "png24" | "png32" | "jpg" | "gif";
+    transparent?: boolean;
+}
+/** Options for an ArcGIS TileLayer migrated into a MapLibre raster tile source. */
+export interface HonuaTileServiceLayerOptions extends HonuaMapLibreLayerOptionsBase {
+    url: string;
+    tileSize?: number;
+}
+/** Options for an ArcGIS Map migrated into a MapLibre style document. */
+export interface HonuaMapLibreStyleOptions {
+    basemap?: string;
+    layers?: readonly HonuaMapLibreLayerDefinition[];
+    name?: string;
+    center?: [number, number];
+    zoom?: number;
+}
+/** Options for an ArcGIS MapView migrated into MapLibre's `Map` constructor. */
+export interface HonuaMapLibreMapOptions {
+    map?: HonuaStyleSpecification;
+    style?: HonuaStyleSpecification;
+    container?: string | HTMLElement;
+    center?: [number, number];
+    zoom?: number;
+    bearing?: number;
+    pitch?: number;
+}
+/**
+ * Create a Honua feature-service source and a default MapLibre render layer.
+ *
+ * The returned `source` carries the custom `honua-feature-service` type, which
+ * MapLibre's renderer does not understand on its own — adding it to a
+ * `maplibre-gl` `Map` directly is a silent no-op. To render it, run the layer's
+ * source through the MapLibre runtime adapter
+ * (`loadHonuaFeatureServiceGeoJson` / `registerHonuaFeatureServiceSources` from
+ * `@honua/sdk-js/map`), which fetches features via the SDK and produces a
+ * standard `geojson` source. This differs from
+ * {@link createHonuaTileServiceLayer}, which emits a native MapLibre `raster`
+ * source that renders without an adapter.
+ *
+ * @see loadHonuaFeatureServiceGeoJson
+ * @see registerHonuaFeatureServiceSources
+ */
+export declare function createHonuaFeatureServiceLayer(options: HonuaFeatureServiceLayerOptions): HonuaMapLibreLayerDefinition;
+/**
+ * Create a Honua map-service source and a default MapLibre raster layer.
+ */
+export declare function createHonuaMapServiceLayer(options: HonuaMapServiceLayerOptions): HonuaMapLibreLayerDefinition;
+/**
+ * Create a MapLibre raster source and layer for an ArcGIS tiled service.
+ */
+export declare function createHonuaTileServiceLayer(options: HonuaTileServiceLayerOptions): HonuaMapLibreLayerDefinition;
+/**
+ * Create a MapLibre style document from migrated ArcGIS `Map` options.
+ */
+export declare function createHonuaMapLibreStyle(options?: HonuaMapLibreStyleOptions): HonuaStyleSpecification;
+/**
+ * Create the options object passed to `new maplibregl.Map(...)`.
+ */
+export declare function createHonuaMapLibreMapOptions(options: HonuaMapLibreMapOptions): Record<string, unknown>;
+//# sourceMappingURL=maplibre-target.d.ts.map

package/map/maplibre-target.d.ts.map

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

package/map/maplibre-target.js

@@ -0,0 +1,164 @@
+import { stripQueryAndFragment, trimTrailingSlashes } from "../core/path-utils.js";
+/**
+ * Create a Honua feature-service source and a default MapLibre render layer.
+ *
+ * The returned `source` carries the custom `honua-feature-service` type, which
+ * MapLibre's renderer does not understand on its own — adding it to a
+ * `maplibre-gl` `Map` directly is a silent no-op. To render it, run the layer's
+ * source through the MapLibre runtime adapter
+ * (`loadHonuaFeatureServiceGeoJson` / `registerHonuaFeatureServiceSources` from
+ * `@honua/sdk-js/map`), which fetches features via the SDK and produces a
+ * standard `geojson` source. This differs from
+ * {@link createHonuaTileServiceLayer}, which emits a native MapLibre `raster`
+ * source that renders without an adapter.
+ *
+ * @see loadHonuaFeatureServiceGeoJson
+ * @see registerHonuaFeatureServiceSources
+ */
+export function createHonuaFeatureServiceLayer(options) {
+    const sourceId = normalizeLayerId(options.id, options.title, options.url, "feature-service");
+    const layerType = options.layerType ?? "circle";
+    const source = {
+        type: "honua-feature-service",
+        url: options.url,
+        ...(options.attribution ? { attribution: options.attribution } : {}),
+        ...(options.definitionExpression ? { definitionExpression: options.definitionExpression } : {}),
+        ...(options.outFields ? { outFields: [...options.outFields] } : {}),
+        ...(options.returnGeometry !== undefined ? { returnGeometry: options.returnGeometry } : {}),
+        ...(options.outSR !== undefined ? { outSR: options.outSR } : {}),
+    };
+    return {
+        id: sourceId,
+        sourceId,
+        source,
+        layer: buildLayer(sourceId, layerType, options),
+    };
+}
+/**
+ * Create a Honua map-service source and a default MapLibre raster layer.
+ */
+export function createHonuaMapServiceLayer(options) {
+    const sourceId = normalizeLayerId(options.id, options.title, options.url, "map-service");
+    const source = {
+        type: "honua-map-service",
+        url: options.url,
+        ...(options.attribution ? { attribution: options.attribution } : {}),
+        ...(options.layers ? { layers: options.layers } : {}),
+        ...(options.dpi !== undefined ? { dpi: options.dpi } : {}),
+        ...(options.format ? { format: options.format } : {}),
+        ...(options.transparent !== undefined ? { transparent: options.transparent } : {}),
+    };
+    return {
+        id: sourceId,
+        sourceId,
+        source,
+        layer: buildLayer(sourceId, "raster", options),
+    };
+}
+/**
+ * Create a MapLibre raster source and layer for an ArcGIS tiled service.
+ */
+export function createHonuaTileServiceLayer(options) {
+    const sourceId = normalizeLayerId(options.id, options.title, options.url, "tile-service");
+    const baseUrl = trimTrailingSlashes(options.url);
+    const source = {
+        type: "raster",
+        tiles: [`${baseUrl}/tile/{z}/{y}/{x}`],
+        tileSize: options.tileSize ?? 256,
+        ...(options.attribution ? { attribution: options.attribution } : {}),
+    };
+    return {
+        id: sourceId,
+        sourceId,
+        source,
+        layer: buildLayer(sourceId, "raster", options),
+    };
+}
+/**
+ * Create a MapLibre style document from migrated ArcGIS `Map` options.
+ */
+export function createHonuaMapLibreStyle(options = {}) {
+    const sources = {};
+    const layers = [];
+    for (const layer of options.layers ?? []) {
+        sources[layer.sourceId] = layer.source;
+        layers.push(layer.layer);
+    }
+    return {
+        version: 8,
+        ...(options.name ? { name: options.name } : {}),
+        ...(options.center ? { center: options.center } : {}),
+        ...(options.zoom !== undefined ? { zoom: options.zoom } : {}),
+        metadata: options.basemap ? { "honua:arcgis-basemap": options.basemap } : undefined,
+        sources,
+        layers,
+    };
+}
+/**
+ * Create the options object passed to `new maplibregl.Map(...)`.
+ */
+export function createHonuaMapLibreMapOptions(options) {
+    const style = options.style ?? options.map ?? createHonuaMapLibreStyle();
+    return {
+        style,
+        ...(options.container !== undefined ? { container: options.container } : {}),
+        ...(options.center ? { center: options.center } : {}),
+        ...(options.zoom !== undefined ? { zoom: options.zoom } : {}),
+        ...(options.bearing !== undefined ? { bearing: options.bearing } : {}),
+        ...(options.pitch !== undefined ? { pitch: options.pitch } : {}),
+    };
+}
+function buildLayer(sourceId, type, options) {
+    return {
+        id: `${sourceId}-${type}`,
+        source: sourceId,
+        type,
+        ...(options.visible === false ? { layout: { ...(options.layout ?? {}), visibility: "none" } } : {}),
+        ...(options.visible !== false && options.layout ? { layout: options.layout } : {}),
+        ...(options.paint || options.opacity !== undefined ? { paint: buildPaint(type, options) } : {}),
+        ...(options.minScale !== undefined ? { minzoom: scaleToZoom(options.minScale) } : {}),
+        ...(options.maxScale !== undefined ? { maxzoom: scaleToZoom(options.maxScale) } : {}),
+        metadata: {
+            ...(options.title ? { title: options.title } : {}),
+            ...(options.id ? { "honua:source-id": options.id } : {}),
+        },
+    };
+}
+function buildPaint(type, options) {
+    const paint = { ...(options.paint ?? {}) };
+    if (options.opacity === undefined) {
+        return paint;
+    }
+    if (type === "circle")
+        paint["circle-opacity"] = options.opacity;
+    if (type === "line")
+        paint["line-opacity"] = options.opacity;
+    if (type === "fill")
+        paint["fill-opacity"] = options.opacity;
+    if (type === "raster")
+        paint["raster-opacity"] = options.opacity;
+    return paint;
+}
+function normalizeLayerId(id, title, url, fallback) {
+    return sanitizeId(id ?? title ?? lastUrlSegment(url) ?? fallback);
+}
+function lastUrlSegment(url) {
+    const trimmed = trimTrailingSlashes(stripQueryAndFragment(url));
+    const segment = trimmed.slice(trimmed.lastIndexOf("/") + 1);
+    return segment || undefined;
+}
+function sanitizeId(value) {
+    const id = value
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/[^A-Za-z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .toLowerCase();
+    return id || "layer";
+}
+function scaleToZoom(scale) {
+    if (!Number.isFinite(scale) || scale <= 0) {
+        return 0;
+    }
+    return Math.max(0, Math.log2(591657550.5 / scale));
+}