@honua/react 0.0.20-alpha.0

package/style/specification.js

@@ -0,0 +1,178 @@
+/**
+ * HonuaMapSpec — Honua-specific source type definitions extending MapLibre Style Spec v8.
+ *
+ * Defines three custom source types (`honua-feature-service`, `honua-map-service`,
+ * `honua-ogc-features`) and a `HonuaStyleSpecification` that widens the MapLibre
+ * style's `sources` map to accept them. Standard MapLibre layer types, paint/layout
+ * properties, and expressions are used unchanged.
+ *
+ * These types are standalone (zero dependency on `maplibre-gl` or
+ * `@maplibre/maplibre-gl-style-spec`), but structurally compatible — a
+ * `HonuaStyleSpecification` can be narrowed to `StyleSpecification` by filtering
+ * out Honua sources.
+ *
+ * @module
+ */
+// ── Type guards ──────────────────────────────────────────────
+/** Test whether a source specification is any Honua custom type. */
+export function isHonuaSource(source) {
+    return source.type.startsWith("honua-");
+}
+/** Test whether a source is a `honua-feature-service`. */
+export function isFeatureServiceSource(source) {
+    return source.type === "honua-feature-service";
+}
+/** Test whether a source is a `honua-map-service`. */
+export function isMapServiceSource(source) {
+    return source.type === "honua-map-service";
+}
+/** Test whether a source is a `honua-ogc-features`. */
+export function isOgcFeaturesSource(source) {
+    return source.type === "honua-ogc-features";
+}
+/** Test whether a source is a `honua-wms`. */
+export function isWmsSource(source) {
+    return source.type === "honua-wms";
+}
+/** Test whether a source is a `honua-wmts`. */
+export function isWmtsSource(source) {
+    return source.type === "honua-wmts";
+}
+/**
+ * Parse an OGC Features URL into baseUrl and optional collectionId.
+ *
+ * Accepts URLs like:
+ * - `https://gis.example.com/ogc/collections/admin-boundaries`
+ * - `https://gis.example.com/ogc` (collectionId provided separately)
+ */
+export function parseOgcFeaturesUrl(url) {
+    const absoluteUrl = parseAbsoluteHttpUrl(url);
+    const path = absoluteUrl ? absoluteUrl.pathname : stripQueryAndHash(url);
+    const normalizedPath = trimTrailingSlashes(path);
+    // Locate the first `/collections/` segment (case-insensitive) and split the
+    // path into basePath + collectionId. Linear `indexOf` scanning replaces the
+    // prior `/^(.*?)\/collections\/([^/?#]+)(?:\/.*)?$/i` regex, whose lazy
+    // leading `.*?` plus trailing alternation could backtrack super-linearly.
+    const collectionsToken = "/collections/";
+    const markerIndex = normalizedPath.toLowerCase().indexOf(collectionsToken);
+    if (markerIndex >= 0) {
+        const afterMarker = normalizedPath.slice(markerIndex + collectionsToken.length);
+        const nextSlash = afterMarker.indexOf("/");
+        const collectionId = nextSlash >= 0 ? afterMarker.slice(0, nextSlash) : afterMarker;
+        if (collectionId !== "") {
+            const basePath = normalizeCollectionBasePath(normalizedPath.slice(0, markerIndex), normalizedPath);
+            return {
+                baseUrl: joinUrlParts(absoluteUrl?.origin, basePath),
+                collectionId,
+            };
+        }
+    }
+    return {
+        baseUrl: joinUrlParts(absoluteUrl?.origin, normalizedPath),
+        collectionId: undefined,
+    };
+}
+function parseAbsoluteHttpUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+            return parsed;
+        }
+    }
+    catch {
+        // Relative URLs are handled by string parsing below.
+    }
+    return undefined;
+}
+function stripQueryAndHash(url) {
+    const hashIndex = url.indexOf("#");
+    const withoutHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+    const queryIndex = withoutHash.indexOf("?");
+    return queryIndex >= 0 ? withoutHash.slice(0, queryIndex) : withoutHash;
+}
+function trimTrailingSlashes(path) {
+    if (path === "/") {
+        return "/";
+    }
+    // Linear-time trailing-slash trim. Avoids the `/\/+$/` regex, whose
+    // anchored quantifier can backtrack super-linearly on long slash runs.
+    let end = path.length;
+    while (end > 0 && path.charCodeAt(end - 1) === 47 /* '/' */) {
+        end -= 1;
+    }
+    return end === path.length ? path : path.slice(0, end);
+}
+function normalizeCollectionBasePath(basePath, fullPath) {
+    const normalized = trimTrailingSlashes(basePath);
+    if (normalized.length > 0) {
+        return normalized;
+    }
+    return fullPath.startsWith("/") ? "/" : "";
+}
+function joinUrlParts(origin, path) {
+    if (!origin) {
+        return path;
+    }
+    if (path.length === 0 || path === "/") {
+        return origin;
+    }
+    return `${origin}${path.startsWith("/") ? path : `/${path}`}`;
+}
+/**
+ * Validate a HonuaStyleSpecification for structural correctness.
+ *
+ * Returns an empty array if the style is valid. Does not validate MapLibre
+ * layer/expression semantics — use `@maplibre/maplibre-gl-style-spec` for that.
+ */
+export function validateHonuaStyle(style) {
+    const errors = [];
+    if (typeof style !== "object" || style === null) {
+        errors.push({ path: "", message: "Style must be a non-null object" });
+        return errors;
+    }
+    const s = style;
+    if (s.version !== 8) {
+        errors.push({ path: "version", message: "Version must be 8" });
+    }
+    if (typeof s.sources !== "object" || s.sources === null || Array.isArray(s.sources)) {
+        errors.push({ path: "sources", message: "Sources must be a non-null object" });
+    }
+    else {
+        for (const [name, source] of Object.entries(s.sources)) {
+            if (typeof source !== "object" || source === null) {
+                errors.push({ path: `sources.${name}`, message: "Source must be a non-null object" });
+                continue;
+            }
+            const src = source;
+            if (typeof src.type !== "string") {
+                errors.push({ path: `sources.${name}.type`, message: "Source type must be a string" });
+                continue;
+            }
+            if (isHonuaSource(src)) {
+                if (typeof src.url !== "string") {
+                    errors.push({ path: `sources.${name}.url`, message: "Honua source must have a string url" });
+                }
+            }
+        }
+    }
+    if (!Array.isArray(s.layers)) {
+        errors.push({ path: "layers", message: "Layers must be an array" });
+    }
+    else {
+        for (let i = 0; i < s.layers.length; i++) {
+            const layer = s.layers[i];
+            if (typeof layer !== "object" || layer === null) {
+                errors.push({ path: `layers[${i}]`, message: "Layer must be a non-null object" });
+                continue;
+            }
+            const l = layer;
+            if (typeof l.id !== "string") {
+                errors.push({ path: `layers[${i}].id`, message: "Layer must have a string id" });
+            }
+            if (typeof l.type !== "string") {
+                errors.push({ path: `layers[${i}].type`, message: "Layer must have a string type" });
+            }
+        }
+    }
+    return errors;
+}

