@honua/app-platform 0.0.20-alpha.0

package/esri-compat/group-layer.d.ts

@@ -0,0 +1,48 @@
+import { CompatEventBus } from "./event-bus.js";
+export interface GroupLayerCompatOptions {
+    id?: string;
+    title?: string;
+    layers?: unknown[];
+    visible?: boolean;
+    opacity?: number;
+    listMode?: "show" | "hide";
+    visibilityMode?: "independent" | "inherited" | "exclusive";
+    eventBus?: CompatEventBus;
+}
+export type GroupLayerLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface GroupLayerHandleCompat {
+    remove(): void;
+}
+export declare class GroupLayerCompat {
+    readonly type: "group";
+    id: string | undefined;
+    title: string | undefined;
+    visible: boolean;
+    opacity: number;
+    listMode: "show" | "hide";
+    visibilityMode: "independent" | "inherited" | "exclusive";
+    loaded: boolean;
+    loadStatus: GroupLayerLoadStatusCompat;
+    readonly eventBus: CompatEventBus;
+    private readonly layersInternal;
+    private readonly watchListeners;
+    private readonly eventListeners;
+    constructor(options?: GroupLayerCompatOptions);
+    load(): Promise<GroupLayerCompat>;
+    when(callback?: (layer: GroupLayerCompat) => void): Promise<GroupLayerCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): GroupLayerHandleCompat;
+    get layers(): readonly unknown[];
+    get allLayers(): readonly unknown[];
+    add(layer: unknown, index?: number): void;
+    addMany(layers: readonly unknown[], index?: number): void;
+    remove(layer: unknown): boolean;
+    removeMany(layers: readonly unknown[]): number;
+    removeAll(): void;
+    findLayerById(id: string): unknown;
+    setVisibility(visible: boolean): void;
+    setOpacity(opacity: number): void;
+    on(eventName: string, listener: (event: unknown) => void): GroupLayerHandleCompat;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=group-layer.d.ts.map

package/esri-compat/group-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-layer.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/group-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAmD,MAAM,gBAAgB,CAAC;AAEjG,MAAM,WAAW,uBAAuB;IACtC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,aAAa,GAAG,WAAW,GAAG,WAAW,CAAC;IAC3D,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,MAAM,MAAM,0BAA0B,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE7E,MAAM,WAAW,sBAAsB;IACrC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,gBAAgB;IAC3B,SAAgB,IAAI,EAAE,OAAO,CAAC;IACvB,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,cAAc,EAAE,aAAa,GAAG,WAAW,GAAG,WAAW,CAAC;IAC1D,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,0BAA0B,CAAC;IAC9C,SAAgB,QAAQ,EAAE,cAAc,CAAC;IACzC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAY;IAC3C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;IAC5E,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,uBAA4B;IAgB3C,IAAI,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAgBjC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAQnF,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,sBAAsB;IAe9F,IAAW,MAAM,IAAI,SAAS,OAAO,EAAE,CAEtC;IAED,IAAW,SAAS,IAAI,SAAS,OAAO,EAAE,CAOzC;IAEM,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAoBzC,OAAO,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IA6BzD,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAa/B,UAAU,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,MAAM;IAU9C,SAAS,IAAI,IAAI;IAQjB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAUlC,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAMrC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAMjC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,sBAAsB;IAqBjF,OAAO,IAAI,IAAI;IAMtB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/group-layer.js

