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

package/esri-compat/sketch.js

@@ -0,0 +1,227 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+export class SketchCompat {
+    view;
+    layer;
+    container;
+    eventBus;
+    updateOnGraphicClick;
+    creationMode;
+    defaultCreateOptions;
+    defaultUpdateOptions;
+    loaded;
+    loadStatus;
+    state;
+    activeTool;
+    activeCreateOptions;
+    activeUpdateGraphics;
+    activeUpdateOptions;
+    watchListeners;
+    constructor(options = {}) {
+        this.view = options.view;
+        this.layer = options.layer;
+        this.container = options.container;
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.view, options.layer) ?? new CompatEventBus();
+        this.updateOnGraphicClick = options.updateOnGraphicClick ?? true;
+        this.creationMode = options.creationMode ?? "single";
+        this.defaultCreateOptions = { ...(options.defaultCreateOptions ?? {}) };
+        this.defaultUpdateOptions = { ...(options.defaultUpdateOptions ?? {}) };
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.state = "ready";
+        this.activeTool = undefined;
+        this.activeCreateOptions = undefined;
+        this.activeUpdateGraphics = [];
+        this.activeUpdateOptions = undefined;
+        this.watchListeners = new Map();
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("sketch.loading", undefined, this);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("sketch.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);
+            },
+        };
+    }
+    create(tool, options) {
+        this.state = "active";
+        this.notifyWatchers("state", this.state);
+        this.activeTool = tool;
+        this.notifyWatchers("activeTool", this.activeTool);
+        this.activeCreateOptions = {
+            ...this.defaultCreateOptions,
+            ...(options ?? {}),
+        };
+        this.notifyWatchers("activeCreateOptions", this.activeCreateOptions);
+        this.eventBus.emit("sketch.create-started", {
+            tool,
+            creationMode: this.creationMode,
+            options: this.activeCreateOptions,
+        }, this);
+    }
+    complete(graphic) {
+        if (this.state !== "active" || !this.activeTool) {
+            return undefined;
+        }
+        const tool = this.activeTool;
+        const createdGraphic = graphic ?? {};
+        appendGraphic(this.layer, createdGraphic);
+        this.clearActiveState();
+        this.eventBus.emit("sketch.create-completed", {
+            tool,
+            graphic: createdGraphic,
+            layerGraphicCount: getLayerGraphics(this.layer).length,
+        }, this);
+        return {
+            state: "complete",
+            tool,
+            graphic: createdGraphic,
+        };
+    }
+    cancel() {
+        if (this.state !== "active" || !this.activeTool) {
+            return undefined;
+        }
+        const tool = this.activeTool;
+        this.clearActiveState();
+        this.eventBus.emit("sketch.create-cancelled", { tool }, this);
+        return {
+            state: "cancel",
+            tool,
+        };
+    }
+    update(graphics, options) {
+        const normalizedGraphics = normalizeGraphicsInput(graphics);
+        this.activeUpdateGraphics = [...normalizedGraphics];
+        this.notifyWatchers("activeUpdateGraphics", this.activeUpdateGraphics);
+        this.activeUpdateOptions = {
+            ...this.defaultUpdateOptions,
+            ...(options ?? {}),
+        };
+        this.notifyWatchers("activeUpdateOptions", this.activeUpdateOptions);
+        this.eventBus.emit("sketch.update-started", {
+            count: normalizedGraphics.length,
+            options: this.activeUpdateOptions,
+        }, this);
+        return this.activeUpdateGraphics;
+    }
+    delete(graphics) {
+        const targets = graphics !== undefined ? normalizeGraphicsInput(graphics) : [...this.activeUpdateGraphics];
+        let removed = 0;
+        for (const target of targets) {
+            if (removeGraphic(this.layer, target)) {
+                removed += 1;
+            }
+        }
+        if (removed > 0) {
+            this.eventBus.emit("sketch.graphics-deleted", {
+                count: removed,
+                layerGraphicCount: getLayerGraphics(this.layer).length,
+            }, this);
+        }
+        if (this.activeUpdateGraphics.length > 0) {
+            this.activeUpdateGraphics = this.activeUpdateGraphics.filter((graphic) => !targets.some((target) => target === graphic));
+            this.notifyWatchers("activeUpdateGraphics", this.activeUpdateGraphics);
+        }
+        return removed;
+    }
+    reset() {
+        this.clearActiveState();
+        this.activeUpdateGraphics = [];
+        this.notifyWatchers("activeUpdateGraphics", this.activeUpdateGraphics);
+        this.activeUpdateOptions = undefined;
+        this.notifyWatchers("activeUpdateOptions", this.activeUpdateOptions);
+        this.eventBus.emit("sketch.reset", undefined, this);
+    }
+    clearActiveState() {
+        this.state = "ready";
+        this.notifyWatchers("state", this.state);
+        this.activeTool = undefined;
+        this.notifyWatchers("activeTool", this.activeTool);
+        this.activeCreateOptions = undefined;
+        this.notifyWatchers("activeCreateOptions", this.activeCreateOptions);
+    }
+    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 normalizeGraphicsInput(graphics) {
+    return Array.isArray(graphics) ? [...graphics] : [graphics];
+}
+function appendGraphic(layer, graphic) {
+    if (!isGraphicsLayerLike(layer)) {
+        return;
+    }
+    if (typeof layer.add === "function") {
+        layer.add(graphic);
+        return;
+    }
+    if (Array.isArray(layer.graphics)) {
+        layer.graphics.push(graphic);
+    }
+}
+function removeGraphic(layer, graphic) {
+    if (!isGraphicsLayerLike(layer)) {
+        return false;
+    }
+    if (typeof layer.remove === "function") {
+        const beforeCount = getLayerGraphics(layer).length;
+        const result = layer.remove(graphic);
+        if (result !== undefined) {
+            return true;
+        }
+        return getLayerGraphics(layer).length < beforeCount;
+    }
+    if (!Array.isArray(layer.graphics)) {
+        return false;
+    }
+    const index = layer.graphics.findIndex((candidate) => candidate === graphic);
+    if (index < 0) {
+        return false;
+    }
+    layer.graphics.splice(index, 1);
+    return true;
+}
+function getLayerGraphics(layer) {
+    if (!isGraphicsLayerLike(layer) || !Array.isArray(layer.graphics)) {
+        return [];
+    }
+    return layer.graphics;
+}
+function isGraphicsLayerLike(value) {
+    return typeof value === "object" && value !== null;
+}