package/style/wms-wmts-resolvers.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared resolvers that turn a `HonuaWmsSourceSpecification` /
+ * `HonuaWmtsSourceSpecification` into a runtime SDK handle. Used by both
+ * `src/style/factory.ts` (`createSources`) and `src/map/honua-map.ts`
+ * (`HonuaMap.getSource`) so the URL-parsing and handle-selection rules
+ * stay identical between the two surfaces.
+ *
+ * @module
+ */
+import type { HonuaClient } from "../core/client.js";
+import { HonuaWms, HonuaWmsLayer } from "../core/wms.js";
+import { HonuaWmts, HonuaWmtsTileset } from "../core/wmts.js";
+import type { HonuaWmsSourceSpecification, HonuaWmtsSourceSpecification } from "./specification.js";
+/**
+ * Extract the service id from a WMS/WMTS endpoint URL. Returns
+ * `undefined` if the URL does not match a known service shape so the
+ * caller can fall back to the spec's explicit `serviceId` (or surface a
+ * typed error).
+ */
+export declare function parseWmsServiceIdFromUrl(url: string): string | undefined;
+/**
+ * Resolve a `honua-wms` source spec to a runtime handle. Returns the
+ * layer-bound `HonuaWmsLayer` only when `spec.layers` parses to exactly
+ * one non-empty layer token, because `HonuaWmsLayer` is a single-layer
+ * handle (its `describe()` resolves one `<Layer>` from the parsed
+ * Capabilities). Multi-layer composites (`LAYERS=a,b`) and
+ * empty / missing values stay on the service-level `HonuaWms` handle so
+ * `map()` / `featureInfo()` can still target the composite.
+ */
+export declare function resolveWmsSpec(client: HonuaClient, spec: HonuaWmsSourceSpecification): HonuaWms | HonuaWmsLayer;
+/**
+ * Resolve a `honua-wmts` source spec to a runtime handle. Returns the
+ * (layer × style × TileMatrixSet) `HonuaWmtsTileset` when the spec
+ * pins a single layer; otherwise returns the service-level `HonuaWmts`
+ * handle.
+ */
+export declare function resolveWmtsSpec(client: HonuaClient, spec: HonuaWmtsSourceSpecification): HonuaWmts | HonuaWmtsTileset;
+//# sourceMappingURL=wms-wmts-resolvers.d.ts.map

