@honua/react 0.0.20-alpha.0

package/esri-compat/feature-table.js

@@ -0,0 +1,500 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+export class FeatureTableHighlightIdsCompat {
+    values;
+    listeners;
+    constructor(initialIds = []) {
+        this.values = [];
+        this.listeners = new Set();
+        this.set(initialIds);
+    }
+    get length() {
+        return this.values.length;
+    }
+    at(index) {
+        return this.values.at(index);
+    }
+    toArray() {
+        return [...this.values];
+    }
+    indexOf(objectId) {
+        const normalized = normalizeObjectId(objectId);
+        if (normalized === undefined) {
+            return -1;
+        }
+        return this.values.indexOf(normalized);
+    }
+    add(...objectIds) {
+        return this.push(...objectIds);
+    }
+    push(...objectIds) {
+        const additions = normalizeUniqueObjectIds(objectIds).filter((objectId) => !this.values.includes(objectId));
+        if (additions.length === 0) {
+            return this.values.length;
+        }
+        this.values.push(...additions);
+        this.emitChange({
+            added: additions,
+            removed: [],
+        });
+        return this.values.length;
+    }
+    remove(objectId) {
+        const index = this.indexOf(objectId);
+        if (index < 0) {
+            return false;
+        }
+        const removed = this.values.splice(index, 1);
+        this.emitChange({
+            added: [],
+            removed: removed,
+        });
+        return true;
+    }
+    removeAll() {
+        if (this.values.length === 0) {
+            return;
+        }
+        const removed = [...this.values];
+        this.values.length = 0;
+        this.emitChange({
+            added: [],
+            removed,
+        });
+    }
+    set(objectIds) {
+        const next = normalizeUniqueObjectIds(objectIds);
+        const removed = this.values.filter((objectId) => !next.includes(objectId));
+        const added = next.filter((objectId) => !this.values.includes(objectId));
+        if (removed.length === 0 && added.length === 0 && this.values.length === next.length) {
+            return;
+        }
+        this.values.length = 0;
+        this.values.push(...next);
+        this.emitChange({
+            added,
+            removed,
+        });
+    }
+    splice(start, deleteCount, ...items) {
+        const currentLength = this.values.length;
+        const normalizedStart = normalizeSpliceStart(start, currentLength);
+        const normalizedDeleteCount = normalizeSpliceDeleteCount(deleteCount, normalizedStart, currentLength);
+        const removed = this.values.splice(normalizedStart, normalizedDeleteCount);
+        const additions = normalizeUniqueObjectIds(items).filter((objectId) => !this.values.includes(objectId));
+        if (additions.length > 0) {
+            this.values.splice(normalizedStart, 0, ...additions);
+        }
+        if (removed.length > 0 || additions.length > 0) {
+            this.emitChange({
+                added: additions,
+                removed,
+            });
+        }
+        return removed;
+    }
+    on(type, listener) {
+        if (type !== "change") {
+            return { remove: () => undefined };
+        }
+        this.listeners.add(listener);
+        return {
+            remove: () => {
+                this.listeners.delete(listener);
+            },
+        };
+    }
+    [Symbol.iterator]() {
+        return this.values[Symbol.iterator]();
+    }
+    emitChange(event) {
+        for (const listener of this.listeners) {
+            try {
+                listener({
+                    added: [...event.added],
+                    removed: [...event.removed],
+                });
+            }
+            catch {
+                // Listener errors should not break compatibility flow.
+            }
+        }
+    }
+}
+export class FeatureTableCompat {
+    view;
+    container;
+    eventBus;
+    title;
+    description;
+    actionColumnConfig;
+    attachmentsEnabled;
+    paginationEnabled;
+    editingEnabled;
+    multiSortEnabled;
+    relatedRecordsEnabled;
+    objectIdField;
+    state;
+    loadStatus;
+    filterGeometry;
+    filterBySelectionEnabled;
+    where;
+    tableTemplate;
+    visibleElements;
+    fieldConfigs;
+    selectionMode;
+    rowSelectionEnabled;
+    highlightEnabled;
+    pageSize;
+    autoRefreshEnabled;
+    highlightIds;
+    rows;
+    watchListeners;
+    refreshRevision;
+    layerInternal;
+    get size() {
+        return this.rows.length;
+    }
+    get layer() {
+        return this.layerInternal;
+    }
+    set layer(layer) {
+        this.setLayer(layer);
+    }
+    get loaded() {
+        return this.loadStatus === "loaded" || this.state === "loaded";
+    }
+    constructor(options = {}) {
+        this.view = options.view;
+        this.layerInternal = options.layer;
+        this.container = options.container;
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.view, options.layer) ?? new CompatEventBus();
+        this.title = options.title ?? null;
+        this.description = options.description;
+        this.actionColumnConfig = options.actionColumnConfig ?? null;
+        this.attachmentsEnabled = options.attachmentsEnabled ?? false;
+        this.paginationEnabled = options.paginationEnabled ?? false;
+        this.editingEnabled = options.editingEnabled ?? false;
+        this.multiSortEnabled = options.multiSortEnabled ?? false;
+        this.relatedRecordsEnabled = options.relatedRecordsEnabled ?? false;
+        this.objectIdField = options.objectIdField ?? "OBJECTID";
+        this.state = "loading";
+        this.loadStatus = "not-loaded";
+        this.where = options.where ?? "1=1";
+        this.filterGeometry = options.filterGeometry ?? null;
+        this.filterBySelectionEnabled = options.filterBySelectionEnabled ?? false;
+        this.tableTemplate = options.tableTemplate ?? null;
+        this.visibleElements = options.visibleElements ?? null;
+        this.fieldConfigs = options.fieldConfigs ?? null;
+        this.selectionMode = options.selectionMode ?? "multiple";
+        this.rowSelectionEnabled = options.rowSelectionEnabled ?? true;
+        this.highlightEnabled = options.highlightEnabled ?? true;
+        this.pageSize =
+            typeof options.pageSize === "number" && Number.isFinite(options.pageSize)
+                ? Math.max(1, Math.trunc(options.pageSize))
+                : 25;
+        this.autoRefreshEnabled = options.autoRefreshEnabled ?? true;
+        this.highlightIds = new FeatureTableHighlightIdsCompat(options.highlightIds);
+        this.rows = [];
+        this.watchListeners = new Map();
+        this.refreshRevision = 0;
+        this.highlightIds.on("change", (event) => {
+            this.notifyWatchers("highlightIds", this.highlightIds.toArray());
+            this.eventBus.emit("feature-table.selection-changed", {
+                objectIds: this.highlightIds.toArray(),
+                added: event.added,
+                removed: event.removed,
+            }, this);
+        });
+    }
+    async when(callback) {
+        await this.load();
+        if (callback) {
+            callback(this);
+        }
+        return this;
+    }
+    async load() {
+        if (this.loadStatus === "loaded") {
+            return this;
+        }
+        await this.refresh();
+        return 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);
+            },
+        };
+    }
+    async refresh() {
+        const refreshRevision = this.nextRefreshRevision();
+        if (this.loadStatus !== "loading") {
+            this.loadStatus = "loading";
+            this.notifyWatchers("loadStatus", this.loadStatus);
+            this.eventBus.emit("feature-table.loading", undefined, this);
+        }
+        this.state = "loading";
+        this.notifyWatchers("state", this.state);
+        this.eventBus.emit("feature-table.state-changed", { state: this.state }, this);
+        if (!this.layer) {
+            if (refreshRevision !== this.refreshRevision) {
+                return this.rows;
+            }
+            this.rows = [];
+            this.notifyWatchers("rows", this.rows);
+            this.notifyWatchers("size", this.size);
+            this.state = "loaded";
+            this.notifyWatchers("state", this.state);
+            this.eventBus.emit("feature-table.state-changed", { state: this.state }, this);
+            this.loadStatus = "loaded";
+            this.notifyWatchers("loadStatus", this.loadStatus);
+            this.notifyWatchers("loaded", this.loaded);
+            this.eventBus.emit("feature-table.loaded", { rowCount: 0 }, this);
+            this.eventBus.emit("feature-table.refreshed", { rowCount: 0 }, this);
+            return this.rows;
+        }
+        try {
+            const response = await this.layer.queryFeatures({
+                where: this.where,
+                returnGeometry: true,
+            });
+            if (refreshRevision !== this.refreshRevision) {
+                return this.rows;
+            }
+            this.rows = extractRows(response, this.objectIdField);
+            this.notifyWatchers("rows", this.rows);
+            this.notifyWatchers("size", this.size);
+            this.state = "loaded";
+            this.notifyWatchers("state", this.state);
+            this.eventBus.emit("feature-table.state-changed", { state: this.state }, this);
+            this.loadStatus = "loaded";
+            this.notifyWatchers("loadStatus", this.loadStatus);
+            this.notifyWatchers("loaded", this.loaded);
+            this.eventBus.emit("feature-table.loaded", { rowCount: this.rows.length }, this);
+            this.eventBus.emit("feature-table.refreshed", { rowCount: this.rows.length }, this);
+            return this.rows;
+        }
+        catch (error) {
+            if (refreshRevision !== this.refreshRevision) {
+                return this.rows;
+            }
+            this.state = "error";
+            this.notifyWatchers("state", this.state);
+            this.eventBus.emit("feature-table.state-changed", { state: this.state }, this);
+            this.loadStatus = "failed";
+            this.notifyWatchers("loadStatus", this.loadStatus);
+            this.notifyWatchers("loaded", this.loaded);
+            this.eventBus.emit("feature-table.failed", { error }, this);
+            throw error;
+        }
+    }
+    setLayer(layer) {
+        if (Object.is(this.layerInternal, layer)) {
+            return;
+        }
+        this.nextRefreshRevision();
+        this.layerInternal = layer;
+        this.notifyWatchers("layer", this.layerInternal);
+        this.eventBus.emit("feature-table.layer-changed", { hasLayer: Boolean(layer) }, this);
+    }
+    setWhere(where) {
+        this.where = where;
+        this.notifyWatchers("where", this.where);
+        this.eventBus.emit("feature-table.filter-changed", { where }, this);
+    }
+    setFilterGeometry(filterGeometry) {
+        this.filterGeometry = filterGeometry;
+        this.notifyWatchers("filterGeometry", this.filterGeometry);
+        this.eventBus.emit("feature-table.filter-geometry-changed", { filterGeometry }, this);
+    }
+    selectRows(objectIds) {
+        this.highlightIds.set(objectIds);
+    }
+    clearSelection() {
+        this.highlightIds.removeAll();
+    }
+    getSelectedObjectIds() {
+        return this.highlightIds.toArray();
+    }
+    getSelectedRows() {
+        if (this.highlightIds.length === 0) {
+            return [];
+        }
+        const selectedIds = new Set(this.highlightIds.toArray());
+        return this.rows.filter((row) => selectedIds.has(row.objectId));
+    }
+    /**
+     * Sorts current rows by the given field name and direction.
+     * Returns a new sorted snapshot (does not re-fetch from the server).
+     */
+    sortRows(fieldName, direction = "asc") {
+        const sorted = [...this.rows].sort((a, b) => {
+            const aVal = a.attributes[fieldName];
+            const bVal = b.attributes[fieldName];
+            const comparison = compareAttributeValues(aVal, bVal);
+            return direction === "desc" ? -comparison : comparison;
+        });
+        this.rows = sorted;
+        this.notifyWatchers("rows", this.rows);
+        this.eventBus.emit("feature-table.sorted", { fieldName, direction, rowCount: this.rows.length }, this);
+        return this.rows;
+    }
+    /**
+     * Exports current rows as a JSON-serializable array of attribute records.
+     * Optionally accepts a list of field names to include.
+     */
+    exportRows(fieldNames) {
+        return this.rows.map((row) => {
+            if (!fieldNames || fieldNames.length === 0) {
+                return { ...row.attributes };
+            }
+            const filtered = {};
+            for (const field of fieldNames) {
+                if (field in row.attributes) {
+                    filtered[field] = row.attributes[field];
+                }
+            }
+            return filtered;
+        });
+    }
+    /**
+     * Finds a row by its object ID, or undefined if not found.
+     */
+    findRowByObjectId(objectId) {
+        return this.rows.find((row) => row.objectId === objectId);
+    }
+    destroy() {
+        this.watchListeners.clear();
+        this.eventBus.emit("feature-table.destroyed", undefined, this);
+    }
+    async queryRelatedRecords(options) {
+        if (!this.layer) {
+            return { relatedRecordGroups: [] };
+        }
+        const objectIds = options.objectIds === undefined
+            ? this.highlightIds.length > 0
+                ? this.highlightIds.toArray()
+                : undefined
+            : Array.isArray(options.objectIds)
+                ? [...options.objectIds]
+                : options.objectIds;
+        return this.layer.queryRelatedFeatures({
+            relationshipId: options.relationshipId,
+            objectIds,
+            where: options.where ?? this.where,
+            outFields: options.outFields,
+            returnGeometry: options.returnGeometry,
+            method: options.method,
+            extraParams: options.extraParams,
+        });
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+    nextRefreshRevision() {
+        this.refreshRevision += 1;
+        return this.refreshRevision;
+    }
+}
+function extractRows(response, objectIdField) {
+    if (!isRecord(response) || !Array.isArray(response.features)) {
+        return [];
+    }
+    const rows = [];
+    for (const feature of response.features) {
+        if (!isRecord(feature) || !isRecord(feature.attributes)) {
+            continue;
+        }
+        const objectId = extractObjectId(feature.attributes, objectIdField);
+        if (objectId === undefined) {
+            continue;
+        }
+        rows.push({
+            objectId,
+            attributes: { ...feature.attributes },
+            geometry: feature.geometry,
+        });
+    }
+    return rows;
+}
+function extractObjectId(attributes, objectIdField) {
+    const preferred = Number(attributes[objectIdField]);
+    if (Number.isFinite(preferred)) {
+        return preferred;
+    }
+    for (const key of ["OBJECTID", "objectid", "ObjectId", "id"]) {
+        const parsed = Number(attributes[key]);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function normalizeObjectId(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function normalizeUniqueObjectIds(values) {
+    const normalized = [];
+    for (const value of values) {
+        const objectId = normalizeObjectId(value);
+        if (objectId === undefined || normalized.includes(objectId)) {
+            continue;
+        }
+        normalized.push(objectId);
+    }
+    return normalized;
+}
+function normalizeSpliceStart(start, length) {
+    if (!Number.isFinite(start)) {
+        return length;
+    }
+    const integer = Math.trunc(start);
+    if (integer < 0) {
+        return Math.max(length + integer, 0);
+    }
+    return Math.min(integer, length);
+}
+function normalizeSpliceDeleteCount(deleteCount, start, length) {
+    if (deleteCount === undefined) {
+        return Math.max(length - start, 0);
+    }
+    if (!Number.isFinite(deleteCount)) {
+        return 0;
+    }
+    return Math.min(Math.max(Math.trunc(deleteCount), 0), Math.max(length - start, 0));
+}
+function compareAttributeValues(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    if (a === undefined || a === null) {
+        return -1;
+    }
+    if (b === undefined || b === null) {
+        return 1;
+    }
+    if (typeof a === "number" && typeof b === "number") {
+        return a - b;
+    }
+    if (typeof a === "string" && typeof b === "string") {
+        return a.localeCompare(b);
+    }
+    return String(a).localeCompare(String(b));
+}

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

@@ -0,0 +1,41 @@
+import { CompatEventBus } from "./event-bus.js";
+export interface FeatureTemplateItemCompat {
+    id: string;
+    name: string;
+    description?: string;
+}
+export interface FeatureTemplatesCompatOptions {
+    view?: unknown;
+    layerInfos?: readonly unknown[];
+    container?: unknown;
+    filterFunction?: ((item: FeatureTemplateItemCompat) => boolean) | undefined;
+    groupBy?: unknown;
+    eventBus?: CompatEventBus;
+}
+export type FeatureTemplatesLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface FeatureTemplatesHandleCompat {
+    remove(): void;
+}
+export declare class FeatureTemplatesCompat {
+    readonly view: unknown;
+    readonly layerInfos: readonly unknown[];
+    readonly container: unknown;
+    readonly eventBus: CompatEventBus;
+    readonly filterFunction: ((item: FeatureTemplateItemCompat) => boolean) | undefined;
+    readonly groupBy: unknown;
+    loaded: boolean;
+    loadStatus: FeatureTemplatesLoadStatusCompat;
+    templates: FeatureTemplateItemCompat[];
+    selectedTemplate: FeatureTemplateItemCompat | undefined;
+    private readonly watchListeners;
+    constructor(options?: FeatureTemplatesCompatOptions);
+    load(): Promise<FeatureTemplatesCompat>;
+    when(callback?: (widget: FeatureTemplatesCompat) => void): Promise<FeatureTemplatesCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): FeatureTemplatesHandleCompat;
+    setTemplates(templates: readonly FeatureTemplateItemCompat[]): void;
+    selectTemplate(templateId: string): FeatureTemplateItemCompat | undefined;
+    on(eventName: string, listener: (event: unknown) => void): FeatureTemplatesHandleCompat;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=feature-templates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature-templates.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/feature-templates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAmD,MAAM,gBAAgB,CAAC;AAEjG,MAAM,WAAW,yBAAyB;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,6BAA6B;IAC5C,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAChC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,cAAc,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,yBAAyB,KAAK,OAAO,CAAC,GAAG,SAAS,CAAC;IAC5E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,MAAM,MAAM,gCAAgC,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEnF,MAAM,WAAW,4BAA4B;IAC3C,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,sBAAsB;IACjC,SAAgB,IAAI,EAAE,OAAO,CAAC;IAC9B,SAAgB,UAAU,EAAE,SAAS,OAAO,EAAE,CAAC;IAC/C,SAAgB,SAAS,EAAE,OAAO,CAAC;IACnC,SAAgB,QAAQ,EAAE,cAAc,CAAC;IACzC,SAAgB,cAAc,EAAE,CAAC,CAAC,IAAI,EAAE,yBAAyB,KAAK,OAAO,CAAC,GAAG,SAAS,CAAC;IAC3F,SAAgB,OAAO,EAAE,OAAO,CAAC;IAC1B,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,gCAAgC,CAAC;IAC7C,SAAS,EAAE,yBAAyB,EAAE,CAAC;IACvC,gBAAgB,EAAE,yBAAyB,GAAG,SAAS,CAAC;IAC/D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,6BAAkC;IAcjD,IAAI,IAAI,OAAO,CAAC,sBAAsB,CAAC;IAgBvC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,sBAAsB,KAAK,IAAI,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAQhG,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,4BAA4B;IAe7F,YAAY,CAAC,SAAS,EAAE,SAAS,yBAAyB,EAAE,GAAG,IAAI;IAQnE,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,yBAAyB,GAAG,SAAS;IAQzE,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,4BAA4B;IAavF,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/feature-templates.js

@@ -0,0 +1,97 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+export class FeatureTemplatesCompat {
+    view;
+    layerInfos;
+    container;
+    eventBus;
+    filterFunction;
+    groupBy;
+    loaded;
+    loadStatus;
+    templates;
+    selectedTemplate;
+    watchListeners;
+    constructor(options = {}) {
+        this.view = options.view;
+        this.layerInfos = options.layerInfos ? [...options.layerInfos] : [];
+        this.container = options.container;
+        this.filterFunction = options.filterFunction;
+        this.groupBy = options.groupBy;
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.view) ?? new CompatEventBus();
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.templates = [];
+        this.selectedTemplate = undefined;
+        this.watchListeners = new Map();
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("feature-templates.loading", undefined, this);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("feature-templates.loaded", undefined, 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);
+            },
+        };
+    }
+    setTemplates(templates) {
+        const filtered = this.filterFunction === undefined ? templates : templates.filter((item) => this.filterFunction?.(item) ?? true);
+        this.templates = filtered.map((item) => ({ ...item }));
+        this.notifyWatchers("templates", this.templates);
+        this.eventBus.emit("feature-templates.updated", { count: this.templates.length }, this);
+    }
+    selectTemplate(templateId) {
+        const found = this.templates.find((template) => template.id === templateId);
+        this.selectedTemplate = found ? { ...found } : undefined;
+        this.notifyWatchers("selectedTemplate", this.selectedTemplate);
+        this.eventBus.emit("feature-templates.selected", { template: this.selectedTemplate }, this);
+        return this.selectedTemplate;
+    }
+    on(eventName, listener) {
+        const namespacedEvent = `feature-templates.${eventName}`;
+        const subscription = this.eventBus.on(namespacedEvent, (event) => {
+            safeInvokeCompatListener(listener, event.payload);
+        });
+        return {
+            remove: () => {
+                subscription.remove();
+            },
+        };
+    }
+    destroy() {
+        this.watchListeners.clear();
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+}

package/esri-compat/feature.d.ts

@@ -0,0 +1,33 @@
+import { CompatEventBus } from "./event-bus.js";
+export interface FeatureCompatOptions {
+    view?: unknown;
+    map?: unknown;
+    container?: unknown;
+    graphic?: unknown;
+    title?: string;
+    eventBus?: CompatEventBus;
+}
+export type FeatureLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface FeatureHandleCompat {
+    remove(): void;
+}
+export declare class FeatureCompat {
+    readonly view: unknown;
+    readonly map: unknown;
+    readonly container: unknown;
+    readonly eventBus: CompatEventBus;
+    loaded: boolean;
+    loadStatus: FeatureLoadStatusCompat;
+    graphic: unknown;
+    title: string | undefined;
+    private readonly watchListeners;
+    constructor(options?: FeatureCompatOptions);
+    load(): Promise<FeatureCompat>;
+    when(callback?: (widget: FeatureCompat) => void): Promise<FeatureCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): FeatureHandleCompat;
+    setGraphic(graphic: unknown, title?: string): void;
+    clear(): void;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=feature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/feature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAmD,MAAM,gBAAgB,CAAC;AAEjG,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,MAAM,MAAM,uBAAuB,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE1E,MAAM,WAAW,mBAAmB;IAClC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,aAAa;IACxB,SAAgB,IAAI,EAAE,OAAO,CAAC;IAC9B,SAAgB,GAAG,EAAE,OAAO,CAAC;IAC7B,SAAgB,SAAS,EAAE,OAAO,CAAC;IACnC,SAAgB,QAAQ,EAAE,cAAc,CAAC;IAClC,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,uBAAuB,CAAC;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,oBAAyB;IAYxC,IAAI,IAAI,OAAO,CAAC,aAAa,CAAC;IAgB9B,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC;IAQ9E,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,mBAAmB;IAepF,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAUlD,KAAK,IAAI,IAAI;IAMb,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}