@honua/react 0.0.20-alpha.0

package/webmap/convert-renderer.js

@@ -0,0 +1,161 @@
+/**
+ * Converts Esri renderer JSON to MapLibre paint/layout properties.
+ *
+ * Handles simple, uniqueValue, and classBreaks renderers. Produces
+ * data-driven expressions (match, step) for categorized/graduated renderers.
+ *
+ * @module
+ */
+import { convertSymbol, esriColorToCss } from "./convert-symbol.js";
+export function convertRenderer(renderer, warn) {
+    if (!renderer)
+        return undefined;
+    switch (renderer.type) {
+        case "simple":
+            return convertSimpleRenderer(renderer.symbol, warn);
+        case "uniqueValue":
+            return convertUniqueValueRenderer(renderer, warn);
+        case "classBreaks":
+            return convertClassBreaksRenderer(renderer, warn);
+        default:
+            warn.warn("unsupported-renderer", `Unsupported renderer type: ${renderer.type}`, { type: renderer.type });
+            return undefined;
+    }
+}
+function convertSimpleRenderer(symbol, warn) {
+    return convertSymbol(symbol, warn);
+}
+function convertUniqueValueRenderer(renderer, warn) {
+    const infos = renderer.uniqueValueInfos ?? [];
+    if (infos.length === 0) {
+        return convertSymbol(renderer.defaultSymbol, warn);
+    }
+    // Determine the layer type from the first valid symbol
+    const firstResult = convertSymbol(infos[0].symbol, warn);
+    if (!firstResult)
+        return undefined;
+    const { layerType } = firstResult;
+    // Build the field expression
+    const fieldExpr = buildFieldExpression(renderer);
+    // Build paint properties with match expressions
+    const paintKeys = collectPaintKeys(infos, warn, layerType);
+    const paint = {};
+    const layout = {};
+    for (const key of paintKeys) {
+        const matchArgs = [fieldExpr];
+        for (const info of infos) {
+            const symbolResult = convertSymbol(info.symbol, warn);
+            if (!symbolResult)
+                continue;
+            matchArgs.push(info.value);
+            matchArgs.push(symbolResult.paint[key] ?? symbolResult.layout[key]);
+        }
+        // Default value from defaultSymbol or first symbol
+        const defaultResult = renderer.defaultSymbol ? convertSymbol(renderer.defaultSymbol, warn) : firstResult;
+        const defaultVal = defaultResult?.paint[key] ?? defaultResult?.layout[key] ?? "transparent";
+        matchArgs.push(defaultVal);
+        if (isLayoutProperty(key)) {
+            layout[key] = ["match", ...matchArgs];
+        }
+        else {
+            paint[key] = ["match", ...matchArgs];
+        }
+    }
+    return { layerType, paint, layout };
+}
+function convertClassBreaksRenderer(renderer, warn) {
+    const breaks = renderer.classBreakInfos ?? [];
+    if (breaks.length === 0) {
+        return convertSymbol(renderer.defaultSymbol, warn);
+    }
+    const firstResult = convertSymbol(breaks[0].symbol, warn);
+    if (!firstResult)
+        return undefined;
+    const { layerType } = firstResult;
+    const field = renderer.field;
+    if (!field) {
+        warn.warn("missing-field", "classBreaks renderer missing field property");
+        return undefined;
+    }
+    const paintKeys = collectPaintKeysFromBreaks(breaks, warn, layerType);
+    const paint = {};
+    const layout = {};
+    for (const key of paintKeys) {
+        // Default value
+        const defaultResult = renderer.defaultSymbol ? convertSymbol(renderer.defaultSymbol, warn) : firstResult;
+        const defaultVal = defaultResult?.paint[key] ?? defaultResult?.layout[key] ?? "transparent";
+        const stepArgs = [["get", field], defaultVal];
+        for (const brk of breaks) {
+            const symbolResult = convertSymbol(brk.symbol, warn);
+            if (!symbolResult)
+                continue;
+            const threshold = brk.classMinValue ?? brk.classMaxValue;
+            stepArgs.push(threshold);
+            stepArgs.push(symbolResult.paint[key] ?? symbolResult.layout[key]);
+        }
+        if (isLayoutProperty(key)) {
+            layout[key] = ["step", ...stepArgs];
+        }
+        else {
+            paint[key] = ["step", ...stepArgs];
+        }
+    }
+    return { layerType, paint, layout };
+}
+function buildFieldExpression(renderer) {
+    if (!renderer.field2 && !renderer.field3) {
+        return ["get", renderer.field1 ?? ""];
+    }
+    // Multi-field: concatenate with delimiter
+    const delim = renderer.fieldDelimiter ?? ",";
+    const fields = [];
+    if (renderer.field1)
+        fields.push(["get", renderer.field1]);
+    if (renderer.field2) {
+        fields.push(delim);
+        fields.push(["get", renderer.field2]);
+    }
+    if (renderer.field3) {
+        fields.push(delim);
+        fields.push(["get", renderer.field3]);
+    }
+    return ["concat", ...fields];
+}
+function collectPaintKeys(infos, warn, layerType) {
+    const keys = new Set();
+    for (const info of infos) {
+        const result = convertSymbol(info.symbol, warn);
+        if (!result)
+            continue;
+        for (const k of Object.keys(result.paint))
+            keys.add(k);
+        for (const k of Object.keys(result.layout))
+            keys.add(k);
+    }
+    return keys;
+}
+function collectPaintKeysFromBreaks(breaks, warn, layerType) {
+    return collectPaintKeys(breaks, warn, layerType);
+}
+const LAYOUT_PROPERTIES = new Set([
+    "icon-image",
+    "icon-size",
+    "icon-offset",
+    "icon-anchor",
+    "icon-rotate",
+    "text-field",
+    "text-font",
+    "text-size",
+    "text-offset",
+    "text-anchor",
+    "text-max-width",
+    "text-letter-spacing",
+    "text-justify",
+    "text-rotate",
+    "symbol-placement",
+    "symbol-spacing",
+    "visibility",
+]);
+function isLayoutProperty(key) {
+    return LAYOUT_PROPERTIES.has(key);
+}