package/esri-compat/spatial-reference.d.ts

@@ -0,0 +1,31 @@
+export interface SpatialReferenceCompatOptions {
+    wkid?: number;
+    latestWkid?: number;
+    wkt?: string;
+    vcsWkid?: number;
+    latestVcsWkid?: number;
+}
+export type SpatialReferenceLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface SpatialReferenceHandleCompat {
+    remove(): void;
+}
+export declare class SpatialReferenceCompat {
+    loaded: boolean;
+    loadStatus: SpatialReferenceLoadStatusCompat;
+    wkid: number | undefined;
+    latestWkid: number | undefined;
+    wkt: string | undefined;
+    vcsWkid: number | undefined;
+    latestVcsWkid: number | undefined;
+    private readonly watchListeners;
+    constructor(options?: SpatialReferenceCompatOptions);
+    load(): Promise<SpatialReferenceCompat>;
+    when(callback?: (spatialReference: SpatialReferenceCompat) => void): Promise<SpatialReferenceCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): SpatialReferenceHandleCompat;
+    update(options: SpatialReferenceCompatOptions): void;
+    clone(): SpatialReferenceCompat;
+    toJSON(): SpatialReferenceCompatOptions;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=spatial-reference.d.ts.map

package/esri-compat/spatial-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatial-reference.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/spatial-reference.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,6BAA6B;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,gCAAgC,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEnF,MAAM,WAAW,4BAA4B;IAC3C,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,sBAAsB;IAC1B,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,gCAAgC,CAAC;IAC7C,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,6BAAkC;IAWjD,IAAI,IAAI,OAAO,CAAC,sBAAsB,CAAC;IAcvC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,gBAAgB,EAAE,sBAAsB,KAAK,IAAI,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAQ1G,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,4BAA4B;IAe7F,MAAM,CAAC,OAAO,EAAE,6BAA6B,GAAG,IAAI;IAuBpD,KAAK,IAAI,sBAAsB;IAI/B,MAAM,IAAI,6BAA6B;IAUvC,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/spatial-reference.js

