@honua/react 0.0.20-alpha.0

package/esri-compat/search.js

@@ -0,0 +1,820 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener, } from "./event-bus.js";
+const DEFAULT_SEARCH_SOURCE_MAX_FEATURE_CANDIDATES = 200;
+const DEFAULT_SEARCH_SOURCE_MAX_RESULTS = 10;
+const DEFAULT_SEARCH_SOURCE_MAX_SUGGESTIONS = 5;
+export class SearchCompat {
+    view;
+    container;
+    eventBus;
+    autoNavigate;
+    includeDefaultSources;
+    autoRefreshSources;
+    loaded;
+    loadStatus;
+    sources;
+    searchTerm;
+    results;
+    suggestions;
+    selectedResult;
+    selectedResultIndex;
+    defaultSourceMaxFeatureCandidates;
+    defaultSourceMaxResults;
+    defaultSourceMaxSuggestions;
+    searchAllEnabled;
+    popupEnabled;
+    maxResults;
+    allPlaceholder;
+    locationEnabled;
+    resultGraphicEnabled;
+    subscriptions;
+    watchListeners;
+    customSources;
+    constructor(options = {}) {
+        this.view = options.view;
+        this.container = options.container ?? null;
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.view) ?? new CompatEventBus();
+        this.autoNavigate = options.autoNavigate ?? true;
+        this.includeDefaultSources = options.includeDefaultSources ?? true;
+        this.autoRefreshSources = options.autoRefreshSources ?? true;
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.customSources = [...(options.sources ?? [])];
+        this.sources = [];
+        this.searchTerm = "";
+        this.results = [];
+        this.suggestions = [];
+        this.selectedResult = undefined;
+        this.selectedResultIndex = -1;
+        this.defaultSourceMaxFeatureCandidates = normalizeSearchLimit(options.defaultSourceMaxFeatureCandidates, DEFAULT_SEARCH_SOURCE_MAX_FEATURE_CANDIDATES);
+        this.defaultSourceMaxResults = normalizeSearchLimit(options.defaultSourceMaxResults, DEFAULT_SEARCH_SOURCE_MAX_RESULTS);
+        this.defaultSourceMaxSuggestions = normalizeSearchLimit(options.defaultSourceMaxSuggestions, DEFAULT_SEARCH_SOURCE_MAX_SUGGESTIONS);
+        this.searchAllEnabled = options.searchAllEnabled ?? true;
+        this.popupEnabled = options.popupEnabled ?? true;
+        this.maxResults = normalizeSearchLimit(options.maxResults, DEFAULT_SEARCH_SOURCE_MAX_RESULTS);
+        this.allPlaceholder = options.allPlaceholder ?? "";
+        this.locationEnabled = options.locationEnabled ?? true;
+        this.resultGraphicEnabled = options.resultGraphicEnabled ?? true;
+        this.subscriptions = [];
+        this.watchListeners = new Map();
+        this.refreshSourceSubscriptions();
+        this.rebuildSources(false);
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("search.loading", undefined, this);
+        this.rebuildSources(false);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("search.loaded", { sourceCount: this.sources.length }, this);
+        return this;
+    }
+    async when(callback) {
+        const widget = await this.load();
+        if (callback) {
+            callback(widget);
+        }
+        return widget;
+    }
+    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 search(termOrRequest) {
+        const searchTerm = typeof termOrRequest === "string"
+            ? termOrRequest
+            : typeof termOrRequest.searchTerm === "string"
+                ? termOrRequest.searchTerm
+                : "";
+        this.searchTerm = searchTerm;
+        this.notifyWatchers("searchTerm", this.searchTerm);
+        this.eventBus.emit("search.started", { searchTerm }, this);
+        const sourceResults = await Promise.all(this.sources.map(async (source) => {
+            try {
+                const results = await source.search({ searchTerm });
+                return { source, results };
+            }
+            catch (error) {
+                this.eventBus.emit("search.source-error", { searchTerm, error }, this);
+                return { source, results: [] };
+            }
+        }));
+        const allResults = [];
+        for (const sourceResult of sourceResults) {
+            for (const result of sourceResult.results) {
+                allResults.push({
+                    ...result,
+                    source: result.source ?? sourceResult.source,
+                });
+            }
+        }
+        this.results = allResults;
+        this.notifyWatchers("results", this.results);
+        this.selectedResult = this.results[0];
+        this.notifyWatchers("selectedResult", this.selectedResult);
+        this.selectedResultIndex = this.selectedResult ? 0 : -1;
+        this.notifyWatchers("selectedResultIndex", this.selectedResultIndex);
+        if (this.autoNavigate) {
+            await this.navigateToSelectedResult();
+        }
+        const response = {
+            searchTerm,
+            results: [...this.results],
+        };
+        this.eventBus.emit("search.completed", {
+            searchTerm,
+            resultCount: this.results.length,
+        }, this);
+        return response;
+    }
+    async suggest(termOrRequest) {
+        const searchTerm = typeof termOrRequest === "string"
+            ? termOrRequest
+            : typeof termOrRequest.searchTerm === "string"
+                ? termOrRequest.searchTerm
+                : "";
+        const suggestionSources = this.sources.filter((source) => typeof source.suggest === "function");
+        const sourceSuggestions = await Promise.all(suggestionSources.map(async (source) => {
+            if (!source.suggest) {
+                return { source, suggestions: [] };
+            }
+            try {
+                const suggestions = await source.suggest({ searchTerm });
+                return { source, suggestions };
+            }
+            catch (error) {
+                this.eventBus.emit("search.suggest-error", { searchTerm, error }, this);
+                return { source, suggestions: [] };
+            }
+        }));
+        const suggestions = [];
+        for (const sourceSuggestion of sourceSuggestions) {
+            for (const suggestion of sourceSuggestion.suggestions) {
+                suggestions.push({
+                    ...suggestion,
+                    source: suggestion.source ?? sourceSuggestion.source,
+                });
+            }
+        }
+        this.suggestions = suggestions;
+        this.notifyWatchers("suggestions", this.suggestions);
+        this.eventBus.emit("search.suggestions-updated", {
+            searchTerm,
+            suggestionCount: suggestions.length,
+        }, this);
+        return {
+            searchTerm,
+            suggestions: [...suggestions],
+        };
+    }
+    clear() {
+        this.searchTerm = "";
+        this.notifyWatchers("searchTerm", this.searchTerm);
+        this.results = [];
+        this.notifyWatchers("results", this.results);
+        this.suggestions = [];
+        this.notifyWatchers("suggestions", this.suggestions);
+        this.selectedResult = undefined;
+        this.notifyWatchers("selectedResult", this.selectedResult);
+        this.selectedResultIndex = -1;
+        this.notifyWatchers("selectedResultIndex", this.selectedResultIndex);
+        this.eventBus.emit("search.cleared", undefined, this);
+    }
+    setSources(sources, options = {}) {
+        const includeDefaults = options.includeDefaultSources ?? this.includeDefaultSources;
+        this.includeDefaultSources = includeDefaults;
+        this.notifyWatchers("includeDefaultSources", this.includeDefaultSources);
+        this.customSources = [...sources];
+        this.refreshSourceSubscriptions();
+        this.rebuildSources(true);
+    }
+    addSource(source) {
+        this.customSources.push(source);
+        this.rebuildSources(true);
+    }
+    removeSource(source) {
+        const index = this.customSources.indexOf(source);
+        if (index < 0) {
+            return false;
+        }
+        this.customSources.splice(index, 1);
+        this.rebuildSources(true);
+        return true;
+    }
+    async selectResult(resultOrIndex) {
+        if (this.results.length === 0) {
+            return undefined;
+        }
+        const index = typeof resultOrIndex === "number"
+            ? normalizeResultIndex(resultOrIndex, this.results.length)
+            : this.results.indexOf(resultOrIndex);
+        if (index < 0) {
+            return undefined;
+        }
+        this.selectedResultIndex = index;
+        this.notifyWatchers("selectedResultIndex", this.selectedResultIndex);
+        this.selectedResult = this.results[index];
+        this.notifyWatchers("selectedResult", this.selectedResult);
+        if (this.autoNavigate) {
+            await this.navigateToSelectedResult();
+        }
+        this.eventBus.emit("search.result-selected", {
+            selectedResultIndex: this.selectedResultIndex,
+            selectedResult: this.selectedResult,
+        }, this);
+        return this.selectedResult;
+    }
+    async nextResult() {
+        if (this.results.length === 0) {
+            return undefined;
+        }
+        const current = this.selectedResultIndex >= 0 ? this.selectedResultIndex : 0;
+        const next = Math.min(current + 1, this.results.length - 1);
+        return this.selectResult(next);
+    }
+    async previousResult() {
+        if (this.results.length === 0) {
+            return undefined;
+        }
+        const current = this.selectedResultIndex >= 0 ? this.selectedResultIndex : 0;
+        const previous = Math.max(current - 1, 0);
+        return this.selectResult(previous);
+    }
+    destroy() {
+        for (const subscription of this.subscriptions.splice(0)) {
+            subscription.remove();
+        }
+        this.watchListeners.clear();
+    }
+    async navigateToSelectedResult() {
+        if (!this.selectedResult) {
+            return;
+        }
+        if (!isGoToProvider(this.view)) {
+            return;
+        }
+        const target = this.selectedResult.extent ?? this.selectedResult.location ?? this.selectedResult.feature;
+        if (target === undefined) {
+            return;
+        }
+        await this.view.goTo(target);
+        this.eventBus.emit("search.navigated", { target }, this);
+    }
+    rebuildSources(emitChange) {
+        this.sources = [
+            ...this.customSources,
+            ...(this.includeDefaultSources
+                ? resolveViewSearchSources(this.view, {
+                    maxFeatureCandidates: this.defaultSourceMaxFeatureCandidates,
+                    maxResults: this.defaultSourceMaxResults,
+                    maxSuggestions: this.defaultSourceMaxSuggestions,
+                })
+                : []),
+        ];
+        this.notifyWatchers("sources", this.sources);
+        if (emitChange) {
+            this.eventBus.emit("search.sources-changed", { sourceCount: this.sources.length }, this);
+        }
+    }
+    refreshSourceSubscriptions() {
+        for (const subscription of this.subscriptions.splice(0)) {
+            subscription.remove();
+        }
+        if (!this.includeDefaultSources || !this.autoRefreshSources) {
+            return;
+        }
+        const refreshEvents = [
+            "map.layer-added",
+            "map.layer-removed",
+            "map.layers-added",
+            "map.layers-cleared",
+            "map.layer-reordered",
+            "group-layer.layer-added",
+            "group-layer.layer-removed",
+            "group-layer.layers-added",
+            "group-layer.layers-cleared",
+        ];
+        for (const eventType of refreshEvents) {
+            this.subscriptions.push(this.eventBus.on(eventType, () => {
+                this.rebuildSources(true);
+            }));
+        }
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+}
+function isGoToProvider(value) {
+    return isRecord(value) && typeof value.goTo === "function";
+}
+function resolveViewSearchSources(view, limits) {
+    const map = extractMapFromView(view);
+    const layers = extractLayersFromMap(map);
+    const sources = [];
+    for (const layer of layers) {
+        if (isQueryFeaturesProvider(layer)) {
+            let fieldSearchConfig = resolveLayerSearchFieldConfig(layer);
+            let fieldSearchUnsupported = false;
+            const source = buildLayerSearchSource(layer, limits, async (normalizedTerm) => {
+                if (!fieldSearchUnsupported && fieldSearchConfig.searchableFields.length === 0) {
+                    fieldSearchConfig = resolveLayerSearchFieldConfig(layer);
+                }
+                const fallbackQueryOptions = createFallbackLayerSearchQueryOptions(limits.maxFeatureCandidates, normalizedTerm, fieldSearchConfig.outFields);
+                const optimizedQueryOptions = !fieldSearchUnsupported && fieldSearchConfig.searchableFields.length > 0
+                    ? createOptimizedLayerSearchQueryOptions(fieldSearchConfig, normalizedTerm, limits.maxFeatureCandidates)
+                    : undefined;
+                let response;
+                if (optimizedQueryOptions) {
+                    try {
+                        response = await layer.queryFeatures(optimizedQueryOptions);
+                    }
+                    catch {
+                        fieldSearchUnsupported = true;
+                        response = await layer.queryFeatures(fallbackQueryOptions);
+                    }
+                }
+                else {
+                    response = await layer.queryFeatures(fallbackQueryOptions);
+                }
+                return extractFeatures(response);
+            });
+            sources.push(source);
+            continue;
+        }
+        if (!isOgcItemsProvider(layer)) {
+            continue;
+        }
+        const source = buildLayerSearchSource(layer, limits, async () => {
+            const response = await layer.items({
+                limit: limits.maxFeatureCandidates,
+            });
+            return extractFeatures(response);
+        });
+        sources.push(source);
+    }
+    return sources;
+}
+function buildLayerSearchSource(layer, limits, resolveFeatures) {
+    let lastSearchTerm;
+    let lastSearchResults = [];
+    let lastSearchPromise;
+    const executeSearch = async (searchTerm) => {
+        const normalizedTerm = searchTerm.trim().toLowerCase();
+        if (!normalizedTerm) {
+            lastSearchTerm = undefined;
+            lastSearchResults = [];
+            lastSearchPromise = undefined;
+            return [];
+        }
+        if (lastSearchTerm === normalizedTerm && lastSearchPromise) {
+            return lastSearchPromise;
+        }
+        if (lastSearchTerm === normalizedTerm && lastSearchResults.length > 0) {
+            return [...lastSearchResults];
+        }
+        const inFlight = (async () => {
+            const features = await resolveFeatures(normalizedTerm);
+            const matches = [];
+            for (const feature of features) {
+                if (!featureMatchesTerm(feature, normalizedTerm)) {
+                    continue;
+                }
+                const name = describeFeature(feature, layer, matches.length);
+                matches.push({
+                    name,
+                    feature: isRecord(feature) ? feature : null,
+                    location: extractFeatureLocation(feature),
+                    source: layer,
+                });
+                if (matches.length >= limits.maxResults) {
+                    break;
+                }
+            }
+            lastSearchTerm = normalizedTerm;
+            lastSearchResults = matches;
+            return [...matches];
+        })();
+        lastSearchTerm = normalizedTerm;
+        lastSearchPromise = inFlight;
+        try {
+            return await inFlight;
+        }
+        finally {
+            if (lastSearchPromise === inFlight) {
+                lastSearchPromise = undefined;
+            }
+        }
+    };
+    return {
+        search: async ({ searchTerm }) => executeSearch(searchTerm),
+        suggest: async ({ searchTerm }) => {
+            const response = await executeSearch(searchTerm);
+            return response.slice(0, limits.maxSuggestions).map((result) => ({
+                text: result.name,
+                source: layer,
+            }));
+        },
+    };
+}
+const COMMON_SEARCH_FIELD_NAMES = [
+    "name",
+    "title",
+    "label",
+    "description",
+    "city",
+    "state",
+    "county",
+    "address",
+];
+const MAX_SERVER_SEARCH_FIELDS = 6;
+const MAX_SERVER_OUT_FIELDS = 16;
+function createFallbackLayerSearchQueryOptions(maxFeatureCandidates, normalizedTerm, outFields) {
+    return {
+        where: "1=1",
+        outFields: normalizeFallbackOutFields(outFields),
+        returnGeometry: true,
+        extraParams: {
+            text: normalizedTerm,
+            resultOffset: 0,
+            resultRecordCount: maxFeatureCandidates,
+        },
+    };
+}
+function createOptimizedLayerSearchQueryOptions(config, normalizedTerm, maxFeatureCandidates) {
+    return {
+        where: createSearchWhereClause(config.searchableFields, normalizedTerm),
+        outFields: config.outFields,
+        returnGeometry: true,
+        extraParams: {
+            resultOffset: 0,
+            resultRecordCount: maxFeatureCandidates,
+        },
+    };
+}
+function createSearchWhereClause(searchableFields, normalizedTerm) {
+    const escapedTerm = escapeSqlLiteral(normalizedTerm.toUpperCase());
+    return searchableFields.map((field) => `UPPER(${field}) LIKE '%${escapedTerm}%' ESCAPE '\\\\'`).join(" OR ");
+}
+function resolveLayerSearchFieldConfig(layer) {
+    const fieldDefinitions = resolveLayerFieldDefinitions(layer);
+    const searchableFields = resolveSearchableFieldNames(layer, fieldDefinitions);
+    const outFields = resolveSearchOutFields(layer, searchableFields, fieldDefinitions);
+    return {
+        searchableFields,
+        outFields,
+    };
+}
+function resolveLayerFieldDefinitions(layer) {
+    const fromListFields = resolveLayerFieldsFromListFields(layer);
+    if (fromListFields.length > 0) {
+        return fromListFields;
+    }
+    return resolveLayerFieldsFromProperty(layer);
+}
+function resolveLayerFieldsFromListFields(layer) {
+    if (typeof layer.listFields !== "function") {
+        return [];
+    }
+    let fields;
+    try {
+        fields = layer.listFields();
+    }
+    catch {
+        return [];
+    }
+    return normalizeLayerFieldDefinitions(fields);
+}
+function resolveLayerFieldsFromProperty(layer) {
+    if (!Array.isArray(layer.fields)) {
+        return [];
+    }
+    return normalizeLayerFieldDefinitions(layer.fields);
+}
+function normalizeLayerFieldDefinitions(values) {
+    const definitions = [];
+    const seen = new Set();
+    for (const value of values) {
+        if (!isRecord(value) || typeof value.name !== "string") {
+            continue;
+        }
+        const normalizedName = normalizeFieldIdentifier(value.name);
+        if (!normalizedName) {
+            continue;
+        }
+        const normalizedKey = normalizedName.toLowerCase();
+        if (seen.has(normalizedKey)) {
+            continue;
+        }
+        seen.add(normalizedKey);
+        definitions.push({
+            name: normalizedName,
+            type: typeof value.type === "string" ? value.type : undefined,
+        });
+    }
+    return definitions;
+}
+function resolveSearchableFieldNames(layer, fieldDefinitions) {
+    const stringFields = fieldDefinitions.filter((field) => isStringFieldType(field.type)).map((field) => field.name);
+    const searchable = new Set();
+    const addIfAvailable = (fieldName) => {
+        if (!fieldName) {
+            return;
+        }
+        const available = fieldDefinitions.find((definition) => definition.name.toLowerCase() === fieldName.toLowerCase());
+        if (!available) {
+            return;
+        }
+        searchable.add(available.name);
+    };
+    addIfAvailable(resolveLayerDisplayField(layer));
+    for (const commonName of COMMON_SEARCH_FIELD_NAMES) {
+        addIfAvailable(commonName);
+    }
+    for (const fieldName of stringFields) {
+        searchable.add(fieldName);
+        if (searchable.size >= MAX_SERVER_SEARCH_FIELDS) {
+            break;
+        }
+    }
+    if (searchable.size > 0) {
+        return Array.from(searchable).slice(0, MAX_SERVER_SEARCH_FIELDS);
+    }
+    for (const outField of resolveLayerOutFields(layer)) {
+        const normalizedOutField = normalizeFieldIdentifier(outField);
+        if (!normalizedOutField || normalizedOutField === "*") {
+            continue;
+        }
+        searchable.add(normalizedOutField);
+        if (searchable.size >= MAX_SERVER_SEARCH_FIELDS) {
+            break;
+        }
+    }
+    return Array.from(searchable);
+}
+function resolveSearchOutFields(layer, searchableFields, fieldDefinitions) {
+    const outFields = new Set();
+    for (const field of searchableFields) {
+        outFields.add(field);
+    }
+    const addIfAvailable = (fieldName) => {
+        if (!fieldName) {
+            return;
+        }
+        const available = fieldDefinitions.find((definition) => definition.name.toLowerCase() === fieldName.toLowerCase());
+        if (!available) {
+            return;
+        }
+        outFields.add(available.name);
+    };
+    addIfAvailable(resolveLayerDisplayField(layer));
+    addIfAvailable(resolveLayerObjectIdField(layer));
+    for (const commonName of COMMON_SEARCH_FIELD_NAMES) {
+        addIfAvailable(commonName);
+    }
+    const requestedOutFields = resolveLayerOutFields(layer);
+    if (requestedOutFields.includes("*")) {
+        return ["*"];
+    }
+    for (const field of requestedOutFields) {
+        const normalizedField = normalizeFieldIdentifier(field);
+        if (!normalizedField || normalizedField === "*") {
+            continue;
+        }
+        outFields.add(normalizedField);
+        if (outFields.size >= MAX_SERVER_OUT_FIELDS) {
+            break;
+        }
+    }
+    const resolved = Array.from(outFields).slice(0, MAX_SERVER_OUT_FIELDS);
+    return resolved.length > 0 ? resolved : ["*"];
+}
+function resolveLayerOutFields(layer) {
+    if (typeof layer.outFields === "string") {
+        return [layer.outFields];
+    }
+    if (Array.isArray(layer.outFields)) {
+        return layer.outFields.filter((value) => typeof value === "string");
+    }
+    return [];
+}
+function normalizeFallbackOutFields(outFields) {
+    if (outFields.includes("*")) {
+        return ["*"];
+    }
+    const normalized = new Set();
+    for (const outField of outFields) {
+        const fieldName = normalizeFieldIdentifier(outField);
+        if (!fieldName || fieldName === "*") {
+            continue;
+        }
+        normalized.add(fieldName);
+        if (normalized.size >= MAX_SERVER_OUT_FIELDS) {
+            break;
+        }
+    }
+    if (normalized.size > 0) {
+        return Array.from(normalized);
+    }
+    return ["*"];
+}
+function resolveLayerDisplayField(layer) {
+    const fromLayer = normalizeFieldIdentifier(typeof layer.displayField === "string" ? layer.displayField : undefined);
+    if (fromLayer) {
+        return fromLayer;
+    }
+    if (!isRecord(layer.metadata)) {
+        return undefined;
+    }
+    return normalizeFieldIdentifier(typeof layer.metadata.displayField === "string" ? layer.metadata.displayField : undefined);
+}
+function resolveLayerObjectIdField(layer) {
+    const fromLayer = normalizeFieldIdentifier(typeof layer.objectIdField === "string" ? layer.objectIdField : undefined);
+    if (fromLayer) {
+        return fromLayer;
+    }
+    if (!isRecord(layer.metadata)) {
+        return undefined;
+    }
+    if (typeof layer.metadata.objectIdField === "string") {
+        return normalizeFieldIdentifier(layer.metadata.objectIdField);
+    }
+    return undefined;
+}
+function normalizeFieldIdentifier(fieldName) {
+    if (typeof fieldName !== "string") {
+        return undefined;
+    }
+    const trimmed = fieldName.trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    if (trimmed === "*") {
+        return "*";
+    }
+    if (!/^[A-Za-z_][A-Za-z0-9_$.]*$/.test(trimmed)) {
+        return undefined;
+    }
+    return trimmed;
+}
+function isStringFieldType(type) {
+    if (!type) {
+        return true;
+    }
+    const normalized = type.trim().toLowerCase();
+    if (normalized.length === 0) {
+        return true;
+    }
+    return normalized.includes("string") || normalized.includes("text");
+}
+function escapeSqlLiteral(value) {
+    return value.replace(/\\/g, "\\\\").replace(/'/g, "''").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+function extractMapFromView(view) {
+    if (!isRecord(view)) {
+        return undefined;
+    }
+    return view.map;
+}
+function extractLayersFromMap(map) {
+    if (!isRecord(map)) {
+        return [];
+    }
+    if (Array.isArray(map.allLayers)) {
+        return [...map.allLayers];
+    }
+    if (Array.isArray(map.layers)) {
+        return [...map.layers];
+    }
+    return [];
+}
+function normalizeResultIndex(index, length) {
+    if (!Number.isFinite(index)) {
+        return -1;
+    }
+    const normalized = Math.trunc(index);
+    if (normalized < 0 || normalized >= length) {
+        return -1;
+    }
+    return normalized;
+}
+function isQueryFeaturesProvider(value) {
+    return isRecord(value) && typeof value.queryFeatures === "function";
+}
+function isOgcItemsProvider(value) {
+    return isRecord(value) && typeof value.items === "function";
+}
+function normalizeSearchLimit(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.max(1, Math.trunc(value));
+}
+function extractFeatures(response) {
+    if (!isRecord(response) || !Array.isArray(response.features)) {
+        return [];
+    }
+    return response.features;
+}
+function featureMatchesTerm(feature, normalizedTerm) {
+    const properties = resolveFeatureProperties(feature);
+    if (!properties) {
+        return false;
+    }
+    for (const value of Object.values(properties)) {
+        if (value === null || value === undefined) {
+            continue;
+        }
+        const text = String(value).toLowerCase();
+        if (text.includes(normalizedTerm)) {
+            return true;
+        }
+    }
+    return false;
+}
+function describeFeature(feature, layer, index) {
+    const properties = resolveFeatureProperties(feature);
+    if (properties) {
+        for (const key of ["name", "Name", "NAME", "title", "Title", "TITLE"]) {
+            const value = properties[key];
+            if (typeof value === "string" && value.trim().length > 0) {
+                return value;
+            }
+        }
+    }
+    const layerTitle = typeof layer.title === "string" ? layer.title : typeof layer.id === "string" ? layer.id : "Result";
+    return `${layerTitle} ${index + 1}`;
+}
+function extractFeatureLocation(feature) {
+    if (!isRecord(feature) || !isRecord(feature.geometry)) {
+        return null;
+    }
+    const x = feature.geometry.x;
+    const y = feature.geometry.y;
+    if (typeof x === "number" && Number.isFinite(x) && typeof y === "number" && Number.isFinite(y)) {
+        return { x, y };
+    }
+    const point = extractPointFromGeoJsonGeometry(feature.geometry);
+    if (point) {
+        return point;
+    }
+    return feature.geometry;
+}
+function resolveFeatureProperties(feature) {
+    if (!isRecord(feature)) {
+        return undefined;
+    }
+    if (isRecord(feature.attributes)) {
+        return feature.attributes;
+    }
+    if (isRecord(feature.properties)) {
+        return feature.properties;
+    }
+    return undefined;
+}
+function extractPointFromGeoJsonGeometry(geometry) {
+    const coordinates = extractPointCoordinates(geometry.coordinates);
+    if (!coordinates) {
+        return undefined;
+    }
+    return {
+        x: coordinates[0],
+        y: coordinates[1],
+    };
+}
+function extractPointCoordinates(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        return undefined;
+    }
+    const first = value[0];
+    const second = value[1];
+    if (typeof first === "number" && Number.isFinite(first) && typeof second === "number" && Number.isFinite(second)) {
+        return [first, second];
+    }
+    if (Array.isArray(first)) {
+        return extractPointCoordinates(first);
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}