@@ -0,0 +1,212 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+export class GroupLayerCompat {
+    type;
+    id;
+    title;
+    visible;
+    opacity;
+    listMode;
+    visibilityMode;
+    loaded;
+    loadStatus;
+    eventBus;
+    layersInternal;
+    watchListeners;
+    eventListeners;
+    constructor(options = {}) {
+        this.type = "group";
+        this.id = options.id;
+        this.title = options.title;
+        this.visible = options.visible ?? true;
+        this.opacity = options.opacity ?? 1;
+        this.listMode = options.listMode ?? "show";
+        this.visibilityMode = options.visibilityMode ?? "independent";
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.layersInternal = Array.isArray(options.layers) ? [...options.layers] : [];
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.layers) ?? new CompatEventBus();
+        this.watchListeners = new Map();
+        this.eventListeners = new Map();
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("group-layer.loading", { layerId: this.id }, this);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("group-layer.loaded", { layerId: this.id }, this);
+        return this;
+    }
+    async when(callback) {
+        const layer = await this.load();
+        if (callback) {
+            callback(layer);
+        }
+        return layer;
+    }
+    watch(propertyName, listener) {
+        let listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            listeners = new Set();
+            this.watchListeners.set(propertyName, listeners);
+        }
+        listeners.add(listener);
+        return {
+            remove: () => {
+                listeners?.delete(listener);
+            },
+        };
+    }
+    get layers() {
+        return this.layersInternal;
+    }
+    get allLayers() {
+        const flattened = [];
+        for (const layer of this.layersInternal) {
+            flattened.push(layer);
+            flattened.push(...extractNestedLayers(layer));
+        }
+        return flattened;
+    }
+    add(layer, index) {
+        if (index === undefined) {
+            this.layersInternal.push(layer);
+            this.notifyWatchers("layers", this.layers);
+            this.notifyWatchers("allLayers", this.allLayers);
+            this.eventBus.emit("group-layer.layer-added", { groupLayerId: this.id, layer, index: this.layersInternal.length - 1 }, this);
+            return;
+        }
+        const insertAt = normalizeInsertIndex(index, this.layersInternal.length);
+        this.layersInternal.splice(insertAt, 0, layer);
+        this.notifyWatchers("layers", this.layers);
+        this.notifyWatchers("allLayers", this.allLayers);
+        this.eventBus.emit("group-layer.layer-added", { groupLayerId: this.id, layer, index: insertAt }, this);
+    }
+    addMany(layers, index) {
+        if (layers.length === 0) {
+            return;
+        }
+        if (index === undefined) {
+            const startIndex = this.layersInternal.length;
+            this.layersInternal.push(...layers);
+            this.notifyWatchers("layers", this.layers);
+            this.notifyWatchers("allLayers", this.allLayers);
+            this.eventBus.emit("group-layer.layers-added", { groupLayerId: this.id, layers: [...layers], index: startIndex }, this);
+            return;
+        }
+        const insertAt = normalizeInsertIndex(index, this.layersInternal.length);
+        this.layersInternal.splice(insertAt, 0, ...layers);
+        this.notifyWatchers("layers", this.layers);
+        this.notifyWatchers("allLayers", this.allLayers);
+        this.eventBus.emit("group-layer.layers-added", { groupLayerId: this.id, layers: [...layers], index: insertAt }, this);
+    }
+    remove(layer) {
+        const index = this.layersInternal.indexOf(layer);
+        if (index < 0) {
+            return false;
+        }
+        this.layersInternal.splice(index, 1);
+        this.notifyWatchers("layers", this.layers);
+        this.notifyWatchers("allLayers", this.allLayers);
+        this.eventBus.emit("group-layer.layer-removed", { groupLayerId: this.id, layer, index }, this);
+        return true;
+    }
+    removeMany(layers) {
+        let removedCount = 0;
+        for (const layer of layers) {
+            if (this.remove(layer)) {
+                removedCount += 1;
+            }
+        }
+        return removedCount;
+    }
+    removeAll() {
+        const removedLayers = [...this.layersInternal];
+        this.layersInternal.length = 0;
+        this.notifyWatchers("layers", this.layers);
+        this.notifyWatchers("allLayers", this.allLayers);
+        this.eventBus.emit("group-layer.layers-cleared", { groupLayerId: this.id, layers: removedLayers }, this);
+    }
+    findLayerById(id) {
+        for (const layer of this.allLayers) {
+            if (isLayerWithId(layer) && layer.id === id) {
+                return layer;
+            }
+        }
+        return undefined;
+    }
+    setVisibility(visible) {
+        this.visible = visible;
+        this.notifyWatchers("visible", this.visible);
+        this.eventBus.emit("layer.visibility-changed", { layerId: this.id, visible }, this);
+    }
+    setOpacity(opacity) {
+        this.opacity = normalizeOpacity(opacity);
+        this.notifyWatchers("opacity", this.opacity);
+        this.eventBus.emit("layer.opacity-changed", { layerId: this.id, opacity: this.opacity }, this);
+    }
+    on(eventName, listener) {
+        const namespacedEvent = `group-layer.${eventName}`;
+        let listeners = this.eventListeners.get(eventName);
+        if (!listeners) {
+            listeners = new Set();
+            this.eventListeners.set(eventName, listeners);
+        }
+        listeners.add(listener);
+        const subscription = this.eventBus.on(namespacedEvent, (event) => {
+            safeInvokeCompatListener(listener, event.payload);
+        });
+        return {
+            remove: () => {
+                listeners?.delete(listener);
+                subscription.remove();
+            },
+        };
+    }
+    destroy() {
+        this.watchListeners.clear();
+        this.eventListeners.clear();
+        this.eventBus.emit("group-layer.destroyed", { layerId: this.id }, this);
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+}
+function isLayerWithId(value) {
+    return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string";
+}
+function extractNestedLayers(layer) {
+    if (!isLayerWithChildren(layer)) {
+        return [];
+    }
+    const nested = [];
+    for (const child of layer.layers) {
+        nested.push(child);
+        nested.push(...extractNestedLayers(child));
+    }
+    return nested;
+}
+function isLayerWithChildren(value) {
+    return typeof value === "object" && value !== null && "layers" in value && Array.isArray(value.layers);
+}
+function normalizeInsertIndex(index, length) {
+    const sanitized = Number.isFinite(index) ? Math.trunc(index) : length;
+    return Math.min(Math.max(sanitized, 0), length);
+}
+function normalizeOpacity(opacity) {
+    if (!Number.isFinite(opacity)) {
+        return 1;
+    }
+    return Math.min(Math.max(opacity, 0), 1);
+}

