@honua/sdk-esri-compat 0.0.6-alpha.0

package/esri-compat/feature-layer.js

@@ -0,0 +1,655 @@
+import { HonuaClient } from "../core/client.js";
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+import { parseFeatureLayerUrl } from "./url.js";
+const DEFAULT_MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+export class FeatureLayerCompat {
+    url;
+    id;
+    title;
+    serviceId;
+    layerId;
+    outFields;
+    definitionExpression;
+    renderer;
+    popupTemplate;
+    labelingInfo;
+    labelsVisible;
+    opacity;
+    visible;
+    minScale;
+    maxScale;
+    legendEnabled;
+    listMode;
+    loaded;
+    loadStatus;
+    metadata;
+    timeExtent;
+    eventBus;
+    client;
+    watchListeners;
+    eventListeners;
+    maxAttachmentBytes;
+    constructor(options) {
+        const parsed = parseFeatureLayerUrl(options.url);
+        this.url = options.url;
+        this.serviceId = parsed.serviceId;
+        this.layerId = parsed.layerId;
+        this.id = options.id ?? `${this.serviceId}-${this.layerId}`;
+        this.title = options.title;
+        this.outFields =
+            options.outFields === undefined
+                ? undefined
+                : Array.isArray(options.outFields)
+                    ? [...options.outFields]
+                    : [options.outFields];
+        this.definitionExpression = options.definitionExpression;
+        this.renderer = options.renderer;
+        this.popupTemplate = options.popupTemplate;
+        this.labelingInfo = Array.isArray(options.labelingInfo) ? [...options.labelingInfo] : [];
+        this.labelsVisible = options.labelsVisible ?? true;
+        this.opacity = normalizeOpacity(options.opacity ?? 1);
+        this.visible = options.visible ?? true;
+        this.minScale = normalizeScale(options.minScale);
+        this.maxScale = normalizeScale(options.maxScale);
+        this.legendEnabled = options.legendEnabled ?? true;
+        this.listMode = options.listMode ?? "show";
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.metadata = undefined;
+        this.timeExtent = undefined;
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.client) ?? new CompatEventBus();
+        this.client = options.client ?? new HonuaClient({ baseUrl: parsed.baseUrl });
+        this.watchListeners = new Map();
+        this.eventListeners = new Map();
+        this.maxAttachmentBytes = normalizeAttachmentSizeLimit(options.maxAttachmentBytes);
+    }
+    async load() {
+        if (!this.loaded) {
+            this.loadStatus = "loading";
+            this.notifyWatchers("loadStatus", this.loadStatus);
+            this.eventBus.emit("feature-layer.loading", { serviceId: this.serviceId, layerId: this.layerId, id: this.id }, this);
+            try {
+                this.metadata = await this.client.getLayerMetadata(this.serviceId, this.layerId);
+                this.notifyWatchers("metadata", this.metadata);
+                this.loaded = true;
+                this.notifyWatchers("loaded", this.loaded);
+                this.loadStatus = "loaded";
+                this.notifyWatchers("loadStatus", this.loadStatus);
+                this.eventBus.emit("feature-layer.loaded", { serviceId: this.serviceId, layerId: this.layerId, 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("feature-layer.failed", { serviceId: this.serviceId, layerId: this.layerId, 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("feature-layer.refreshed", { serviceId: this.serviceId, layerId: this.layerId, 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);
+            },
+        };
+    }
+    setVisibility(visible) {
+        this.visible = visible;
+        this.notifyWatchers("visible", this.visible);
+        this.eventBus.emit("layer.visibility-changed", { layerId: this.id, serviceId: this.serviceId, sublayerId: this.layerId, visible }, this);
+    }
+    setOpacity(opacity) {
+        this.opacity = normalizeOpacity(opacity);
+        this.notifyWatchers("opacity", this.opacity);
+        this.eventBus.emit("layer.opacity-changed", { layerId: this.id, serviceId: this.serviceId, sublayerId: this.layerId, opacity: this.opacity }, this);
+    }
+    setRenderer(renderer) {
+        this.renderer = renderer;
+        this.notifyWatchers("renderer", this.renderer);
+        this.eventBus.emit("feature-layer.renderer-changed", { layerId: this.id }, this);
+    }
+    setPopupTemplate(popupTemplate) {
+        this.popupTemplate = popupTemplate;
+        this.notifyWatchers("popupTemplate", this.popupTemplate);
+        this.eventBus.emit("feature-layer.popup-template-changed", { layerId: this.id }, this);
+    }
+    setLabelingInfo(labelingInfo) {
+        this.labelingInfo = [...labelingInfo];
+        this.notifyWatchers("labelingInfo", this.labelingInfo);
+        this.eventBus.emit("feature-layer.labeling-changed", { layerId: this.id }, this);
+    }
+    setDefinitionExpression(definitionExpression) {
+        this.definitionExpression = definitionExpression;
+        this.notifyWatchers("definitionExpression", this.definitionExpression);
+        this.eventBus.emit("feature-layer.definition-expression-changed", { layerId: this.id, definitionExpression }, this);
+    }
+    setOutFields(outFields) {
+        this.outFields = outFields === undefined ? undefined : Array.isArray(outFields) ? [...outFields] : [outFields];
+        this.notifyWatchers("outFields", this.outFields);
+        this.eventBus.emit("feature-layer.out-fields-changed", { layerId: this.id, outFields: this.outFields }, this);
+    }
+    setLabelsVisible(labelsVisible) {
+        this.labelsVisible = labelsVisible;
+        this.notifyWatchers("labelsVisible", this.labelsVisible);
+        this.eventBus.emit("feature-layer.labels-visible-changed", { layerId: this.id, labelsVisible }, this);
+    }
+    setScaleRange(minScale, maxScale) {
+        this.minScale = normalizeScale(minScale);
+        this.maxScale = normalizeScale(maxScale);
+        this.notifyWatchers("minScale", this.minScale);
+        this.notifyWatchers("maxScale", this.maxScale);
+        this.eventBus.emit("feature-layer.scale-range-changed", { layerId: this.id, minScale: this.minScale, maxScale: this.maxScale }, this);
+    }
+    setLegendEnabled(legendEnabled) {
+        this.legendEnabled = legendEnabled;
+        this.notifyWatchers("legendEnabled", this.legendEnabled);
+        this.eventBus.emit("feature-layer.legend-enabled-changed", { layerId: this.id, legendEnabled }, this);
+    }
+    setTimeExtent(extent) {
+        this.timeExtent = extent
+            ? { start: new Date(extent.start.getTime()), end: new Date(extent.end.getTime()) }
+            : undefined;
+        this.notifyWatchers("timeExtent", this.timeExtent);
+        this.eventBus.emit("feature-layer.time-extent-change", { layerId: this.id, timeExtent: this.timeExtent }, this);
+    }
+    destroy() {
+        this.watchListeners.clear();
+        this.eventListeners.clear();
+        this.eventBus.emit("feature-layer.destroyed", { id: this.id }, this);
+    }
+    on(eventName, listener) {
+        const namespacedEvent = `feature-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();
+            },
+        };
+    }
+    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;
+        });
+    }
+    hasField(fieldName) {
+        return this.getField(fieldName) !== undefined;
+    }
+    createQuery() {
+        return {
+            where: this.definitionExpression ?? "1=1",
+            outFields: this.outFields ? [...this.outFields] : ["*"],
+            returnGeometry: true,
+        };
+    }
+    queryFeatures(options = {}) {
+        const timeParam = buildTimeParam(this.timeExtent, options.extraParams);
+        return this.client.queryFeatures({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            where: options.where ?? this.definitionExpression,
+            outFields: options.outFields ?? this.outFields,
+            returnGeometry: options.returnGeometry,
+            method: options.method,
+            extraParams: timeParam ? { ...(options.extraParams ?? {}), time: timeParam } : options.extraParams,
+        });
+    }
+    async queryFeaturesAll(options = {}) {
+        const { pageSize: requestedPageSize, maxPages: requestedMaxPages, ...queryOptions } = options;
+        const pageSize = typeof requestedPageSize === "number" && Number.isFinite(requestedPageSize)
+            ? Math.max(1, Math.trunc(requestedPageSize))
+            : 2000;
+        const maxPages = typeof requestedMaxPages === "number" && Number.isFinite(requestedMaxPages)
+            ? Math.max(1, Math.trunc(requestedMaxPages))
+            : 100;
+        const features = [];
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryFeatures({
+                ...queryOptions,
+                extraParams: {
+                    ...(queryOptions.extraParams ?? {}),
+                    resultOffset: page * pageSize,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = response.features ?? [];
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            features.push(...pageFeatures);
+            if (pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+        return features;
+    }
+    async *queryFeaturesStream(options = {}) {
+        const { pageSize: requestedPageSize, maxPages: requestedMaxPages, ...queryOptions } = options;
+        const pageSize = typeof requestedPageSize === "number" && Number.isFinite(requestedPageSize)
+            ? Math.max(1, Math.trunc(requestedPageSize))
+            : 2000;
+        const maxPages = typeof requestedMaxPages === "number" && Number.isFinite(requestedMaxPages)
+            ? Math.max(1, Math.trunc(requestedMaxPages))
+            : 100;
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryFeatures({
+                ...queryOptions,
+                extraParams: {
+                    ...(queryOptions.extraParams ?? {}),
+                    resultOffset: page * pageSize,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = response.features ?? [];
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            yield pageFeatures;
+            if (pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+    }
+    async queryObjectIds(options = {}) {
+        const response = (await this.client.queryFeatures({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            where: options.where ?? this.definitionExpression,
+            returnGeometry: false,
+            method: options.method,
+            extraParams: {
+                ...options.extraParams,
+                returnIdsOnly: true,
+            },
+        }));
+        if (Array.isArray(response.objectIds)) {
+            return response.objectIds.map((value) => Number(value)).filter((value) => Number.isFinite(value));
+        }
+        const features = response.features;
+        if (!features) {
+            return [];
+        }
+        return features.map((feature) => extractObjectId(feature)).filter((value) => value !== undefined);
+    }
+    async queryFeatureCount(options = {}) {
+        const response = (await this.client.queryFeatures({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            where: options.where ?? this.definitionExpression,
+            returnGeometry: false,
+            method: options.method,
+            extraParams: {
+                ...options.extraParams,
+                returnCountOnly: true,
+            },
+        }));
+        if (typeof response.count === "number" && Number.isFinite(response.count)) {
+            return response.count;
+        }
+        return response.features?.length ?? 0;
+    }
+    async queryExtent(options = {}) {
+        const response = (await this.client.queryFeatures({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            where: options.where ?? this.definitionExpression,
+            returnGeometry: false,
+            method: options.method,
+            extraParams: {
+                ...options.extraParams,
+                returnExtentOnly: true,
+            },
+        }));
+        const count = typeof response.count === "number" && Number.isFinite(response.count) ? response.count : undefined;
+        return {
+            extent: response.extent ?? null,
+            count,
+        };
+    }
+    async applyEdits(options) {
+        const result = await this.client.applyEdits({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            adds: options.adds,
+            updates: options.updates,
+            deletes: options.deletes,
+            rollbackOnFailure: options.rollbackOnFailure,
+        });
+        this.eventBus.emit("feature-layer.edits", { result, layerId: this.id }, this);
+        return result;
+    }
+    queryRelatedFeatures(options) {
+        return this.client.queryRelatedRecords({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            relationshipId: options.relationshipId,
+            objectIds: options.objectIds,
+            where: options.where ?? this.definitionExpression,
+            outFields: options.outFields ?? this.outFields,
+            returnGeometry: options.returnGeometry,
+            method: options.method,
+            extraParams: options.extraParams,
+        });
+    }
+    queryRelatedRecords(options) {
+        return this.queryRelatedFeatures(options);
+    }
+    queryAttachments(options = {}) {
+        return this.client.request({
+            method: options.method ?? "GET",
+            path: `/rest/services/${encodeURIComponent(this.serviceId)}/FeatureServer/${this.layerId}/queryAttachments`,
+            responseFormat: options.responseFormat ?? "json",
+            query: {
+                ...(options.objectIds === undefined
+                    ? {}
+                    : {
+                        objectIds: Array.isArray(options.objectIds) ? options.objectIds.join(",") : options.objectIds,
+                    }),
+                ...(options.where === undefined ? {} : { where: options.where }),
+                ...(options.extraParams ?? {}),
+            },
+        });
+    }
+    listAttachments(options) {
+        return this.client.request({
+            method: "GET",
+            path: `/rest/services/${encodeURIComponent(this.serviceId)}` +
+                `/FeatureServer/${this.layerId}/${options.objectId}/attachments`,
+            responseFormat: options.responseFormat ?? "json",
+            query: options.extraParams,
+        });
+    }
+    deleteAttachments(options) {
+        const params = new URLSearchParams();
+        params.set("f", options.responseFormat ?? "json");
+        params.set("attachmentIds", Array.isArray(options.attachmentIds) ? options.attachmentIds.join(",") : String(options.attachmentIds));
+        if (options.extraParams) {
+            for (const [key, value] of Object.entries(options.extraParams)) {
+                params.set(key, String(value));
+            }
+        }
+        return this.client.request({
+            method: "POST",
+            path: `/rest/services/${encodeURIComponent(this.serviceId)}` +
+                `/FeatureServer/${this.layerId}/${options.objectId}/deleteAttachments`,
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body: params.toString(),
+        });
+    }
+    addAttachment(options) {
+        const maxAttachmentBytes = options.maxAttachmentBytes ?? this.maxAttachmentBytes;
+        enforceAttachmentSizeLimit(options.attachment, maxAttachmentBytes);
+        const formOrPromise = buildAttachmentFormData({
+            ...options,
+            maxAttachmentBytes,
+        });
+        const sendForm = (form) => this.client.request({
+            method: "POST",
+            path: `/rest/services/${encodeURIComponent(this.serviceId)}` +
+                `/FeatureServer/${this.layerId}/${options.objectId}/addAttachment`,
+            responseFormat: options.responseFormat ?? "json",
+            query: options.extraParams,
+            body: form,
+        });
+        if (formOrPromise instanceof Promise) {
+            return formOrPromise.then(sendForm);
+        }
+        return sendForm(formOrPromise);
+    }
+    updateAttachment(options) {
+        const maxAttachmentBytes = options.maxAttachmentBytes ?? this.maxAttachmentBytes;
+        enforceAttachmentSizeLimit(options.attachment, maxAttachmentBytes);
+        const formOrPromise = buildAttachmentFormData({
+            ...options,
+            maxAttachmentBytes,
+        });
+        const sendForm = (form) => {
+            form.set("attachmentId", String(options.attachmentId));
+            return this.client.request({
+                method: "POST",
+                path: `/rest/services/${encodeURIComponent(this.serviceId)}` +
+                    `/FeatureServer/${this.layerId}/${options.objectId}/updateAttachment`,
+                responseFormat: options.responseFormat ?? "json",
+                query: options.extraParams,
+                body: form,
+            });
+        };
+        if (formOrPromise instanceof Promise) {
+            return formOrPromise.then(sendForm);
+        }
+        return sendForm(formOrPromise);
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function normalizeOpacity(opacity) {
+    if (!Number.isFinite(opacity)) {
+        return 1;
+    }
+    return Math.min(Math.max(opacity, 0), 1);
+}
+function normalizeScale(scale) {
+    if (scale === undefined || !Number.isFinite(scale)) {
+        return 0;
+    }
+    return Math.max(0, Math.trunc(scale));
+}
+function extractObjectId(feature) {
+    if (!isRecord(feature)) {
+        return undefined;
+    }
+    const attributes = feature.attributes;
+    if (!isRecord(attributes)) {
+        return undefined;
+    }
+    for (const key of ["objectid", "OBJECTID", "id"]) {
+        const raw = attributes[key];
+        const parsed = Number(raw);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+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 buildAttachmentFormData(options) {
+    const attachmentName = resolveAttachmentName(options.attachment, options.name);
+    const blobOrPromise = normalizeAttachmentData(options.attachment, options.contentType, options.maxAttachmentBytes);
+    const buildForm = (blob) => {
+        const form = new FormData();
+        if (options.name) {
+            form.set("name", options.name);
+        }
+        form.set("attachment", blob, attachmentName);
+        return form;
+    };
+    if (blobOrPromise instanceof Promise) {
+        return blobOrPromise.then(buildForm);
+    }
+    return buildForm(blobOrPromise);
+}
+function normalizeAttachmentSizeLimit(maxAttachmentBytes) {
+    if (typeof maxAttachmentBytes !== "number" || !Number.isFinite(maxAttachmentBytes)) {
+        return DEFAULT_MAX_ATTACHMENT_BYTES;
+    }
+    return Math.max(1, Math.trunc(maxAttachmentBytes));
+}
+function enforceAttachmentSizeLimit(attachment, maxAttachmentBytes) {
+    const sizeBytes = estimateAttachmentSizeBytes(attachment);
+    if (sizeBytes === undefined || sizeBytes <= maxAttachmentBytes) {
+        return;
+    }
+    throw new Error(`Attachment payload exceeds maxAttachmentBytes (${sizeBytes} > ${maxAttachmentBytes}).`);
+}
+function estimateAttachmentSizeBytes(attachment) {
+    if (attachment instanceof Blob) {
+        return attachment.size;
+    }
+    if (typeof attachment === "string") {
+        return new TextEncoder().encode(attachment).byteLength;
+    }
+    if (attachment instanceof ArrayBuffer) {
+        return attachment.byteLength;
+    }
+    if (isReadableStream(attachment)) {
+        return undefined;
+    }
+    return attachment.byteLength;
+}
+function resolveAttachmentName(attachment, explicitName) {
+    if (explicitName && explicitName.trim().length > 0) {
+        return explicitName.trim();
+    }
+    if (isRecord(attachment)) {
+        const inferredName = attachment.name;
+        if (typeof inferredName === "string" && inferredName.trim().length > 0) {
+            return inferredName.trim();
+        }
+    }
+    return "attachment.bin";
+}
+function buildTimeParam(timeExtent, extraParams) {
+    if (!timeExtent) {
+        return undefined;
+    }
+    if (extraParams && "time" in extraParams) {
+        return undefined;
+    }
+    return `${timeExtent.start.getTime()},${timeExtent.end.getTime()}`;
+}
+function normalizeAttachmentData(attachment, contentType, maxAttachmentBytes) {
+    if (attachment instanceof Blob) {
+        return attachment;
+    }
+    if (typeof attachment === "string") {
+        return new Blob([attachment], {
+            type: contentType ?? "text/plain",
+        });
+    }
+    if (attachment instanceof ArrayBuffer) {
+        return new Blob([attachment], {
+            type: contentType ?? "application/octet-stream",
+        });
+    }
+    if (isReadableStream(attachment)) {
+        return collectStreamToBlob(attachment, contentType ?? "application/octet-stream", maxAttachmentBytes);
+    }
+    if (ArrayBuffer.isView(attachment)) {
+        const source = new Uint8Array(attachment.buffer, attachment.byteOffset, attachment.byteLength);
+        const copy = Uint8Array.from(source);
+        return new Blob([copy], {
+            type: contentType ?? "application/octet-stream",
+        });
+    }
+    throw new Error("Unsupported attachment payload type.");
+}
+function isReadableStream(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "getReader" in value &&
+        typeof value.getReader === "function");
+}
+async function collectStreamToBlob(stream, contentType, maxAttachmentBytes) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let totalBytes = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            if (value) {
+                totalBytes += value.byteLength;
+                if (totalBytes > maxAttachmentBytes) {
+                    try {
+                        await reader.cancel();
+                    }
+                    catch {
+                        // Ignore cancel errors; size-limit failure is the primary error.
+                    }
+                    throw new Error(`Attachment payload exceeds maxAttachmentBytes (${totalBytes} > ${maxAttachmentBytes}).`);
+                }
+                chunks.push(copyToArrayBuffer(value));
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return new Blob(chunks, { type: contentType });
+}
+function copyToArrayBuffer(chunk) {
+    const copy = new Uint8Array(chunk.byteLength);
+    copy.set(chunk);
+    return copy.buffer;
+}

package/esri-compat/feature-set.d.ts

@@ -0,0 +1,32 @@
+export interface FeatureSetCompatOptions {
+    features?: unknown[];
+    fields?: unknown[];
+    geometryType?: string;
+    spatialReference?: unknown;
+    objectIdFieldName?: string;
+    displayFieldName?: string;
+}
+export type FeatureSetLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface FeatureSetHandleCompat {
+    remove(): void;
+}
+export declare class FeatureSetCompat {
+    loaded: boolean;
+    loadStatus: FeatureSetLoadStatusCompat;
+    features: unknown[];
+    fields: unknown[];
+    geometryType: string | undefined;
+    spatialReference: unknown;
+    objectIdFieldName: string | undefined;
+    displayFieldName: string | undefined;
+    private readonly watchListeners;
+    constructor(options?: FeatureSetCompatOptions);
+    load(): Promise<FeatureSetCompat>;
+    when(callback?: (featureSet: FeatureSetCompat) => void): Promise<FeatureSetCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): FeatureSetHandleCompat;
+    clone(): FeatureSetCompat;
+    toJSON(): FeatureSetCompatOptions;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=feature-set.d.ts.map

package/esri-compat/feature-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-set.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/feature-set.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,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;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,0BAA0B,CAAC;IACvC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,uBAA4B;IAY3C,IAAI,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAcjC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,gBAAgB,KAAK,IAAI,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAQxF,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,sBAAsB;IAevF,KAAK,IAAI,gBAAgB;IAIzB,MAAM,IAAI,uBAAuB;IAWjC,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}