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

package/esri-compat/directions.js

@@ -0,0 +1,123 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+import { RouteLayerCompat, } from "./route-layer.js";
+export class DirectionsCompat {
+    view;
+    container;
+    eventBus;
+    loaded;
+    loadStatus;
+    useDefaultRouteLayer;
+    showSaveAsButton;
+    layer;
+    route;
+    watchListeners;
+    constructor(options = {}) {
+        this.view = options.view;
+        this.container = options.container;
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.view, options.layer) ?? new CompatEventBus();
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.useDefaultRouteLayer = options.useDefaultRouteLayer ?? true;
+        this.showSaveAsButton = options.showSaveAsButton ?? false;
+        this.layer =
+            options.layer ??
+                new RouteLayerCompat({
+                    stops: options.stops,
+                    routeProvider: options.routeProvider,
+                    eventBus: this.eventBus,
+                });
+        this.route = undefined;
+        this.watchListeners = new Map();
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("directions.loading", undefined, this);
+        await this.layer.load();
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("directions.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);
+            },
+        };
+    }
+    setStops(stops) {
+        this.layer.clearStops();
+        this.layer.addStops(stops);
+        this.notifyWatchers("stops", this.layer.stops);
+        this.eventBus.emit("directions.stops-updated", { stopCount: this.layer.stops.length }, this);
+    }
+    addStop(stop) {
+        this.layer.addStop(stop);
+        this.notifyWatchers("stops", this.layer.stops);
+        this.eventBus.emit("directions.stops-updated", { stopCount: this.layer.stops.length }, this);
+    }
+    clearStops() {
+        this.layer.clearStops();
+        this.notifyWatchers("stops", this.layer.stops);
+        this.route = undefined;
+        this.notifyWatchers("route", this.route);
+        this.eventBus.emit("directions.stops-cleared", undefined, this);
+    }
+    async solve() {
+        this.eventBus.emit("directions.solve-started", { stopCount: this.layer.stops.length }, this);
+        try {
+            const route = await this.layer.solve();
+            this.route = route;
+            this.notifyWatchers("route", this.route);
+            this.eventBus.emit("directions.solve-completed", { route }, this);
+            return route;
+        }
+        catch (error) {
+            this.route = undefined;
+            this.notifyWatchers("route", this.route);
+            this.eventBus.emit("directions.solve-error", { error }, this);
+            throw error;
+        }
+    }
+    getSummary() {
+        if (!this.route) {
+            return undefined;
+        }
+        return {
+            stopCount: this.layer.stops.length,
+            distanceMeters: this.route.totalLengthMeters,
+            durationSeconds: this.route.totalTimeSeconds,
+        };
+    }
+    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/editor.d.ts

@@ -0,0 +1,47 @@
+import { CompatEventBus } from "./event-bus.js";
+export type EditorWorkflowCompat = "create" | "update";
+export interface EditorLayerInfoCompat {
+    layer?: unknown;
+    enabled?: boolean;
+    addEnabled?: boolean;
+    updateEnabled?: boolean;
+    deleteEnabled?: boolean;
+    formTemplate?: unknown;
+}
+export interface EditorCompatOptions {
+    view?: unknown;
+    container?: unknown;
+    eventBus?: CompatEventBus;
+    layerInfos?: readonly EditorLayerInfoCompat[];
+    allowedWorkflows?: readonly EditorWorkflowCompat[];
+    supportingWidgetDefaults?: Record<string, unknown>;
+}
+export type EditorLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface EditorHandleCompat {
+    remove(): void;
+}
+export declare class EditorCompat {
+    readonly view: unknown;
+    readonly container: unknown;
+    readonly eventBus: CompatEventBus;
+    loaded: boolean;
+    loadStatus: EditorLoadStatusCompat;
+    layerInfos: EditorLayerInfoCompat[];
+    allowedWorkflows: EditorWorkflowCompat[];
+    supportingWidgetDefaults: Record<string, unknown>;
+    activeWorkflow: EditorWorkflowCompat | undefined;
+    selectedFeature: Record<string, unknown> | null;
+    private readonly watchListeners;
+    constructor(options?: EditorCompatOptions);
+    load(): Promise<EditorCompat>;
+    when(callback?: (widget: EditorCompat) => void): Promise<EditorCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): EditorHandleCompat;
+    startCreateWorkflowAtFeatureTypeSelection(layer?: unknown): boolean;
+    startUpdateWorkflowAtFeatureSelection(): boolean;
+    startUpdateWorkflowAtFeatureEdit(feature: Record<string, unknown>): boolean;
+    deleteFeatureFromWorkflow(feature?: unknown): boolean;
+    stopWorkflow(): void;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=editor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/editor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAmD,MAAM,gBAAgB,CAAC;AAEjG,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEvD,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,UAAU,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC9C,gBAAgB,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACnD,wBAAwB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpD;AAED,MAAM,MAAM,sBAAsB,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEzE,MAAM,WAAW,kBAAkB;IACjC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,YAAY;IACvB,SAAgB,IAAI,EAAE,OAAO,CAAC;IAC9B,SAAgB,SAAS,EAAE,OAAO,CAAC;IACnC,SAAgB,QAAQ,EAAE,cAAc,CAAC;IAClC,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,sBAAsB,CAAC;IACnC,UAAU,EAAE,qBAAqB,EAAE,CAAC;IACpC,gBAAgB,EAAE,oBAAoB,EAAE,CAAC;IACzC,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClD,cAAc,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACjD,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACvD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,mBAAwB;IAcvC,IAAI,IAAI,OAAO,CAAC,YAAY,CAAC;IAgB7B,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC;IAQ5E,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,kBAAkB;IAenF,yCAAyC,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO;IAoBnE,qCAAqC,IAAI,OAAO;IAiBhD,gCAAgC,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;IAY3E,yBAAyB,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO;IA0BrD,YAAY,IAAI,IAAI;IAapB,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/editor.js