package/webmap/convert-symbol.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Converts Esri symbol JSON to MapLibre paint/layout properties.
+ *
+ * @module
+ */
+import type { EsriColor, WebMapSymbol } from "./types.js";
+import type { WarningCollector } from "./warnings.js";
+/** Convert Esri `[r,g,b,a]` (a 0–255) to CSS `rgba()` string. */
+export declare function esriColorToCss(color: EsriColor | undefined): string | undefined;
+export declare function esriLineStyleToDashArray(style: string | undefined): number[] | undefined;
+export interface SymbolConversionResult {
+    layerType: string;
+    paint: Record<string, unknown>;
+    layout: Record<string, unknown>;
+}
+export declare function convertSymbol(symbol: WebMapSymbol | undefined, warn: WarningCollector): SymbolConversionResult | undefined;
+//# sourceMappingURL=convert-symbol.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"convert-symbol.d.ts","sourceRoot":"","sources":["../../../src/webmap/convert-symbol.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,SAAS,EAKT,YAAY,EAEb,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAItD,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAM/E;AAaD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,GAAG,SAAS,CAGxF;AAID,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,YAAY,GAAG,SAAS,EAChC,IAAI,EAAE,gBAAgB,GACrB,sBAAsB,GAAG,SAAS,CAkBpC"}

package/webmap/convert-symbol.js