package/style/wms-wmts-resolvers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wms-wmts-resolvers.d.ts","sourceRoot":"","sources":["../../../src/style/wms-wmts-resolvers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAsB,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,KAAK,EAAE,2BAA2B,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAC;AAWpG;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAUxE;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,2BAA2B,GAAG,QAAQ,GAAG,aAAa,CAmB/G;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,4BAA4B,GAAG,SAAS,GAAG,gBAAgB,CAkBrH"}

package/style/wms-wmts-resolvers.js

@@ -0,0 +1,92 @@
+/**
+ * Shared resolvers that turn a `HonuaWmsSourceSpecification` /
+ * `HonuaWmtsSourceSpecification` into a runtime SDK handle. Used by both
+ * `src/style/factory.ts` (`createSources`) and `src/map/honua-map.ts`
+ * (`HonuaMap.getSource`) so the URL-parsing and handle-selection rules
+ * stay identical between the two surfaces.
+ *
+ * @module
+ */
+import { HonuaWms, HonuaWmsLayer, parseWmsLayerNames } from "../core/wms.js";
+import { HonuaWmts, HonuaWmtsTileset } from "../core/wmts.js";
+/**
+ * Match the canonical Esri MapServer WMS/WMTS endpoint shape
+ * (`/rest/services/<name>/MapServer/{WMS|WMTS}`) and the OGC web-map
+ * shape (`/ogc/services/<name>/{wms|wmts}`) so we can lift the service
+ * id out of the URL when the spec did not carry it explicitly.
+ */
+const HONUA_WMS_WMTS_URL_RE = /\/(?:rest\/services\/([^/?#]+)\/MapServer\/(?:WMS|WMTS)|ogc\/services\/([^/?#]+)\/(?:wms|wmts))/i;
+/**
+ * Extract the service id from a WMS/WMTS endpoint URL. Returns
+ * `undefined` if the URL does not match a known service shape so the
+ * caller can fall back to the spec's explicit `serviceId` (or surface a
+ * typed error).
+ */
+export function parseWmsServiceIdFromUrl(url) {
+    const match = HONUA_WMS_WMTS_URL_RE.exec(url);
+    if (!match)
+        return undefined;
+    const id = match[1] ?? match[2];
+    if (!id)
+        return undefined;
+    try {
+        return decodeURIComponent(id);
+    }
+    catch {
+        return id;
+    }
+}
+/**
+ * Resolve a `honua-wms` source spec to a runtime handle. Returns the
+ * layer-bound `HonuaWmsLayer` only when `spec.layers` parses to exactly
+ * one non-empty layer token, because `HonuaWmsLayer` is a single-layer
+ * handle (its `describe()` resolves one `<Layer>` from the parsed
+ * Capabilities). Multi-layer composites (`LAYERS=a,b`) and
+ * empty / missing values stay on the service-level `HonuaWms` handle so
+ * `map()` / `featureInfo()` can still target the composite.
+ */
+export function resolveWmsSpec(client, spec) {
+    const serviceId = spec.serviceId ?? parseWmsServiceIdFromUrl(spec.url);
+    if (!serviceId) {
+        throw new Error("honua-wms source requires either serviceId or a URL containing the service id");
+    }
+    const root = new HonuaWms({ client, serviceId });
+    const parsedLayers = parseWmsLayerNames(spec.layers);
+    if (parsedLayers.length === 1) {
+        const opts = {
+            client,
+            serviceId,
+            layerName: parsedLayers[0],
+        };
+        if (typeof spec.styles === "string" && spec.styles.length > 0) {
+            opts.defaultStyleId = spec.styles;
+        }
+        return new HonuaWmsLayer(opts);
+    }
+    return root;
+}
+/**
+ * Resolve a `honua-wmts` source spec to a runtime handle. Returns the
+ * (layer × style × TileMatrixSet) `HonuaWmtsTileset` when the spec
+ * pins a single layer; otherwise returns the service-level `HonuaWmts`
+ * handle.
+ */
+export function resolveWmtsSpec(client, spec) {
+    const serviceId = spec.serviceId ?? parseWmsServiceIdFromUrl(spec.url);
+    if (!serviceId) {
+        throw new Error("honua-wmts source requires either serviceId or a URL containing the service id");
+    }
+    const root = new HonuaWmts({ client, serviceId });
+    if (typeof spec.layer === "string" && spec.layer.length > 0) {
+        const style = spec.style ?? "default";
+        const tms = spec.tileMatrixSet ?? "WebMercatorQuad";
+        return new HonuaWmtsTileset({
+            client,
+            serviceId,
+            layerName: spec.layer,
+            styleId: style,
+            tileMatrixSetId: tms,
+        });
+    }
+    return root;
+}

package/webmap/contract.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Compatibility contract for WebMap JSON → HonuaStyleSpecification conversion.
+ *
+ * Documents every WebMap JSON property path and its support level,
+ * enabling consumers to programmatically audit which features are
+ * handled (or not) by the parser.
+ *
+ * @module
+ */
+export type ContractSupport = "full" | "partial" | "ignored" | "unsupported";
+export interface ContractEntry {
+    /** JSON path pattern (e.g. `"operationalLayers[].layerDefinition.drawingInfo.renderer"`). */
+    path: string;
+    /** Support level. */
+    support: ContractSupport;
+    /** Additional notes about limitations or behavior. */
+    notes?: string;
+}
+export declare const CONTRACT: ContractEntry[];
+export interface ContractSummary {
+    total: number;
+    full: number;
+    partial: number;
+    ignored: number;
+    unsupported: number;
+}
+export declare function getContractSummary(): ContractSummary;
+//# sourceMappingURL=contract.d.ts.map

package/webmap/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../src/webmap/contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CAAC;AAE7E,MAAM,WAAW,aAAa;IAC5B,6FAA6F;IAC7F,IAAI,EAAE,MAAM,CAAC;IACb,qBAAqB;IACrB,OAAO,EAAE,eAAe,CAAC;IACzB,sDAAsD;IACtD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,QAAQ,EAAE,aAAa,EA2HnC,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,kBAAkB,IAAI,eAAe,CAOpD"}

package/webmap/contract.js

@@ -0,0 +1,130 @@
+/**
+ * Compatibility contract for WebMap JSON → HonuaStyleSpecification conversion.
+ *
+ * Documents every WebMap JSON property path and its support level,
+ * enabling consumers to programmatically audit which features are
+ * handled (or not) by the parser.
+ *
+ * @module
+ */
+export const CONTRACT = [
+    // ── Top-level ──
+    { path: "version", support: "ignored", notes: "Informational only" },
+    { path: "authoringApp", support: "ignored" },
+    { path: "authoringAppVersion", support: "ignored" },
+    { path: "spatialReference", support: "partial", notes: "Web Mercator (3857/102100) supported; others warn" },
+    { path: "unknown top-level properties", support: "ignored", notes: "Ignored with warning" },
+    // ── Initial viewpoint / extent ──
+    {
+        path: "initialViewpoint",
+        support: "partial",
+        notes: "targetGeometry point/extent supported; camera/3D unsupported",
+    },
+    { path: "initialViewpoint.targetGeometry", support: "partial", notes: "Point or extent in 3857/102100/4326" },
+    { path: "initialViewpoint.scale", support: "full", notes: "Converted to approximate zoom" },
+    { path: "initialExtent", support: "full", notes: "Converted to center/zoom for Web Mercator" },
+    { path: "initialExtent.spatialReference", support: "partial", notes: "Web Mercator only" },
+    // ── Bookmarks ──
+    { path: "bookmarks", support: "full", notes: "Passed through as-is in result" },
+    { path: "bookmarks[].name", support: "full" },
+    { path: "bookmarks[].extent", support: "full" },
+    // ── Basemap ──
+    { path: "baseMap", support: "partial" },
+    { path: "baseMap.title", support: "full" },
+    { path: "baseMap.baseMapLayers[]", support: "partial" },
+    { path: "baseMap.baseMapLayers[].url", support: "full" },
+    {
+        path: "baseMap.baseMapLayers[].layerType",
+        support: "partial",
+        notes: "ArcGISTiledMapServiceLayer supported; VectorTileLayer partial",
+    },
+    { path: "baseMap.baseMapLayers[].visibility", support: "full" },
+    { path: "baseMap.baseMapLayers[].opacity", support: "full" },
+    {
+        path: "baseMap.baseMapLayers[].styleUrl",
+        support: "partial",
+        notes: "Noted in metadata; sprite/glyph resolution not performed",
+    },
+    // ── Operational layers ──
+    { path: "operationalLayers[]", support: "partial" },
+    { path: "operationalLayers[].id", support: "full" },
+    { path: "operationalLayers[].title", support: "full", notes: "Used as layer metadata" },
+    { path: "operationalLayers[].url", support: "full" },
+    {
+        path: "operationalLayers[].layerType",
+        support: "partial",
+        notes: "ArcGISFeatureLayer, ArcGISMapServiceLayer supported",
+    },
+    { path: "operationalLayers[].visibility", support: "full" },
+    { path: "operationalLayers[].opacity", support: "full" },
+    { path: "operationalLayers[].minScale", support: "full" },
+    { path: "operationalLayers[].maxScale", support: "full" },
+    // ── Layer definition ──
+    { path: "operationalLayers[].layerDefinition", support: "partial" },
+    { path: "operationalLayers[].layerDefinition.definitionExpression", support: "full" },
+    { path: "operationalLayers[].layerDefinition.drawingInfo", support: "partial" },
+    { path: "operationalLayers[].layerDefinition.drawingInfo.transparency", support: "full" },
+    // ── Renderers ──
+    { path: "operationalLayers[].layerDefinition.drawingInfo.renderer", support: "partial" },
+    { path: "operationalLayers[].layerDefinition.drawingInfo.renderer (simple)", support: "full" },
+    { path: "operationalLayers[].layerDefinition.drawingInfo.renderer (uniqueValue)", support: "full" },
+    { path: "operationalLayers[].layerDefinition.drawingInfo.renderer (classBreaks)", support: "full" },
+    {
+        path: "operationalLayers[].layerDefinition.drawingInfo.renderer (heatmap)",
+        support: "unsupported",
+        notes: "Warning emitted",
+    },
+    {
+        path: "operationalLayers[].layerDefinition.drawingInfo.renderer (dotDensity)",
+        support: "unsupported",
+        notes: "Warning emitted",
+    },
+    // ── Symbols ──
+    { path: "symbol (esriSFS)", support: "full", notes: "Simple fill symbol → fill layer" },
+    { path: "symbol (esriSLS)", support: "full", notes: "Simple line symbol → line layer" },
+    { path: "symbol (esriSMS)", support: "full", notes: "Simple marker symbol → circle layer" },
+    { path: "symbol (esriPMS)", support: "partial", notes: "Picture marker → symbol layer; requires sprite setup" },
+    { path: "symbol (esriTS)", support: "partial", notes: "Text symbol → symbol layer with text" },
+    // ── Labeling ──
+    { path: "operationalLayers[].layerDefinition.drawingInfo.labelingInfo", support: "partial" },
+    {
+        path: "operationalLayers[].layerDefinition.drawingInfo.labelingInfo[].labelExpressionInfo.expression",
+        support: "partial",
+        notes: "Simple $feature.FIELD supported; complex Arcade skipped",
+    },
+    // ── Popups ──
+    {
+        path: "operationalLayers[].popupInfo",
+        support: "full",
+        notes: "Passed through as metadata (MapLibre has no popup spec)",
+    },
+    { path: "operationalLayers[].popupInfo.title", support: "full" },
+    { path: "operationalLayers[].popupInfo.description", support: "full" },
+    { path: "operationalLayers[].popupInfo.fieldInfos", support: "full" },
+    { path: "operationalLayers[].popupInfo.mediaInfos", support: "full" },
+    {
+        path: "operationalLayers[].popupInfo.expressionInfos",
+        support: "unsupported",
+        notes: "Warning emitted; manual intervention",
+    },
+    // ── Feature collection (inline) ──
+    {
+        path: "operationalLayers[].featureCollection",
+        support: "unsupported",
+        notes: "Inline feature collections not yet supported",
+    },
+    // ── 3D ──
+    {
+        path: "ground / viewingMode / camera / elevationInfo",
+        support: "unsupported",
+        notes: "Warning emitted; manual intervention",
+    },
+];
+export function getContractSummary() {
+    const summary = { total: 0, full: 0, partial: 0, ignored: 0, unsupported: 0 };
+    for (const entry of CONTRACT) {
+        summary.total++;
+        summary[entry.support]++;
+    }
+    return summary;
+}

package/webmap/convert-basemap.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Converts Esri WebMap baseMap to Honua sources and layers.
+ *
+ * @module
+ */
+import type { HonuaLayerSpecification, HonuaMapServiceSourceSpecification } from "../style/specification.js";
+import type { WebMapBaseMap } from "./types.js";
+import { type WarningCollector } from "./warnings.js";
+export interface BasemapConversionResult {
+    sources: Record<string, HonuaMapServiceSourceSpecification | {
+        type: string;
+        [key: string]: unknown;
+    }>;
+    layers: HonuaLayerSpecification[];
+}
+export declare function convertBasemap(baseMap: WebMapBaseMap | undefined, warn: WarningCollector): BasemapConversionResult;
+//# sourceMappingURL=convert-basemap.d.ts.map

package/webmap/convert-basemap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-basemap.d.ts","sourceRoot":"","sources":["../../../src/webmap/convert-basemap.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,kCAAkC,EAAE,MAAM,2BAA2B,CAAC;AAC7G,OAAO,KAAK,EAAE,aAAa,EAAsB,MAAM,YAAY,CAAC;AACpE,OAAO,EAAE,KAAK,gBAAgB,EAAyB,MAAM,eAAe,CAAC;AAE7E,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,kCAAkC,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC,CAAC;IACvG,MAAM,EAAE,uBAAuB,EAAE,CAAC;CACnC;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,EAAE,IAAI,EAAE,gBAAgB,GAAG,uBAAuB,CA6ElH"}

package/webmap/convert-basemap.js

@@ -0,0 +1,78 @@
+/**
+ * Converts Esri WebMap baseMap to Honua sources and layers.
+ *
+ * @module
+ */
+import { warnUnknownProperties } from "./warnings.js";
+export function convertBasemap(baseMap, warn) {
+    const result = { sources: {}, layers: [] };
+    if (!baseMap?.baseMapLayers)
+        return result;
+    warnUnknownProperties(baseMap, BASEMAP_PROPERTIES, warn);
+    const bmLayers = baseMap.baseMapLayers;
+    for (let i = 0; i < bmLayers.length; i++) {
+        const bml = bmLayers[i];
+        const bmlWarn = warn.child(`baseMapLayers[${i}]`);
+        warnUnknownProperties(bml, BASEMAP_LAYER_PROPERTIES, bmlWarn);
+        const sourceId = bml.id ?? `basemap-${i}`;
+        const layerId = `${sourceId}-layer`;
+        const layerType = bml.layerType ?? "";
+        if (layerType === "ArcGISTiledMapServiceLayer" && bml.url) {
+            result.sources[sourceId] = {
+                type: "honua-map-service",
+                url: bml.url,
+            };
+            const layer = {
+                id: layerId,
+                type: "raster",
+                source: sourceId,
+                layout: {},
+                paint: {},
+            };
+            if (bml.visibility === false) {
+                layer.layout = { visibility: "none" };
+            }
+            if (bml.opacity != null && bml.opacity < 1) {
+                layer.paint["raster-opacity"] = bml.opacity;
+            }
+            result.layers.push(layer);
+        }
+        else if (layerType === "VectorTileLayer") {
+            // Partial support: note styleUrl in metadata
+            if (bml.url) {
+                result.sources[sourceId] = {
+                    type: "vector",
+                    url: bml.url,
+                };
+            }
+            else {
+                bmlWarn.warn("missing-url", "VectorTileLayer missing url");
+                continue;
+            }
+            const layer = {
+                id: layerId,
+                type: "background",
+                source: sourceId,
+                layout: {},
+                paint: {},
+                metadata: {
+                    ...(bml.styleUrl ? { esriStyleUrl: bml.styleUrl } : {}),
+                    note: "VectorTileLayer requires style resolution; using placeholder background layer",
+                },
+            };
+            if (bml.visibility === false) {
+                layer.layout = { visibility: "none" };
+            }
+            bmlWarn.warn("vector-tile-partial", "VectorTileLayer support is partial; style must be resolved separately", {
+                styleUrl: bml.styleUrl,
+            });
+            result.layers.push(layer);
+        }
+        else {
+            bmlWarn.warn("unsupported-basemap-type", `Unsupported basemap layer type: ${layerType}`, { layerType });
+        }
+    }
+    return result;
+}
+const BASEMAP_PROPERTIES = ["title", "baseMapLayers"];
+const BASEMAP_LAYER_PROPERTIES = ["id", "title", "url", "layerType", "visibility", "opacity", "styleUrl"];

package/webmap/convert-extent.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Converts Esri WebMap extents/viewpoints to MapLibre center/zoom.
+ *
+ * Supports Web Mercator (WKID 3857 / 102100) and geographic (4326).
+ * Unsupported spatial references emit warnings and are skipped.
+ *
+ * @module
+ */
+import type { WebMapExtent, WebMapViewpoint } from "./types.js";
+import type { WarningCollector } from "./warnings.js";
+export interface ExtentConversionResult {
+    center: [number, number];
+    zoom: number;
+}
+export declare function convertInitialViewpoint(viewpoint: WebMapViewpoint | undefined, warn: WarningCollector): ExtentConversionResult | undefined;
+export declare function convertExtent(extent: WebMapExtent | undefined, warn: WarningCollector): ExtentConversionResult | undefined;
+//# sourceMappingURL=convert-extent.d.ts.map

package/webmap/convert-extent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-extent.d.ts","sourceRoot":"","sources":["../../../src/webmap/convert-extent.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAe,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;CACd;AAMD,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,eAAe,GAAG,SAAS,EACtC,IAAI,EAAE,gBAAgB,GACrB,sBAAsB,GAAG,SAAS,CAsBpC;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,YAAY,GAAG,SAAS,EAChC,IAAI,EAAE,gBAAgB,GACrB,sBAAsB,GAAG,SAAS,CAyBpC"}