@@ -0,0 +1,170 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+export class EditorCompat {
+    view;
+    container;
+    eventBus;
+    loaded;
+    loadStatus;
+    layerInfos;
+    allowedWorkflows;
+    supportingWidgetDefaults;
+    activeWorkflow;
+    selectedFeature;
+    watchListeners;
+    constructor(options = {}) {
+        this.view = options.view;
+        this.container = options.container;
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.view) ?? new CompatEventBus();
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.layerInfos = [...(options.layerInfos ?? [])];
+        this.allowedWorkflows = [...(options.allowedWorkflows ?? ["create", "update"])];
+        this.supportingWidgetDefaults = { ...(options.supportingWidgetDefaults ?? {}) };
+        this.activeWorkflow = undefined;
+        this.selectedFeature = null;
+        this.watchListeners = new Map();
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("editor.loading", undefined, this);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("editor.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);
+            },
+        };
+    }
+    startCreateWorkflowAtFeatureTypeSelection(layer) {
+        if (!this.allowedWorkflows.includes("create")) {
+            return false;
+        }
+        this.activeWorkflow = "create";
+        this.notifyWatchers("activeWorkflow", this.activeWorkflow);
+        this.selectedFeature = null;
+        this.notifyWatchers("selectedFeature", this.selectedFeature);
+        this.eventBus.emit("editor.workflow-started", {
+            workflow: "create",
+            layer,
+        }, this);
+        return true;
+    }
+    startUpdateWorkflowAtFeatureSelection() {
+        if (!this.allowedWorkflows.includes("update")) {
+            return false;
+        }
+        this.activeWorkflow = "update";
+        this.notifyWatchers("activeWorkflow", this.activeWorkflow);
+        this.eventBus.emit("editor.workflow-started", {
+            workflow: "update",
+        }, this);
+        return true;
+    }
+    startUpdateWorkflowAtFeatureEdit(feature) {
+        const started = this.startUpdateWorkflowAtFeatureSelection();
+        if (!started) {
+            return false;
+        }
+        this.selectedFeature = feature;
+        this.notifyWatchers("selectedFeature", this.selectedFeature);
+        this.eventBus.emit("editor.feature-selected", { feature }, this);
+        return true;
+    }
+    deleteFeatureFromWorkflow(feature) {
+        const targetFeature = feature ?? this.selectedFeature;
+        if (targetFeature === undefined) {
+            return false;
+        }
+        let removed = false;
+        for (const layerInfo of this.layerInfos) {
+            if (layerInfo.deleteEnabled === false) {
+                continue;
+            }
+            if (removeFeatureFromLayer(layerInfo.layer, targetFeature)) {
+                removed = true;
+            }
+        }
+        if (removed) {
+            this.eventBus.emit("editor.feature-deleted", { feature: targetFeature }, this);
+        }
+        if (this.selectedFeature === targetFeature) {
+            this.selectedFeature = null;
+            this.notifyWatchers("selectedFeature", this.selectedFeature);
+        }
+        return removed;
+    }
+    stopWorkflow() {
+        if (!this.activeWorkflow) {
+            return;
+        }
+        const workflow = this.activeWorkflow;
+        this.activeWorkflow = undefined;
+        this.notifyWatchers("activeWorkflow", this.activeWorkflow);
+        this.selectedFeature = null;
+        this.notifyWatchers("selectedFeature", this.selectedFeature);
+        this.eventBus.emit("editor.workflow-stopped", { workflow }, this);
+    }
+    destroy() {
+        this.watchListeners.clear();
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+}
+function removeFeatureFromLayer(layer, feature) {
+    if (!isEditorLayerLike(layer)) {
+        return false;
+    }
+    if (typeof layer.remove === "function") {
+        const beforeCount = Array.isArray(layer.graphics) ? layer.graphics.length : undefined;
+        const result = layer.remove(feature);
+        if (result !== undefined) {
+            return true;
+        }
+        if (beforeCount !== undefined && Array.isArray(layer.graphics)) {
+            return layer.graphics.length < beforeCount;
+        }
+        return false;
+    }
+    if (!Array.isArray(layer.graphics)) {
+        return false;
+    }
+    const index = layer.graphics.findIndex((candidate) => candidate === feature);
+    if (index < 0) {
+        return false;
+    }
+    layer.graphics.splice(index, 1);
+    return true;
+}
+function isEditorLayerLike(value) {
+    return typeof value === "object" && value !== null;
+}