@@ -0,0 +1,122 @@
+/**
+ * Converts Esri symbol JSON to MapLibre paint/layout properties.
+ *
+ * @module
+ */
+// ── Color conversion ────────────────────────────────────────
+/** Convert Esri `[r,g,b,a]` (a 0–255) to CSS `rgba()` string. */
+export function esriColorToCss(color) {
+    if (!color || color.length < 4)
+        return undefined;
+    const [r, g, b, a] = color;
+    const alpha = Math.round((a / 255) * 100) / 100;
+    if (alpha === 1)
+        return `rgb(${r},${g},${b})`;
+    return `rgba(${r},${g},${b},${alpha})`;
+}
+// ── Line style mapping ──────────────────────────────────────
+const LINE_DASH_MAP = {
+    esriSLSSolid: undefined,
+    esriSLSDash: [6, 4],
+    esriSLSDot: [2, 4],
+    esriSLSDashDot: [6, 4, 2, 4],
+    esriSLSDashDotDot: [6, 4, 2, 4, 2, 4],
+    esriSLSNull: [0, 10],
+};
+export function esriLineStyleToDashArray(style) {
+    if (!style)
+        return undefined;
+    return LINE_DASH_MAP[style];
+}
+export function convertSymbol(symbol, warn) {
+    if (!symbol)
+        return undefined;
+    switch (symbol.type) {
+        case "esriSFS":
+            return convertSimpleFill(symbol);
+        case "esriSLS":
+            return convertSimpleLine(symbol);
+        case "esriSMS":
+            return convertSimpleMarker(symbol);
+        case "esriPMS":
+            return convertPictureMarker(symbol, warn);
+        case "esriTS":
+            return convertTextSymbol(symbol);
+        default:
+            warn.warn("unsupported-symbol", `Unsupported symbol type: ${symbol.type}`);
+            return undefined;
+    }
+}
+function convertSimpleFill(symbol) {
+    const paint = {};
+    const fillColor = esriColorToCss(symbol.color);
+    if (fillColor)
+        paint["fill-color"] = fillColor;
+    if (symbol.color) {
+        const alpha = symbol.color[3] / 255;
+        if (alpha < 1)
+            paint["fill-opacity"] = Math.round(alpha * 100) / 100;
+    }
+    if (symbol.outline) {
+        const outlineColor = esriColorToCss(symbol.outline.color);
+        if (outlineColor)
+            paint["fill-outline-color"] = outlineColor;
+    }
+    return { layerType: "fill", paint, layout: {} };
+}
+function convertSimpleLine(symbol) {
+    const paint = {};
+    const layout = {};
+    const lineColor = esriColorToCss(symbol.color);
+    if (lineColor)
+        paint["line-color"] = lineColor;
+    if (symbol.width != null)
+        paint["line-width"] = symbol.width;
+    const dashArray = esriLineStyleToDashArray(symbol.style);
+    if (dashArray)
+        paint["line-dasharray"] = dashArray;
+    return { layerType: "line", paint, layout };
+}
+function convertSimpleMarker(symbol) {
+    const paint = {};
+    const circleColor = esriColorToCss(symbol.color);
+    if (circleColor)
+        paint["circle-color"] = circleColor;
+    if (symbol.size != null)
+        paint["circle-radius"] = symbol.size / 2;
+    if (symbol.outline) {
+        const strokeColor = esriColorToCss(symbol.outline.color);
+        if (strokeColor)
+            paint["circle-stroke-color"] = strokeColor;
+        if (symbol.outline.width != null)
+            paint["circle-stroke-width"] = symbol.outline.width;
+    }
+    return { layerType: "circle", paint, layout: {} };
+}
+function convertPictureMarker(symbol, warn) {
+    const layout = {};
+    if (symbol.url) {
+        layout["icon-image"] = symbol.url;
+        warn.warn("sprite-required", "Picture marker symbol requires sprite setup for icon-image", { url: symbol.url });
+    }
+    if (symbol.width != null && symbol.height != null) {
+        layout["icon-size"] = 1;
+    }
+    return { layerType: "symbol", paint: {}, layout };
+}
+function convertTextSymbol(symbol) {
+    const paint = {};
+    const layout = {};
+    const textColor = esriColorToCss(symbol.color);
+    if (textColor)
+        paint["text-color"] = textColor;
+    if (symbol.text)
+        layout["text-field"] = symbol.text;
+    if (symbol.font) {
+        if (symbol.font.size != null)
+            layout["text-size"] = symbol.font.size;
+        if (symbol.font.family)
+            layout["text-font"] = [symbol.font.family];
+    }
+    return { layerType: "symbol", paint, layout };
+}

