@honua/react 0.0.20-alpha.0

package/esri-compat/map-image-layer.js

@@ -0,0 +1,709 @@
+import { HonuaClient } from "../core/client.js";
+import { responseExceededTransferLimit } from "../core/wire-shared.js";
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+import { parseMapServiceUrl } from "./url.js";
+export class MapImageLayerCompat {
+    url;
+    id;
+    title;
+    serviceId;
+    opacity;
+    visible;
+    minScale;
+    maxScale;
+    listMode;
+    legendEnabled;
+    loaded;
+    loadStatus;
+    metadata;
+    eventBus;
+    client;
+    watchListeners;
+    eventListeners;
+    sublayerWrappersById;
+    sublayerSources;
+    constructor(options) {
+        const parsed = parseMapServiceUrl(options.url);
+        this.url = options.url;
+        this.serviceId = parsed.serviceId;
+        this.id = options.id ?? this.serviceId;
+        this.title = options.title;
+        this.sublayerSources = Array.isArray(options.sublayers)
+            ? [...options.sublayers]
+            : [];
+        this.opacity = options.opacity ?? 1;
+        this.visible = options.visible ?? true;
+        this.minScale = normalizeScale(options.minScale);
+        this.maxScale = normalizeScale(options.maxScale);
+        this.listMode = options.listMode ?? "show";
+        this.legendEnabled = options.legendEnabled ?? true;
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.metadata = undefined;
+        this.eventBus =
+            options.eventBus ?? resolveCompatEventBus(options.client, options.sublayers) ?? new CompatEventBus();
+        this.client = options.client ?? new HonuaClient({ baseUrl: parsed.baseUrl });
+        this.watchListeners = new Map();
+        this.eventListeners = new Map();
+        this.sublayerWrappersById = new Map();
+    }
+    async load() {
+        if (!this.loaded) {
+            this.loadStatus = "loading";
+            this.notifyWatchers("loadStatus", this.loadStatus);
+            this.eventBus.emit("map-image-layer.loading", { serviceId: this.serviceId, id: this.id }, this);
+            try {
+                this.metadata = (await this.client.getMapServiceMetadata(this.serviceId));
+                this.notifyWatchers("metadata", this.metadata);
+                this.hydrateSublayersFromMetadataIfNeeded();
+                this.loaded = true;
+                this.notifyWatchers("loaded", this.loaded);
+                this.loadStatus = "loaded";
+                this.notifyWatchers("loadStatus", this.loadStatus);
+                this.eventBus.emit("map-image-layer.loaded", { serviceId: this.serviceId, id: this.id }, this);
+            }
+            catch (error) {
+                this.metadata = undefined;
+                this.notifyWatchers("metadata", this.metadata);
+                this.loaded = false;
+                this.notifyWatchers("loaded", this.loaded);
+                this.loadStatus = "failed";
+                this.notifyWatchers("loadStatus", this.loadStatus);
+                this.eventBus.emit("map-image-layer.failed", { serviceId: this.serviceId, id: this.id, error }, this);
+                throw error;
+            }
+        }
+        return this;
+    }
+    async when(callback) {
+        const layer = await this.load();
+        if (callback) {
+            callback(layer);
+        }
+        return layer;
+    }
+    refresh() {
+        this.loaded = false;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "not-loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.metadata = undefined;
+        this.notifyWatchers("metadata", this.metadata);
+        this.eventBus.emit("map-image-layer.refreshed", { serviceId: this.serviceId, id: this.id }, this);
+    }
+    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 sublayers() {
+        void this.synchronizeSublayerWrapperCache();
+        const wrappers = [];
+        const seenIds = new Set();
+        for (const source of this.sublayerSources) {
+            const sourceId = extractSublayerId(source);
+            if (sourceId === undefined || seenIds.has(sourceId)) {
+                continue;
+            }
+            seenIds.add(sourceId);
+            wrappers.push(this.getOrCreateSublayerWrapper(sourceId, source));
+        }
+        return wrappers;
+    }
+    set sublayers(sublayers) {
+        this.setSublayers(sublayers);
+    }
+    get allSublayers() {
+        return this.synchronizeSublayerWrapperCache();
+    }
+    exportImage(options) {
+        return this.client.exportMap({
+            ...options,
+            serviceId: this.serviceId,
+        });
+    }
+    getLegend(options = {}) {
+        return this.client.getMapLegend({
+            ...options,
+            serviceId: this.serviceId,
+        });
+    }
+    legend(options = {}) {
+        return this.getLegend(options);
+    }
+    identify(options) {
+        return this.client.identifyMap({
+            ...options,
+            serviceId: this.serviceId,
+        });
+    }
+    find(options) {
+        return this.client.findMap({
+            ...options,
+            serviceId: this.serviceId,
+        });
+    }
+    createQuery(layerId) {
+        return {
+            layerId,
+            where: "1=1",
+            outFields: ["*"],
+            returnGeometry: true,
+        };
+    }
+    queryFeatures(options) {
+        return this.client.queryMapLayer({
+            ...options,
+            serviceId: this.serviceId,
+        });
+    }
+    async queryFeaturesAll(options) {
+        const pageSize = typeof options.pageSize === "number" && Number.isFinite(options.pageSize)
+            ? Math.max(1, Math.trunc(options.pageSize))
+            : 2000;
+        const maxPages = typeof options.maxPages === "number" && Number.isFinite(options.maxPages)
+            ? Math.max(1, Math.trunc(options.maxPages))
+            : 100;
+        const features = [];
+        let offset = 0;
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryFeatures({
+                ...options,
+                extraParams: {
+                    ...(options.extraParams ?? {}),
+                    resultOffset: offset,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = extractFeatures(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            features.push(...pageFeatures);
+            offset += pageFeatures.length;
+            if (!responseExceededTransferLimit(response) && pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+        return features;
+    }
+    async *queryFeaturesStream(options) {
+        const pageSize = typeof options.pageSize === "number" && Number.isFinite(options.pageSize)
+            ? Math.max(1, Math.trunc(options.pageSize))
+            : 2000;
+        const maxPages = typeof options.maxPages === "number" && Number.isFinite(options.maxPages)
+            ? Math.max(1, Math.trunc(options.maxPages))
+            : 100;
+        let offset = 0;
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryFeatures({
+                ...options,
+                extraParams: {
+                    ...(options.extraParams ?? {}),
+                    resultOffset: offset,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = extractFeatures(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            yield pageFeatures;
+            offset += pageFeatures.length;
+            if (!responseExceededTransferLimit(response) && pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+    }
+    async queryFeatureCount(options) {
+        const response = (await this.queryFeatures({
+            layerId: options.layerId,
+            where: options.where ?? "1=1",
+            returnGeometry: false,
+            outFields: "OBJECTID",
+            method: options.method,
+            extraParams: {
+                returnCountOnly: true,
+                ...options.extraParams,
+            },
+        }));
+        return extractFeatureCount(response);
+    }
+    async queryObjectIds(options) {
+        const response = (await this.queryFeatures({
+            layerId: options.layerId,
+            where: options.where ?? "1=1",
+            returnGeometry: false,
+            outFields: "OBJECTID",
+            method: options.method,
+            extraParams: {
+                returnIdsOnly: true,
+                ...options.extraParams,
+            },
+        }));
+        return extractObjectIds(response);
+    }
+    async queryExtent(options) {
+        const response = (await this.queryFeatures({
+            layerId: options.layerId,
+            where: options.where ?? "1=1",
+            returnGeometry: false,
+            method: options.method,
+            extraParams: {
+                returnExtentOnly: true,
+                ...options.extraParams,
+            },
+        }));
+        return extractExtent(response);
+    }
+    queryRelatedRecords(options) {
+        return this.client.queryMapRelatedRecords({
+            ...options,
+            serviceId: this.serviceId,
+        });
+    }
+    queryRelatedFeatures(options) {
+        return this.queryRelatedRecords(options);
+    }
+    async applyEdits(options) {
+        const result = await this.client.applyEdits({
+            serviceId: this.serviceId,
+            layerId: options.layerId,
+            adds: options.adds,
+            updates: options.updates,
+            deletes: options.deletes,
+            rollbackOnFailure: options.rollbackOnFailure,
+        });
+        this.eventBus.emit("map-image-layer.edits", { result, layerId: this.id, sublayerId: options.layerId }, this);
+        return result;
+    }
+    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);
+    }
+    setSublayers(sublayers) {
+        this.sublayerSources = sublayers.map((candidate) => candidate instanceof MapImageSublayerCompat ? candidate.source : candidate);
+        const wrappers = this.sublayers;
+        this.notifyWatchers("sublayers", wrappers);
+        this.eventBus.emit("map-image-layer.sublayers-changed", { layerId: this.id }, this);
+    }
+    findSublayerById(id) {
+        const expectedId = normalizeSublayerId(id);
+        if (expectedId === undefined) {
+            return undefined;
+        }
+        const source = findSublayerSourceById(this.sublayerSources, expectedId);
+        if (source === undefined) {
+            return undefined;
+        }
+        return this.getOrCreateSublayerWrapper(expectedId, source);
+    }
+    sublayer(id) {
+        return this.findSublayerById(id);
+    }
+    setScaleRange(minScale, maxScale) {
+        this.minScale = normalizeScale(minScale);
+        this.maxScale = normalizeScale(maxScale);
+        this.notifyWatchers("minScale", this.minScale);
+        this.notifyWatchers("maxScale", this.maxScale);
+        this.eventBus.emit("map-image-layer.scale-range-changed", { layerId: this.id, minScale: this.minScale, maxScale: this.maxScale }, this);
+    }
+    setListMode(listMode) {
+        this.listMode = listMode;
+        this.notifyWatchers("listMode", this.listMode);
+        this.eventBus.emit("map-image-layer.list-mode-changed", { layerId: this.id, listMode }, this);
+    }
+    on(eventName, listener) {
+        const namespacedEvent = `map-image-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("map-image-layer.destroyed", { id: this.id }, this);
+    }
+    setLegendEnabled(legendEnabled) {
+        this.legendEnabled = legendEnabled;
+        this.notifyWatchers("legendEnabled", this.legendEnabled);
+        this.eventBus.emit("map-image-layer.legend-enabled-changed", { layerId: this.id, legendEnabled }, this);
+    }
+    listFields() {
+        return extractFieldDefinitions(this.metadata);
+    }
+    getField(fieldName) {
+        const normalizedFieldName = fieldName.trim();
+        if (normalizedFieldName.length === 0) {
+            return undefined;
+        }
+        return this.listFields().find((field) => {
+            return field.name.trim() === normalizedFieldName;
+        });
+    }
+    hydrateSublayersFromMetadataIfNeeded() {
+        if (this.sublayerSources.length > 0) {
+            return;
+        }
+        const metadataSublayers = extractSublayersFromMetadata(this.metadata);
+        if (metadataSublayers.length === 0) {
+            return;
+        }
+        this.sublayerSources = metadataSublayers;
+        const wrappers = this.sublayers;
+        this.notifyWatchers("sublayers", wrappers);
+        this.eventBus.emit("map-image-layer.sublayers-changed", { layerId: this.id, source: "metadata" }, this);
+    }
+    getOrCreateSublayerWrapper(layerId, source) {
+        const existing = this.sublayerWrappersById.get(layerId);
+        if (existing) {
+            existing.setSource(source);
+            return existing;
+        }
+        const created = new MapImageSublayerCompat({
+            layer: this,
+            layerId,
+            source,
+        });
+        this.sublayerWrappersById.set(layerId, created);
+        return created;
+    }
+    synchronizeSublayerWrapperCache() {
+        const currentSublayerIds = new Set();
+        const wrappers = [];
+        collectSublayerWrappers(this.sublayerSources, this, wrappers, currentSublayerIds);
+        for (const cachedLayerId of this.sublayerWrappersById.keys()) {
+            if (!currentSublayerIds.has(cachedLayerId)) {
+                this.sublayerWrappersById.delete(cachedLayerId);
+            }
+        }
+        return wrappers;
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+}
+export class MapImageSublayerCompat {
+    layer;
+    layerId;
+    source;
+    constructor(options) {
+        this.layer = options.layer;
+        this.layerId = options.layerId;
+        this.source = options.source ?? { id: options.layerId };
+    }
+    setSource(source) {
+        this.source = source;
+    }
+    get id() {
+        return this.layerId;
+    }
+    get visible() {
+        if (typeof this.source.visible !== "boolean") {
+            return true;
+        }
+        return this.source.visible;
+    }
+    set visible(visible) {
+        this.source.visible = visible;
+    }
+    get title() {
+        if (typeof this.source.title !== "string") {
+            return undefined;
+        }
+        return this.source.title;
+    }
+    get definitionExpression() {
+        if (typeof this.source.definitionExpression !== "string") {
+            return undefined;
+        }
+        return this.source.definitionExpression;
+    }
+    set definitionExpression(definitionExpression) {
+        if (definitionExpression === undefined ||
+            (typeof definitionExpression === "string" && definitionExpression.trim().length === 0)) {
+            delete this.source.definitionExpression;
+            return;
+        }
+        this.source.definitionExpression = definitionExpression;
+    }
+    setVisibility(visible) {
+        this.visible = visible;
+        this.layer.eventBus.emit("layer.visibility-changed", { layerId: this.layerId, visible: this.visible }, this);
+    }
+    createQuery() {
+        const query = this.layer.createQuery(this.layerId);
+        return {
+            where: query.where,
+            outFields: query.outFields,
+            returnGeometry: query.returnGeometry,
+            method: query.method,
+            extraParams: query.extraParams,
+        };
+    }
+    queryFeatures(options = {}) {
+        return this.layer.queryFeatures({
+            layerId: this.layerId,
+            where: options.where ?? this.definitionExpression ?? "1=1",
+            ...options,
+        });
+    }
+    queryFeaturesAll(options = {}) {
+        return this.layer.queryFeaturesAll({
+            layerId: this.layerId,
+            where: options.where ?? this.definitionExpression ?? "1=1",
+            ...options,
+        });
+    }
+    queryFeatureCount(options = {}) {
+        return this.layer.queryFeatureCount({
+            layerId: this.layerId,
+            where: options.where ?? this.definitionExpression,
+            ...options,
+        });
+    }
+    queryObjectIds(options = {}) {
+        return this.layer.queryObjectIds({
+            layerId: this.layerId,
+            where: options.where ?? this.definitionExpression,
+            ...options,
+        });
+    }
+    queryExtent(options = {}) {
+        return this.layer.queryExtent({
+            layerId: this.layerId,
+            where: options.where ?? this.definitionExpression,
+            ...options,
+        });
+    }
+    queryRelatedRecords(options) {
+        return this.layer.queryRelatedRecords({
+            layerId: this.layerId,
+            where: options.where ?? this.definitionExpression,
+            ...options,
+        });
+    }
+    queryRelatedFeatures(options) {
+        return this.queryRelatedRecords(options);
+    }
+    applyEdits(options = {}) {
+        return this.layer.applyEdits({
+            layerId: this.layerId,
+            ...options,
+        });
+    }
+    get sublayers() {
+        const childSources = getChildSublayers(this.source);
+        const wrappers = [];
+        for (const childSource of childSources) {
+            const childId = extractSublayerId(childSource);
+            if (childId === undefined) {
+                continue;
+            }
+            wrappers.push(this.layer.getOrCreateSublayerWrapper(childId, childSource));
+        }
+        return wrappers;
+    }
+    get allSublayers() {
+        const wrappers = [];
+        const trackedIds = new Set();
+        collectSublayerWrappers(getChildSublayers(this.source), this.layer, wrappers, trackedIds);
+        return wrappers;
+    }
+    findSublayerById(id) {
+        const expectedId = normalizeSublayerId(id);
+        if (expectedId === undefined) {
+            return undefined;
+        }
+        const source = findSublayerSourceById(getChildSublayers(this.source), expectedId);
+        if (source === undefined) {
+            return undefined;
+        }
+        return this.layer.getOrCreateSublayerWrapper(expectedId, source);
+    }
+    sublayer(id) {
+        return this.findSublayerById(id);
+    }
+}
+function normalizeScale(scale) {
+    if (scale === undefined || !Number.isFinite(scale)) {
+        return 0;
+    }
+    return Math.max(0, Math.trunc(scale));
+}
+function normalizeOpacity(opacity) {
+    if (!Number.isFinite(opacity)) {
+        return 1;
+    }
+    return Math.min(Math.max(opacity, 0), 1);
+}
+function normalizeSublayerId(id) {
+    const parsed = Number(id);
+    if (!Number.isFinite(parsed)) {
+        return undefined;
+    }
+    return Math.trunc(parsed);
+}
+function extractSublayerId(sublayer) {
+    const id = sublayer.id;
+    if (id === undefined) {
+        return undefined;
+    }
+    return normalizeSublayerId(id);
+}
+function getChildSublayers(source) {
+    if (Array.isArray(source.sublayers)) {
+        return [...source.sublayers];
+    }
+    if (Array.isArray(source.allSublayers)) {
+        return [...source.allSublayers];
+    }
+    return [];
+}
+function collectSublayerWrappers(sources, layer, wrappers, trackedIds) {
+    for (const source of sources) {
+        const sourceId = extractSublayerId(source);
+        if (sourceId === undefined || trackedIds.has(sourceId)) {
+            continue;
+        }
+        trackedIds.add(sourceId);
+        wrappers.push(layer.getOrCreateSublayerWrapper(sourceId, source));
+        collectSublayerWrappers(getChildSublayers(source), layer, wrappers, trackedIds);
+    }
+}
+function findSublayerSourceById(sources, expectedId) {
+    for (const source of sources) {
+        if (extractSublayerId(source) === expectedId) {
+            return source;
+        }
+        const nested = findSublayerSourceById(getChildSublayers(source), expectedId);
+        if (nested !== undefined) {
+            return nested;
+        }
+    }
+    return undefined;
+}
+function extractSublayersFromMetadata(metadata) {
+    if (!isRecord(metadata) || !Array.isArray(metadata.layers)) {
+        return [];
+    }
+    const sublayersById = new Map();
+    const orderedIds = [];
+    const seenIds = new Set();
+    for (const entry of metadata.layers) {
+        if (!isRecord(entry)) {
+            continue;
+        }
+        const layerId = normalizeSublayerId(entry.id);
+        if (layerId === undefined || seenIds.has(layerId)) {
+            continue;
+        }
+        const hydrated = { ...entry, id: layerId };
+        if (typeof hydrated.title !== "string" && typeof hydrated.name === "string") {
+            hydrated.title = hydrated.name;
+        }
+        hydrated.sublayers = [];
+        sublayersById.set(layerId, hydrated);
+        orderedIds.push(layerId);
+        seenIds.add(layerId);
+    }
+    if (sublayersById.size === 0) {
+        return [];
+    }
+    const roots = [];
+    for (const layerId of orderedIds) {
+        const hydrated = sublayersById.get(layerId);
+        if (!hydrated) {
+            continue;
+        }
+        const parentId = normalizeSublayerId(hydrated.parentLayerId);
+        const parent = parentId === undefined ? undefined : sublayersById.get(parentId);
+        if (parent && Array.isArray(parent.sublayers)) {
+            parent.sublayers.push(hydrated);
+        }
+        else {
+            roots.push(hydrated);
+        }
+    }
+    return roots;
+}
+function extractFeatureCount(response) {
+    if (typeof response.count === "number" && Number.isFinite(response.count)) {
+        return response.count;
+    }
+    if (Array.isArray(response.features)) {
+        return response.features.length;
+    }
+    return 0;
+}
+function extractFeatures(response) {
+    if (!Array.isArray(response.features)) {
+        return [];
+    }
+    return response.features;
+}
+function extractObjectIds(response) {
+    if (!Array.isArray(response.objectIds)) {
+        return [];
+    }
+    return response.objectIds.map((value) => Number(value)).filter((value) => Number.isFinite(value));
+}
+function extractExtent(response) {
+    const count = typeof response.count === "number" && Number.isFinite(response.count) ? response.count : undefined;
+    return {
+        extent: (response.extent ?? null),
+        count,
+    };
+}
+function extractFieldDefinitions(metadata) {
+    if (!isRecord(metadata)) {
+        return [];
+    }
+    const fields = metadata.fields;
+    if (!Array.isArray(fields)) {
+        return [];
+    }
+    const records = [];
+    for (const field of fields) {
+        if (!isRecord(field) || typeof field.name !== "string" || typeof field.type !== "string") {
+            continue;
+        }
+        records.push(field);
+    }
+    return records;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}