package/esri-compat/esri-config.d.ts

@@ -0,0 +1,16 @@
+import { type EsriRequestInterceptorCompat } from "./request.js";
+export interface EsriConfigRequestCompat {
+    timeout: number;
+    useIdentity: boolean;
+    trustedServers: string[];
+    interceptors: EsriRequestInterceptorCompat[];
+}
+export interface EsriConfigCompat {
+    apiKey: string | undefined;
+    portalUrl: string;
+    request: EsriConfigRequestCompat;
+}
+export declare const esriConfig: EsriConfigCompat;
+export declare function resetEsriConfig(): void;
+export declare function getEsriConfigHonuaInterceptors(): import("../honua.js").HonuaRequestInterceptor[];
+//# sourceMappingURL=esri-config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"esri-config.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/esri-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,4BAA4B,EAAiC,MAAM,cAAc,CAAC;AAEhG,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,YAAY,EAAE,4BAA4B,EAAE,CAAC;CAC9C;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,uBAAuB,CAAC;CAClC;AAID,eAAO,MAAM,UAAU,EAAE,gBASxB,CAAC;AAEF,wBAAgB,eAAe,IAAI,IAAI,CAOtC;AAED,wBAAgB,8BAA8B,oDAE7C"}

package/esri-compat/esri-config.js

@@ -0,0 +1,23 @@
+import { createEsriRequestInterceptors } from "./request.js";
+const DEFAULT_PORTAL_URL = "https://www.arcgis.com";
+export const esriConfig = {
+    apiKey: undefined,
+    portalUrl: DEFAULT_PORTAL_URL,
+    request: {
+        timeout: 62_000,
+        useIdentity: true,
+        trustedServers: [],
+        interceptors: [],
+    },
+};
+export function resetEsriConfig() {
+    esriConfig.apiKey = undefined;
+    esriConfig.portalUrl = DEFAULT_PORTAL_URL;
+    esriConfig.request.timeout = 62_000;
+    esriConfig.request.useIdentity = true;
+    esriConfig.request.trustedServers.length = 0;
+    esriConfig.request.interceptors.length = 0;
+}
+export function getEsriConfigHonuaInterceptors() {
+    return createEsriRequestInterceptors(esriConfig.request.interceptors);
+}

package/esri-compat/esri-request.d.ts