package/esri-compat/identify.d.ts

@@ -0,0 +1,71 @@
+import type { QueryMethod } from "../core/types.js";
+import { CompatEventBus } from "./event-bus.js";
+export interface IdentifyCompatOptions {
+    view?: unknown;
+    layers?: readonly unknown[];
+    eventBus?: CompatEventBus;
+    autoOpenPopup?: boolean;
+    includeHidden?: boolean;
+}
+export type IdentifyLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface IdentifyHandleCompat {
+    remove(): void;
+}
+export interface IdentifyCompatRequest {
+    geometry: string | Record<string, unknown>;
+    geometryType?: string;
+    sr?: string | number;
+    layers?: string;
+    tolerance?: number;
+    mapExtent?: string | [number, number, number, number];
+    imageDisplay?: string | [number, number, number];
+    returnGeometry?: boolean;
+    responseFormat?: "json" | "pjson";
+    maxAllowableOffset?: number;
+    layerDefs?: string;
+    dynamicLayers?: string;
+    time?: string;
+    method?: QueryMethod;
+    extraParams?: Record<string, string | number | boolean>;
+    layerSources?: readonly unknown[];
+    popupTitle?: string;
+    popupContent?: unknown;
+    popupLocation?: unknown;
+    openPopup?: boolean;
+}
+export interface IdentifyCompatLayerResult {
+    layer: unknown;
+    response: unknown;
+    features: unknown[];
+}
+export interface IdentifyCompatLayerError {
+    layer: unknown;
+    error: unknown;
+}
+export interface IdentifyCompatResult {
+    layers: IdentifyCompatLayerResult[];
+    errors: IdentifyCompatLayerError[];
+    features: unknown[];
+    totalResultCount: number;
+}
+export declare class IdentifyCompat {
+    readonly view: unknown;
+    readonly eventBus: CompatEventBus;
+    readonly autoOpenPopup: boolean;
+    readonly includeHidden: boolean;
+    loaded: boolean;
+    loadStatus: IdentifyLoadStatusCompat;
+    lastResult: IdentifyCompatResult | undefined;
+    private readonly explicitLayers;
+    private readonly watchListeners;
+    constructor(options?: IdentifyCompatOptions);
+    load(): Promise<IdentifyCompat>;
+    when(callback?: (identify: IdentifyCompat) => void): Promise<IdentifyCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): IdentifyHandleCompat;
+    identify(request: IdentifyCompatRequest): Promise<IdentifyCompatResult>;
+    identifyAt(point: string | Record<string, unknown>, request?: Omit<IdentifyCompatRequest, "geometry">): Promise<IdentifyCompatResult>;
+    private resolveCandidateLayers;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=identify.d.ts.map