package/webmap/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `@honua/sdk-js/webmap` — WebMap JSON parse + symbol / renderer / popup converters.
+ *
+ * @example
+ * ```ts
+ * import { parseWebMap } from "@honua/sdk-js/webmap";
+ *
+ * const webmapJson = await (await fetch("/path/to/webmap.json")).json();
+ * const { layers, warnings } = parseWebMap(webmapJson);
+ * if (warnings.length > 0) console.warn("WebMap conversion warnings:", warnings);
+ * ```
+ *
+ * @example Inspect the compatibility contract
+ * ```ts
+ * import { CONTRACT, getContractSummary } from "@honua/sdk-js/webmap";
+ *
+ * const summary = getContractSummary();
+ * console.log(summary.supported);   // ["FeatureLayer", "MapImageLayer", ...]
+ * console.log(summary.unsupported); // entries with `support: "unsupported"` + reason
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { parseWebMap } from "./parse.js";
+export type { ParseWebMapOptions, ParseWebMapResult } from "./parse.js";
+export { createWarningCollector } from "./warnings.js";
+export type { WebMapWarning, WarningCollector } from "./warnings.js";
+export { CONTRACT, getContractSummary } from "./contract.js";
+export type { ContractEntry, ContractSupport, ContractSummary } from "./contract.js";
+export { convertSymbol, esriColorToCss, esriLineStyleToDashArray } from "./convert-symbol.js";
+export type { SymbolConversionResult } from "./convert-symbol.js";
+export { convertRenderer } from "./convert-renderer.js";
+export type { RendererConversionResult } from "./convert-renderer.js";
+export { convertPopupInfo } from "./convert-popup.js";
+export type { HonuaPopupConfig, HonuaPopupFieldInfo, HonuaPopupMediaInfo } from "./convert-popup.js";
+export { convertLabelingInfo } from "./convert-label.js";
+export { convertBasemap } from "./convert-basemap.js";
+export type { BasemapConversionResult } from "./convert-basemap.js";
+export { convertExtent, convertInitialViewpoint } from "./convert-extent.js";
+export type { ExtentConversionResult } from "./convert-extent.js";
+export { convertOperationalLayer } from "./convert-layer.js";
+export type { LayerConversionResult } from "./convert-layer.js";
+export type { WebMapJson, WebMapOperationalLayer, WebMapRenderer, WebMapSimpleRenderer, WebMapUniqueValueRenderer, WebMapClassBreaksRenderer, WebMapSymbol, WebMapSimpleFillSymbol, WebMapSimpleLineSymbol, WebMapSimpleMarkerSymbol, WebMapPictureMarkerSymbol, WebMapTextSymbol, WebMapBaseMap, WebMapBaseMapLayer, WebMapPopupInfo, WebMapFieldInfo, WebMapExtent, WebMapPoint, WebMapViewpoint, WebMapViewpointTargetGeometry, WebMapInitialState, WebMapBookmark, WebMapSpatialReference, WebMapLabelClass, WebMapDrawingInfo, WebMapLayerDefinition, EsriColor, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/webmap/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/webmap/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAC7D,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC9F,YAAY,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,YAAY,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACrG,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAC7E,YAAY,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,YAAY,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAChE,YAAY,EACV,UAAU,EACV,sBAAsB,EACtB,cAAc,EACd,oBAAoB,EACpB,yBAAyB,EACzB,yBAAyB,EACzB,YAAY,EACZ,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,EAChB,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,eAAe,EACf,YAAY,EACZ,WAAW,EACX,eAAe,EACf,6BAA6B,EAC7B,kBAAkB,EAClB,cAAc,EACd,sBAAsB,EACtB,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,SAAS,GACV,MAAM,YAAY,CAAC"}

package/webmap/index.js

@@ -0,0 +1,33 @@
+/**
+ * `@honua/sdk-js/webmap` — WebMap JSON parse + symbol / renderer / popup converters.
+ *
+ * @example
+ * ```ts
+ * import { parseWebMap } from "@honua/sdk-js/webmap";
+ *
+ * const webmapJson = await (await fetch("/path/to/webmap.json")).json();
+ * const { layers, warnings } = parseWebMap(webmapJson);
+ * if (warnings.length > 0) console.warn("WebMap conversion warnings:", warnings);
+ * ```
+ *
+ * @example Inspect the compatibility contract
+ * ```ts
+ * import { CONTRACT, getContractSummary } from "@honua/sdk-js/webmap";
+ *
+ * const summary = getContractSummary();
+ * console.log(summary.supported);   // ["FeatureLayer", "MapImageLayer", ...]
+ * console.log(summary.unsupported); // entries with `support: "unsupported"` + reason
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { parseWebMap } from "./parse.js";
+export { createWarningCollector } from "./warnings.js";
+export { CONTRACT, getContractSummary } from "./contract.js";
+export { convertSymbol, esriColorToCss, esriLineStyleToDashArray } from "./convert-symbol.js";
+export { convertRenderer } from "./convert-renderer.js";
+export { convertPopupInfo } from "./convert-popup.js";
+export { convertLabelingInfo } from "./convert-label.js";
+export { convertBasemap } from "./convert-basemap.js";
+export { convertExtent, convertInitialViewpoint } from "./convert-extent.js";
+export { convertOperationalLayer } from "./convert-layer.js";

package/webmap/parse.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Top-level WebMap JSON → HonuaStyleSpecification parser.
+ *
+ * @module
+ */
+import type { HonuaStyleSpecification } from "../style/specification.js";
+import type { HonuaPopupConfig } from "./convert-popup.js";
+import type { WebMapBookmark, WebMapJson } from "./types.js";
+import { type WebMapWarning } from "./warnings.js";
+export interface ParseWebMapOptions {
+    /** If true, include basemap layers. Defaults to true. */
+    includeBasemap?: boolean;
+}
+export interface ParseWebMapResult {
+    /** The converted style specification. */
+    style: HonuaStyleSpecification;
+    /** Non-fatal warnings encountered during conversion. */
+    warnings: WebMapWarning[];
+    /** Bookmarks from the WebMap, if any. */
+    bookmarks: WebMapBookmark[];
+    /** Popup configurations keyed by layer ID. */
+    popups: Record<string, HonuaPopupConfig>;
+}
+export declare function parseWebMap(input: WebMapJson, options?: ParseWebMapOptions): ParseWebMapResult;
+//# sourceMappingURL=parse.d.ts.map