@@ -0,0 +1,102 @@
+import { safeInvokeCompatListener } from "./event-bus.js";
+export class SpatialReferenceCompat {
+    loaded;
+    loadStatus;
+    wkid;
+    latestWkid;
+    wkt;
+    vcsWkid;
+    latestVcsWkid;
+    watchListeners;
+    constructor(options = {}) {
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.wkid = finiteNumberOrUndefined(options.wkid);
+        this.latestWkid = finiteNumberOrUndefined(options.latestWkid);
+        this.wkt = options.wkt;
+        this.vcsWkid = finiteNumberOrUndefined(options.vcsWkid);
+        this.latestVcsWkid = finiteNumberOrUndefined(options.latestVcsWkid);
+        this.watchListeners = new Map();
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        return this;
+    }
+    async when(callback) {
+        const spatialReference = await this.load();
+        if (callback) {
+            callback(spatialReference);
+        }
+        return spatialReference;
+    }
+    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);
+            },
+        };
+    }
+    update(options) {
+        if (options.wkid !== undefined) {
+            this.wkid = finiteNumberOrUndefined(options.wkid);
+            this.notifyWatchers("wkid", this.wkid);
+        }
+        if (options.latestWkid !== undefined) {
+            this.latestWkid = finiteNumberOrUndefined(options.latestWkid);
+            this.notifyWatchers("latestWkid", this.latestWkid);
+        }
+        if (options.wkt !== undefined) {
+            this.wkt = options.wkt;
+            this.notifyWatchers("wkt", this.wkt);
+        }
+        if (options.vcsWkid !== undefined) {
+            this.vcsWkid = finiteNumberOrUndefined(options.vcsWkid);
+            this.notifyWatchers("vcsWkid", this.vcsWkid);
+        }
+        if (options.latestVcsWkid !== undefined) {
+            this.latestVcsWkid = finiteNumberOrUndefined(options.latestVcsWkid);
+            this.notifyWatchers("latestVcsWkid", this.latestVcsWkid);
+        }
+    }
+    clone() {
+        return new SpatialReferenceCompat(this.toJSON());
+    }
+    toJSON() {
+        return {
+            wkid: this.wkid,
+            latestWkid: this.latestWkid,
+            wkt: this.wkt,
+            vcsWkid: this.vcsWkid,
+            latestVcsWkid: this.latestVcsWkid,
+        };
+    }
+    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 finiteNumberOrUndefined(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}

package/esri-compat/swipe.d.ts

@@ -0,0 +1,34 @@
+import { CompatEventBus } from "./event-bus.js";
+export interface SwipeCompatOptions {
+    view?: unknown;
+    container?: unknown;
+    leadingLayers?: readonly unknown[];
+    trailingLayers?: readonly unknown[];
+    position?: number;
+    eventBus?: CompatEventBus;
+}
+export type SwipeLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface SwipeHandleCompat {
+    remove(): void;
+}
+export declare class SwipeCompat {
+    readonly view: unknown;
+    readonly container: unknown;
+    readonly eventBus: CompatEventBus;
+    loaded: boolean;
+    loadStatus: SwipeLoadStatusCompat;
+    leadingLayers: unknown[];
+    trailingLayers: unknown[];
+    position: number;
+    private readonly watchListeners;
+    constructor(options?: SwipeCompatOptions);
+    load(): Promise<SwipeCompat>;
+    when(callback?: (widget: SwipeCompat) => void): Promise<SwipeCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): SwipeHandleCompat;
+    setPosition(position: number): void;
+    setLeadingLayers(layers: readonly unknown[]): void;
+    setTrailingLayers(layers: readonly unknown[]): void;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=swipe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swipe.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/swipe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAmD,MAAM,gBAAgB,CAAC;AAEjG,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACnC,cAAc,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,MAAM,MAAM,qBAAqB,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAExE,MAAM,WAAW,iBAAiB;IAChC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,WAAW;IACtB,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,qBAAqB,CAAC;IAClC,aAAa,EAAE,OAAO,EAAE,CAAC;IACzB,cAAc,EAAE,OAAO,EAAE,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,kBAAuB;IAetC,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC;IAgB5B,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC;IAQ1E,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,iBAAiB;IAelF,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAMnC,gBAAgB,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI;IAMlD,iBAAiB,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI;IAMnD,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/swipe.js