@@ -0,0 +1,17 @@
+export type EsriRequestResponseTypeCompat = "json" | "text" | "blob" | "array-buffer";
+export interface EsriRequestCompatOptions {
+    method?: string;
+    query?: Record<string, string | number | boolean>;
+    headers?: Record<string, string>;
+    body?: BodyInit | null;
+    responseType?: EsriRequestResponseTypeCompat;
+    signal?: AbortSignal;
+}
+export interface EsriRequestCompatResponse<TData = unknown> {
+    data: TData;
+    url: string;
+    status: number;
+    headers: Headers;
+}
+export declare function esriRequest<TData = unknown>(url: string, options?: EsriRequestCompatOptions): Promise<EsriRequestCompatResponse<TData>>;
+//# sourceMappingURL=esri-request.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"esri-request.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/esri-request.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,6BAA6B,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,cAAc,CAAC;AAEtF,MAAM,WAAW,wBAAwB;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IAClD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IACvB,YAAY,CAAC,EAAE,6BAA6B,CAAC;IAC7C,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,yBAAyB,CAAC,KAAK,GAAG,OAAO;IACxD,IAAI,EAAE,KAAK,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,wBAAsB,WAAW,CAAC,KAAK,GAAG,OAAO,EAC/C,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,yBAAyB,CAAC,KAAK,CAAC,CAAC,CAwB3C"}

package/esri-compat/esri-request.js

@@ -0,0 +1,66 @@
+export async function esriRequest(url, options = {}) {
+    const finalUrl = appendQuery(url, options.query);
+    const method = options.method?.toUpperCase() ?? "GET";
+    const responseType = options.responseType ?? "json";
+    const response = await fetch(finalUrl, {
+        method,
+        headers: options.headers,
+        body: options.body ?? undefined,
+        signal: options.signal,
+    });
+    if (!response.ok) {
+        const detail = await readErrorDetail(response);
+        throw new Error(`esriRequest failed (${response.status}): ${detail}`);
+    }
+    const data = (await parseResponseBody(response, responseType));
+    return {
+        data,
+        url: response.url,
+        status: response.status,
+        headers: response.headers,
+    };
+}
+function appendQuery(urlText, query) {
+    if (!query || Object.keys(query).length === 0) {
+        return urlText;
+    }
+    const hashIndex = urlText.indexOf("#");
+    const hash = hashIndex >= 0 ? urlText.slice(hashIndex) : "";
+    const withoutHash = hashIndex >= 0 ? urlText.slice(0, hashIndex) : urlText;
+    const queryIndex = withoutHash.indexOf("?");
+    const path = queryIndex >= 0 ? withoutHash.slice(0, queryIndex) : withoutHash;
+    const existingQuery = queryIndex >= 0 ? withoutHash.slice(queryIndex + 1) : "";
+    const url = new URLSearchParams(existingQuery);
+    for (const [key, value] of Object.entries(query)) {
+        url.set(key, String(value));
+    }
+    const nextQuery = url.toString();
+    const withQuery = nextQuery.length > 0 ? `${path}?${nextQuery}` : path;
+    return `${withQuery}${hash}`;
+}
+async function parseResponseBody(response, responseType) {
+    switch (responseType) {
+        case "text":
+            return response.text();
+        case "blob":
+            return response.blob();
+        case "array-buffer":
+            return response.arrayBuffer();
+        default:
+            return response.json();
+    }
+}
+async function readErrorDetail(response) {
+    try {
+        const contentType = response.headers.get("content-type") ?? "";
+        if (contentType.includes("application/json")) {
+            const payload = await response.json();
+            return JSON.stringify(payload);
+        }
+        const text = await response.text();
+        return text || response.statusText;
+    }
+    catch {
+        return response.statusText || "request failed";
+    }
+}

package/esri-compat/event-bus.d.ts