package/webmap/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/webmap/parse.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAIzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAA0B,MAAM,YAAY,CAAC;AACrF,OAAO,EAEL,KAAK,aAAa,EAGnB,MAAM,eAAe,CAAC;AAEvB,MAAM,WAAW,kBAAkB;IACjC,yDAAyD;IACzD,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,iBAAiB;IAChC,yCAAyC;IACzC,KAAK,EAAE,uBAAuB,CAAC;IAC/B,wDAAwD;IACxD,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,yCAAyC;IACzC,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CAC1C;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,iBAAiB,CAoD9F"}

package/webmap/parse.js

@@ -0,0 +1,83 @@
+/**
+ * Top-level WebMap JSON → HonuaStyleSpecification parser.
+ *
+ * @module
+ */
+import { convertBasemap } from "./convert-basemap.js";
+import { convertExtent, convertInitialViewpoint } from "./convert-extent.js";
+import { convertOperationalLayer } from "./convert-layer.js";
+import { createWarningCollector, warnUnknownProperties, } from "./warnings.js";
+export function parseWebMap(input, options) {
+    const warn = createWarningCollector();
+    const includeBasemap = options?.includeBasemap !== false;
+    warnUnknownProperties(input, WEBMAP_TOP_LEVEL_PROPERTIES, warn);
+    detectVersionWarnings(input, warn);
+    detectUnsupported3DProperties(input, warn);
+    const sources = {};
+    const layers = [];
+    const popups = {};
+    // Convert basemap
+    if (includeBasemap && input.baseMap) {
+        const basemapResult = convertBasemap(input.baseMap, warn.child("baseMap"));
+        Object.assign(sources, basemapResult.sources);
+        layers.push(...basemapResult.layers);
+    }
+    // Convert operational layers
+    if (input.operationalLayers) {
+        const opLayers = input.operationalLayers;
+        for (let i = 0; i < opLayers.length; i++) {
+            const opLayer = opLayers[i];
+            const layerResult = convertOperationalLayer(opLayer, i, warn);
+            Object.assign(sources, layerResult.sources);
+            layers.push(...layerResult.layers);
+            if (layerResult.popup) {
+                const layerId = opLayer.id ?? `operational-${i}`;
+                popups[layerId] = layerResult.popup;
+            }
+        }
+    }
+    // Convert initial viewpoint (preferred over initialExtent for WebMap 2.x)
+    const viewpointResult = convertInitialViewpoint(input.initialViewpoint ?? input.initialState?.viewpoint, warn.child("initialViewpoint"));
+    const extentResult = viewpointResult ?? convertExtent(input.initialExtent, warn.child("initialExtent"));
+    const style = {
+        version: 8,
+        sources,
+        layers,
+        ...(extentResult ? { center: extentResult.center, zoom: extentResult.zoom } : {}),
+    };
+    // Bookmarks
+    const bookmarks = input.bookmarks ?? [];
+    return { style, warnings: warn.warnings, bookmarks, popups };
+}
+const WEBMAP_TOP_LEVEL_PROPERTIES = [
+    "version",
+    "authoringApp",
+    "authoringAppVersion",
+    "operationalLayers",
+    "baseMap",
+    "initialExtent",
+    "initialViewpoint",
+    "initialState",
+    "bookmarks",
+    "spatialReference",
+    "tables",
+];
+const THREE_D_TOP_LEVEL_PROPERTIES = new Set(["ground", "heightModelInfo", "viewingMode", "camera"]);
+function detectVersionWarnings(input, warn) {
+    if (typeof input.version === "string" && !input.version.startsWith("2.")) {
+        warn.warn("unsupported-webmap-version", `WebMap version '${input.version}' is outside the 2.x compatibility target`, { version: input.version });
+    }
+}
+function detectUnsupported3DProperties(input, warn) {
+    for (const key of THREE_D_TOP_LEVEL_PROPERTIES) {
+        if (Object.prototype.hasOwnProperty.call(input, key)) {
+            warn.warn("unsupported-3d-property", `Top-level 3D property '${key}' is not supported by the 2D WebMap style path`, {
+                property: key,
+                status: key === "ground" || key === "camera" ? "degraded" : "unsupported",
+                fallback: key === "ground"
+                    ? "Convert ground/elevation metadata into scene workspace terrain primitives for MapLibre 2.5D."
+                    : "Preserve the property for a scene renderer adapter; the generated 2D style will ignore it.",
+            });
+        }
+    }
+}