@@ -0,0 +1,93 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+export class SwipeCompat {
+    view;
+    container;
+    eventBus;
+    loaded;
+    loadStatus;
+    leadingLayers;
+    trailingLayers;
+    position;
+    watchListeners;
+    constructor(options = {}) {
+        this.view = options.view;
+        this.container = options.container;
+        this.eventBus =
+            options.eventBus ??
+                resolveCompatEventBus(options.view, options.leadingLayers, options.trailingLayers) ??
+                new CompatEventBus();
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.leadingLayers = options.leadingLayers ? [...options.leadingLayers] : [];
+        this.trailingLayers = options.trailingLayers ? [...options.trailingLayers] : [];
+        this.position = normalizePosition(options.position ?? 50);
+        this.watchListeners = new Map();
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("swipe.loading", undefined, this);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("swipe.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);
+            },
+        };
+    }
+    setPosition(position) {
+        this.position = normalizePosition(position);
+        this.notifyWatchers("position", this.position);
+        this.eventBus.emit("swipe.position-changed", { position: this.position }, this);
+    }
+    setLeadingLayers(layers) {
+        this.leadingLayers = [...layers];
+        this.notifyWatchers("leadingLayers", this.leadingLayers);
+        this.eventBus.emit("swipe.layers-changed", { side: "leading", count: this.leadingLayers.length }, this);
+    }
+    setTrailingLayers(layers) {
+        this.trailingLayers = [...layers];
+        this.notifyWatchers("trailingLayers", this.trailingLayers);
+        this.eventBus.emit("swipe.layers-changed", { side: "trailing", count: this.trailingLayers.length }, 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 normalizePosition(value) {
+    if (!Number.isFinite(value)) {
+        return 50;
+    }
+    return Math.min(100, Math.max(0, Math.trunc(value)));
+}

package/esri-compat/table-list.d.ts

@@ -0,0 +1,36 @@
+import { CompatEventBus } from "./event-bus.js";
+export interface TableListCompatOptions {
+    view?: unknown;
+    map?: unknown;
+    container?: unknown;
+    tables?: readonly unknown[];
+    eventBus?: CompatEventBus;
+    autoRefresh?: boolean;
+}
+export type TableListLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface TableListHandleCompat {
+    remove(): void;
+}
+export declare class TableListCompat {
+    readonly view: unknown;
+    readonly map: unknown;
+    readonly container: unknown;
+    readonly eventBus: CompatEventBus;
+    readonly autoRefresh: boolean;
+    loaded: boolean;
+    loadStatus: TableListLoadStatusCompat;
+    tables: unknown[];
+    private readonly subscriptions;
+    private readonly watchListeners;
+    private explicitTables;
+    constructor(options?: TableListCompatOptions);
+    load(): Promise<TableListCompat>;
+    when(callback?: (widget: TableListCompat) => void): Promise<TableListCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): TableListHandleCompat;
+    setTables(tables: readonly unknown[]): void;
+    useMapTables(): readonly unknown[];
+    refresh(): readonly unknown[];
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=table-list.d.ts.map

package/esri-compat/table-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-list.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/table-list.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAIf,MAAM,gBAAgB,CAAC;AAExB,MAAM,WAAW,sBAAsB;IACrC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC5B,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,MAAM,yBAAyB,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE5E,MAAM,WAAW,qBAAqB;IACpC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,eAAe;IAC1B,SAAgB,IAAI,EAAE,OAAO,CAAC;IAC9B,SAAgB,GAAG,EAAE,OAAO,CAAC;IAC7B,SAAgB,SAAS,EAAE,OAAO,CAAC;IACnC,SAAgB,QAAQ,EAAE,cAAc,CAAC;IACzC,SAAgB,WAAW,EAAE,OAAO,CAAC;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,yBAAyB,CAAC;IACtC,MAAM,EAAE,OAAO,EAAE,CAAC;IAEzB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA4B;IAC1D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;IAC5E,OAAO,CAAC,cAAc,CAAwB;gBAE3B,OAAO,GAAE,sBAA2B;IAwB1C,IAAI,IAAI,OAAO,CAAC,eAAe,CAAC;IAiBhC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,GAAG,OAAO,CAAC,eAAe,CAAC;IAQlF,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,qBAAqB;IAetF,SAAS,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI;IAO3C,YAAY,IAAI,SAAS,OAAO,EAAE;IAKlC,OAAO,IAAI,SAAS,OAAO,EAAE;IAY7B,OAAO,IAAI,IAAI;IAOtB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/table-list.js

@@ -0,0 +1,126 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener, } from "./event-bus.js";
+export class TableListCompat {
+    view;
+    map;
+    container;
+    eventBus;
+    autoRefresh;
+    loaded;
+    loadStatus;
+    tables;
+    subscriptions;
+    watchListeners;
+    explicitTables;
+    constructor(options = {}) {
+        this.view = options.view;
+        this.map = options.map ?? extractViewMap(options.view);
+        this.container = options.container;
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.view, options.map) ?? new CompatEventBus();
+        this.autoRefresh = options.autoRefresh ?? true;
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.explicitTables = options.tables ? [...options.tables] : undefined;
+        this.tables = this.explicitTables ? [...this.explicitTables] : extractTablesFromMap(this.map);
+        this.subscriptions = [];
+        this.watchListeners = new Map();
+        if (this.autoRefresh) {
+            this.subscriptions.push(this.eventBus.on("map.tables-changed", () => {
+                if (this.explicitTables === undefined) {
+                    this.refresh();
+                }
+            }));
+        }
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("table-list.loading", undefined, this);
+        this.refresh();
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("table-list.loaded", { count: this.tables.length }, this);
+        return this;
+    }
+    async when(callback) {
+        const widget = await this.load();
+        if (callback) {
+            callback(widget);
+        }
+        return widget;
+    }
+    watch(propertyName, listener) {
+        let listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            listeners = new Set();
+            this.watchListeners.set(propertyName, listeners);
+        }
+        listeners.add(listener);
+        return {
+            remove: () => {
+                listeners?.delete(listener);
+            },
+        };
+    }
+    setTables(tables) {
+        this.explicitTables = [...tables];
+        this.tables = [...this.explicitTables];
+        this.notifyWatchers("tables", this.tables);
+        this.eventBus.emit("table-list.tables-changed", { count: this.tables.length }, this);
+    }
+    useMapTables() {
+        this.explicitTables = undefined;
+        return this.refresh();
+    }
+    refresh() {
+        if (this.explicitTables) {
+            this.tables = [...this.explicitTables];
+        }
+        else {
+            this.tables = extractTablesFromMap(this.map);
+        }
+        this.notifyWatchers("tables", this.tables);
+        this.eventBus.emit("table-list.refreshed", { count: this.tables.length }, this);
+        return this.tables;
+    }
+    destroy() {
+        for (const subscription of this.subscriptions.splice(0)) {
+            subscription.remove();
+        }
+        this.watchListeners.clear();
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+}
+function extractViewMap(view) {
+    if (!isRecord(view)) {
+        return undefined;
+    }
+    return view.map;
+}
+function extractTablesFromMap(map) {
+    if (!isRecord(map)) {
+        return [];
+    }
+    if (Array.isArray(map.allTables)) {
+        return [...map.allTables];
+    }
+    if (Array.isArray(map.tables)) {
+        return [...map.tables];
+    }
+    return [];
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}