package/esri-compat/identify.d.ts.map

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

package/esri-compat/identify.js

@@ -0,0 +1,299 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+export class IdentifyCompat {
+    view;
+    eventBus;
+    autoOpenPopup;
+    includeHidden;
+    loaded;
+    loadStatus;
+    lastResult;
+    explicitLayers;
+    watchListeners;
+    constructor(options = {}) {
+        this.view = options.view;
+        this.explicitLayers = options.layers;
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.view, options.layers) ?? new CompatEventBus();
+        this.autoOpenPopup = options.autoOpenPopup ?? true;
+        this.includeHidden = options.includeHidden ?? false;
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.lastResult = undefined;
+        this.watchListeners = new Map();
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("identify.loading", undefined, this);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("identify.loaded", undefined, this);
+        return this;
+    }
+    async when(callback) {
+        const identify = await this.load();
+        if (callback) {
+            callback(identify);
+        }
+        return identify;
+    }
+    watch(propertyName, listener) {
+        let listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            listeners = new Set();
+            this.watchListeners.set(propertyName, listeners);
+        }
+        listeners.add(listener);
+        return {
+            remove: () => {
+                listeners?.delete(listener);
+            },
+        };
+    }
+    async identify(request) {
+        await this.load();
+        const candidates = this.resolveCandidateLayers(request.layerSources);
+        const identifyLayers = candidates.filter((layer) => {
+            if (!isIdentifyProvider(layer)) {
+                return false;
+            }
+            if (this.includeHidden) {
+                return true;
+            }
+            return !isLayerExplicitlyHidden(layer);
+        });
+        this.eventBus.emit("identify.started", {
+            candidateCount: candidates.length,
+            identifyLayerCount: identifyLayers.length,
+        }, this);
+        const mapExtent = normalizeMapExtent(request.mapExtent, this.view);
+        const imageDisplay = normalizeImageDisplay(request.imageDisplay, this.view);
+        const layerResults = [];
+        const errors = [];
+        const features = [];
+        for (const layer of identifyLayers) {
+            try {
+                const response = await layer.identify({
+                    geometry: request.geometry,
+                    geometryType: request.geometryType,
+                    sr: request.sr,
+                    layers: request.layers,
+                    tolerance: request.tolerance,
+                    mapExtent,
+                    imageDisplay,
+                    returnGeometry: request.returnGeometry,
+                    responseFormat: request.responseFormat,
+                    maxAllowableOffset: request.maxAllowableOffset,
+                    layerDefs: request.layerDefs,
+                    dynamicLayers: request.dynamicLayers,
+                    time: request.time,
+                    method: request.method,
+                    extraParams: request.extraParams,
+                });
+                const layerFeatures = extractIdentifyFeatures(response);
+                layerResults.push({
+                    layer,
+                    response,
+                    features: layerFeatures,
+                });
+                features.push(...layerFeatures);
+                this.eventBus.emit("identify.layer-completed", {
+                    layerId: extractLayerId(layer),
+                    layerTitle: extractLayerTitle(layer),
+                    resultCount: layerFeatures.length,
+                }, this);
+            }
+            catch (error) {
+                errors.push({ layer, error });
+                this.eventBus.emit("identify.layer-error", {
+                    layerId: extractLayerId(layer),
+                    layerTitle: extractLayerTitle(layer),
+                }, this);
+            }
+        }
+        const result = {
+            layers: layerResults,
+            errors,
+            features,
+            totalResultCount: features.length,
+        };
+        this.lastResult = result;
+        this.notifyWatchers("lastResult", this.lastResult);
+        const shouldOpenPopup = request.openPopup ?? this.autoOpenPopup;
+        if (shouldOpenPopup && features.length > 0) {
+            const popupLocation = request.popupLocation ?? extractPopupLocation(request.geometry) ?? extractViewCenter(this.view);
+            openViewPopup(this.view, {
+                location: popupLocation,
+                features,
+                title: request.popupTitle ?? `Identify (${features.length})`,
+                content: request.popupContent,
+            });
+            this.eventBus.emit("identify.popup-opened", {
+                resultCount: features.length,
+            }, this);
+        }
+        this.eventBus.emit("identify.completed", {
+            resultCount: features.length,
+            layerCount: layerResults.length,
+            errorCount: errors.length,
+        }, this);
+        return result;
+    }
+    identifyAt(point, request = {}) {
+        return this.identify({
+            ...request,
+            geometry: point,
+        });
+    }
+    resolveCandidateLayers(layerSources) {
+        if (layerSources) {
+            return [...layerSources];
+        }
+        if (this.explicitLayers) {
+            return [...this.explicitLayers];
+        }
+        return resolveViewLayers(this.view);
+    }
+    destroy() {
+        this.watchListeners.clear();
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+}
+function resolveViewLayers(view) {
+    if (!isRecord(view) || !isRecord(view.map)) {
+        return [];
+    }
+    const map = view.map;
+    if (Array.isArray(map.allLayers)) {
+        return [...map.allLayers];
+    }
+    if (Array.isArray(map.layers)) {
+        return [...map.layers];
+    }
+    return [];
+}
+function openViewPopup(view, options) {
+    if (!isRecord(view)) {
+        return;
+    }
+    const popupTarget = view;
+    if (typeof popupTarget.openPopup === "function") {
+        popupTarget.openPopup(options);
+        return;
+    }
+    if (popupTarget.popup && typeof popupTarget.popup.open === "function") {
+        popupTarget.popup.open(options);
+    }
+}
+function extractPopupLocation(geometry) {
+    if (typeof geometry === "string") {
+        return undefined;
+    }
+    if ("x" in geometry && "y" in geometry) {
+        return geometry;
+    }
+    return undefined;
+}
+function extractViewCenter(view) {
+    if (!isRecord(view)) {
+        return undefined;
+    }
+    return view.center;
+}
+function normalizeMapExtent(mapExtent, view) {
+    if (mapExtent !== undefined) {
+        return mapExtent;
+    }
+    const viewExtent = extractExtentFromView(view);
+    return viewExtent ?? "0,0,0,0";
+}
+function normalizeImageDisplay(imageDisplay, view) {
+    if (imageDisplay !== undefined) {
+        return imageDisplay;
+    }
+    const width = extractOptionalNumber(view, "width");
+    const height = extractOptionalNumber(view, "height");
+    const dpi = extractOptionalNumber(view, "dpi") ?? 96;
+    if (width !== undefined && height !== undefined) {
+        return [width, height, dpi];
+    }
+    return "400,400,96";
+}
+function extractExtentFromView(view) {
+    if (!isRecord(view) || !isRecord(view.extent)) {
+        return undefined;
+    }
+    const xmin = toOptionalNumber(view.extent.xmin);
+    const ymin = toOptionalNumber(view.extent.ymin);
+    const xmax = toOptionalNumber(view.extent.xmax);
+    const ymax = toOptionalNumber(view.extent.ymax);
+    if (xmin === undefined || ymin === undefined || xmax === undefined || ymax === undefined) {
+        return undefined;
+    }
+    return [xmin, ymin, xmax, ymax];
+}
+function extractIdentifyFeatures(response) {
+    if (!isRecord(response)) {
+        return [];
+    }
+    if (!Array.isArray(response.results)) {
+        return [];
+    }
+    const features = [];
+    for (const result of response.results) {
+        if (!isRecord(result)) {
+            continue;
+        }
+        if ("feature" in result) {
+            features.push(result.feature);
+            continue;
+        }
+        features.push(result);
+    }
+    return features;
+}
+function isIdentifyProvider(value) {
+    return isRecord(value) && typeof value.identify === "function";
+}
+function isLayerExplicitlyHidden(value) {
+    return isRecord(value) && value.visible === false;
+}
+function extractLayerId(layer) {
+    if (!isRecord(layer)) {
+        return undefined;
+    }
+    return toOptionalString(layer.id);
+}
+function extractLayerTitle(layer) {
+    if (!isRecord(layer)) {
+        return undefined;
+    }
+    return toOptionalString(layer.title);
+}
+function extractOptionalNumber(value, key) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return toOptionalNumber(value[key]);
+}
+function toOptionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function toOptionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}