@@ -0,0 +1,106 @@
+export interface CompatEvent<TPayload = unknown> {
+    type: string;
+    payload: TPayload;
+    source: unknown;
+    timestamp: number;
+}
+export type CompatEventListener<TPayload = unknown> = (event: CompatEvent<TPayload>) => void;
+export interface CompatEventSubscription {
+    remove(): void;
+}
+/** Well-known event payload types for the compat layer event bus. */
+export interface CompatEventPayloads {
+    "layer.visibility-changed": {
+        layerId: string;
+        serviceId?: string;
+        sublayerId?: number;
+        visible: boolean;
+    };
+    "layer.opacity-changed": {
+        layerId: string;
+        serviceId?: string;
+        sublayerId?: number;
+        opacity: number;
+    };
+    "feature-layer.loading": {
+        serviceId: string;
+        layerId: number;
+        id: string;
+    };
+    "feature-layer.loaded": {
+        serviceId: string;
+        layerId: number;
+        id: string;
+    };
+    "feature-layer.failed": {
+        serviceId: string;
+        layerId: number;
+        id: string;
+        error: unknown;
+    };
+    "feature-layer.refreshed": {
+        serviceId: string;
+        layerId: number;
+        id: string;
+    };
+    "feature-layer.destroyed": {
+        id: string;
+    };
+    "feature-layer.edits": {
+        result: unknown;
+        layerId: string;
+    };
+    "feature-layer.renderer-changed": {
+        layerId: string;
+    };
+    "feature-layer.popup-template-changed": {
+        layerId: string;
+    };
+    "feature-layer.labeling-changed": {
+        layerId: string;
+    };
+    "feature-layer.definition-expression-changed": {
+        layerId: string;
+        definitionExpression: string | undefined;
+    };
+    "feature-layer.out-fields-changed": {
+        layerId: string;
+        outFields: string[] | undefined;
+    };
+    "feature-layer.labels-visible-changed": {
+        layerId: string;
+        labelsVisible: boolean;
+    };
+    "feature-layer.scale-range-changed": {
+        layerId: string;
+        minScale: number;
+        maxScale: number;
+    };
+    "feature-layer.legend-enabled-changed": {
+        layerId: string;
+        legendEnabled: boolean;
+    };
+    "feature-layer.time-extent-change": {
+        layerId: string;
+        timeExtent: {
+            start: Date;
+            end: Date;
+        } | undefined;
+    };
+}
+export declare class CompatEventBus {
+    private readonly listenersByType;
+    private readonly anyListeners;
+    constructor();
+    on<K extends keyof CompatEventPayloads>(type: K, listener: CompatEventListener<CompatEventPayloads[K]>): CompatEventSubscription;
+    on<TPayload = unknown>(type: string, listener: CompatEventListener<TPayload>): CompatEventSubscription;
+    onAny<TPayload = unknown>(listener: CompatEventListener<TPayload>): CompatEventSubscription;
+    emit<TPayload = unknown>(type: string, payload: TPayload, source?: unknown): CompatEvent<TPayload>;
+    clear(): void;
+    private dispatchToTypeListeners;
+    private dispatchToAnyListeners;
+    private safeInvoke;
+}
+export declare function resolveCompatEventBus(...candidates: readonly unknown[]): CompatEventBus | undefined;
+export declare function safeInvokeCompatListener<TValue>(listener: (value: TValue) => void, value: TValue): void;
+//# sourceMappingURL=event-bus.d.ts.map

package/esri-compat/event-bus.d.ts.map

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

package/esri-compat/event-bus.js

@@ -0,0 +1,90 @@
+export class CompatEventBus {
+    listenersByType;
+    anyListeners;
+    constructor() {
+        this.listenersByType = new Map();
+        this.anyListeners = new Set();
+    }
+    on(type, listener) {
+        let listeners = this.listenersByType.get(type);
+        if (!listeners) {
+            listeners = new Set();
+            this.listenersByType.set(type, listeners);
+        }
+        const untypedListener = listener;
+        listeners.add(untypedListener);
+        return {
+            remove: () => {
+                listeners?.delete(untypedListener);
+            },
+        };
+    }
+    onAny(listener) {
+        const untypedListener = listener;
+        this.anyListeners.add(untypedListener);
+        return {
+            remove: () => {
+                this.anyListeners.delete(untypedListener);
+            },
+        };
+    }
+    emit(type, payload, source = undefined) {
+        const event = {
+            type,
+            payload,
+            source,
+            timestamp: Date.now(),
+        };
+        this.dispatchToTypeListeners(type, event);
+        this.dispatchToAnyListeners(event);
+        return event;
+    }
+    clear() {
+        this.listenersByType.clear();
+        this.anyListeners.clear();
+    }
+    dispatchToTypeListeners(type, event) {
+        const listeners = this.listenersByType.get(type);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            this.safeInvoke(listener, event);
+        }
+    }
+    dispatchToAnyListeners(event) {
+        for (const listener of this.anyListeners) {
+            this.safeInvoke(listener, event);
+        }
+    }
+    safeInvoke(listener, event) {
+        try {
+            listener(event);
+        }
+        catch {
+            // Event listeners should not break compatibility flow.
+        }
+    }
+}
+export function resolveCompatEventBus(...candidates) {
+    for (const candidate of candidates) {
+        if (!isRecord(candidate)) {
+            continue;
+        }
+        if (candidate.eventBus instanceof CompatEventBus) {
+            return candidate.eventBus;
+        }
+    }
+    return undefined;
+}
+export function safeInvokeCompatListener(listener, value) {
+    try {
+        listener(value);
+    }
+    catch {
+        // Listener errors should not break compatibility flow.
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}