@honua/react 0.0.20-alpha.0

package/esri-compat/basemap-layer-list.js

@@ -0,0 +1,139 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener, } from "./event-bus.js";
+export class BasemapLayerListCompat {
+    view;
+    map;
+    container;
+    eventBus;
+    autoRefresh;
+    loaded;
+    loadStatus;
+    basemap;
+    baseLayers;
+    referenceLayers;
+    subscriptions;
+    watchListeners;
+    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.basemap = undefined;
+        this.baseLayers = [];
+        this.referenceLayers = [];
+        this.subscriptions = [];
+        this.watchListeners = new Map();
+        this.refresh();
+        if (this.autoRefresh) {
+            this.subscriptions.push(this.eventBus.on("map.basemap-changed", () => this.refresh()));
+            this.subscriptions.push(this.eventBus.on("basemap.toggle", () => this.refresh()));
+        }
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("basemap-layer-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("basemap-layer-list.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);
+            },
+        };
+    }
+    refresh() {
+        const basemap = extractMapBasemap(this.map);
+        this.basemap = basemap;
+        this.notifyWatchers("basemap", this.basemap);
+        this.baseLayers = extractBasemapLayerCollection(basemap, "baseLayers");
+        this.notifyWatchers("baseLayers", this.baseLayers);
+        this.referenceLayers = extractBasemapLayerCollection(basemap, "referenceLayers");
+        this.notifyWatchers("referenceLayers", this.referenceLayers);
+        this.eventBus.emit("basemap-layer-list.refreshed", {
+            basemap: this.basemap,
+            baseLayerCount: this.baseLayers.length,
+            referenceLayerCount: this.referenceLayers.length,
+        }, this);
+        return [...this.baseLayers, ...this.referenceLayers];
+    }
+    setBasemap(basemap) {
+        setMapBasemap(this.map, basemap, this.eventBus, this);
+        this.refresh();
+    }
+    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 setMapBasemap(map, basemap, eventBus, source) {
+    if (!isRecord(map)) {
+        return;
+    }
+    if (isMapBasemapSetter(map)) {
+        map.setBasemap(basemap);
+        return;
+    }
+    map.basemap = basemap;
+    eventBus.emit("map.basemap-changed", { basemap }, source);
+}
+function extractMapBasemap(map) {
+    if (!isRecord(map)) {
+        return undefined;
+    }
+    return map.basemap;
+}
+function extractBasemapLayerCollection(basemap, key) {
+    if (!isRecord(basemap)) {
+        return [];
+    }
+    const value = basemap[key];
+    return Array.isArray(value) ? [...value] : [];
+}
+function extractViewMap(view) {
+    if (!isRecord(view)) {
+        return undefined;
+    }
+    return view.map;
+}
+function isMapBasemapSetter(value) {
+    return isRecord(value) && typeof value.setBasemap === "function";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/esri-compat/basemap.d.ts

@@ -0,0 +1,32 @@
+import { CompatEventBus } from "./event-bus.js";
+export interface BasemapCompatOptions {
+    id?: string;
+    title?: string;
+    baseLayers?: readonly unknown[];
+    referenceLayers?: readonly unknown[];
+    eventBus?: CompatEventBus;
+}
+export type BasemapLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface BasemapHandleCompat {
+    remove(): void;
+}
+export declare class BasemapCompat {
+    readonly eventBus: CompatEventBus;
+    id: string | undefined;
+    title: string | undefined;
+    baseLayers: unknown[];
+    referenceLayers: unknown[];
+    loaded: boolean;
+    loadStatus: BasemapLoadStatusCompat;
+    private readonly watchListeners;
+    constructor(options?: BasemapCompatOptions);
+    static fromId(id: string): BasemapCompat;
+    setBaseLayers(layers: readonly unknown[]): void;
+    setReferenceLayers(layers: readonly unknown[]): void;
+    load(): Promise<BasemapCompat>;
+    when(callback?: (basemap: BasemapCompat) => void): Promise<BasemapCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): BasemapHandleCompat;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=basemap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"basemap.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/basemap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAmD,MAAM,gBAAgB,CAAC;AAEjG,MAAM,WAAW,oBAAoB;IACnC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAChC,eAAe,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACrC,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,QAAQ,EAAE,cAAc,CAAC;IAClC,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,UAAU,EAAE,OAAO,EAAE,CAAC;IACtB,eAAe,EAAE,OAAO,EAAE,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,uBAAuB,CAAC;IAC3C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,oBAAyB;WAYvC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa;IAOxC,aAAa,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI;IAM/C,kBAAkB,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI;IAM9C,IAAI,IAAI,OAAO,CAAC,aAAa,CAAC;IAgB9B,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC;IAQ/E,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,mBAAmB;IAepF,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/basemap.js

@@ -0,0 +1,84 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+export class BasemapCompat {
+    eventBus;
+    id;
+    title;
+    baseLayers;
+    referenceLayers;
+    loaded;
+    loadStatus;
+    watchListeners;
+    constructor(options = {}) {
+        this.eventBus =
+            options.eventBus ?? resolveCompatEventBus(options.baseLayers, options.referenceLayers) ?? new CompatEventBus();
+        this.id = options.id;
+        this.title = options.title ?? options.id;
+        this.baseLayers = options.baseLayers ? [...options.baseLayers] : [];
+        this.referenceLayers = options.referenceLayers ? [...options.referenceLayers] : [];
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.watchListeners = new Map();
+    }
+    static fromId(id) {
+        return new BasemapCompat({
+            id,
+            title: id,
+        });
+    }
+    setBaseLayers(layers) {
+        this.baseLayers = [...layers];
+        this.notifyWatchers("baseLayers", this.baseLayers);
+        this.eventBus.emit("basemap.base-layers-changed", { count: this.baseLayers.length }, this);
+    }
+    setReferenceLayers(layers) {
+        this.referenceLayers = [...layers];
+        this.notifyWatchers("referenceLayers", this.referenceLayers);
+        this.eventBus.emit("basemap.reference-layers-changed", { count: this.referenceLayers.length }, this);
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("basemap.loading", { id: this.id }, this);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("basemap.loaded", { id: this.id }, this);
+        return this;
+    }
+    async when(callback) {
+        const basemap = await this.load();
+        if (callback) {
+            callback(basemap);
+        }
+        return basemap;
+    }
+    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);
+            },
+        };
+    }
+    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/bookmarks.d.ts

@@ -0,0 +1,36 @@
+import { CompatEventBus } from "./event-bus.js";
+export interface BookmarkCompatItem {
+    name: string;
+    viewpoint?: unknown;
+    target?: unknown;
+}
+export interface BookmarksCompatOptions {
+    view?: unknown;
+    container?: unknown;
+    bookmarks?: readonly BookmarkCompatItem[];
+    eventBus?: CompatEventBus;
+}
+export type BookmarksLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface BookmarksHandleCompat {
+    remove(): void;
+}
+export declare class BookmarksCompat {
+    readonly view: unknown;
+    readonly container: unknown;
+    readonly eventBus: CompatEventBus;
+    loaded: boolean;
+    loadStatus: BookmarksLoadStatusCompat;
+    bookmarks: BookmarkCompatItem[];
+    activeBookmark: BookmarkCompatItem | undefined;
+    private readonly watchListeners;
+    constructor(options?: BookmarksCompatOptions);
+    load(): Promise<BookmarksCompat>;
+    when(callback?: (widget: BookmarksCompat) => void): Promise<BookmarksCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): BookmarksHandleCompat;
+    add(bookmark: BookmarkCompatItem): void;
+    remove(nameOrBookmark: string | BookmarkCompatItem): boolean;
+    goTo(nameOrBookmark: string | BookmarkCompatItem): Promise<BookmarkCompatItem | undefined>;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=bookmarks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bookmarks.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/bookmarks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAmD,MAAM,gBAAgB,CAAC;AAEjG,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC1C,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;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,SAAS,EAAE,OAAO,CAAC;IACnC,SAAgB,QAAQ,EAAE,cAAc,CAAC;IAClC,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,yBAAyB,CAAC;IACtC,SAAS,EAAE,kBAAkB,EAAE,CAAC;IAChC,cAAc,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACtD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,sBAA2B;IAW1C,IAAI,IAAI,OAAO,CAAC,eAAe,CAAC;IAgBhC,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,GAAG,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI;IAMvC,MAAM,CAAC,cAAc,EAAE,MAAM,GAAG,kBAAkB,GAAG,OAAO;IAmBtD,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAAC;IAiBhG,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/bookmarks.js

@@ -0,0 +1,108 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+export class BookmarksCompat {
+    view;
+    container;
+    eventBus;
+    loaded;
+    loadStatus;
+    bookmarks;
+    activeBookmark;
+    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.bookmarks = options.bookmarks ? [...options.bookmarks] : [];
+        this.activeBookmark = undefined;
+        this.watchListeners = new Map();
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("bookmarks.loading", undefined, this);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("bookmarks.loaded", { bookmarkCount: this.bookmarks.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);
+            },
+        };
+    }
+    add(bookmark) {
+        this.bookmarks.push(bookmark);
+        this.notifyWatchers("bookmarks", this.bookmarks);
+        this.eventBus.emit("bookmarks.updated", { bookmarkCount: this.bookmarks.length }, this);
+    }
+    remove(nameOrBookmark) {
+        const index = typeof nameOrBookmark === "string"
+            ? this.bookmarks.findIndex((bookmark) => bookmark.name === nameOrBookmark)
+            : this.bookmarks.indexOf(nameOrBookmark);
+        if (index < 0) {
+            return false;
+        }
+        const [removed] = this.bookmarks.splice(index, 1);
+        this.notifyWatchers("bookmarks", this.bookmarks);
+        if (this.activeBookmark === removed) {
+            this.activeBookmark = undefined;
+            this.notifyWatchers("activeBookmark", this.activeBookmark);
+        }
+        this.eventBus.emit("bookmarks.updated", { bookmarkCount: this.bookmarks.length }, this);
+        return true;
+    }
+    async goTo(nameOrBookmark) {
+        const bookmark = typeof nameOrBookmark === "string" ? this.bookmarks.find((item) => item.name === nameOrBookmark) : nameOrBookmark;
+        if (!bookmark) {
+            return undefined;
+        }
+        this.activeBookmark = bookmark;
+        this.notifyWatchers("activeBookmark", this.activeBookmark);
+        const target = bookmark.viewpoint ?? bookmark.target;
+        if (target !== undefined && isGoToProvider(this.view)) {
+            await this.view.goTo(target);
+        }
+        this.eventBus.emit("bookmarks.go-to", { bookmark }, this);
+        return bookmark;
+    }
+    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 isGoToProvider(value) {
+    return isRecord(value) && typeof value.goTo === "function";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/esri-compat/class-breaks-renderer.d.ts

@@ -0,0 +1,50 @@
+export interface ClassBreakInfoCompat {
+    maxValue: number;
+    minValue?: number;
+    symbol?: unknown;
+    label?: string;
+    description?: string;
+}
+export interface ClassBreaksRendererCompatOptions {
+    field?: string;
+    normalizationField?: string;
+    normalizationTotal?: number;
+    minValue?: number;
+    defaultSymbol?: unknown;
+    defaultLabel?: string;
+    legendOptions?: unknown;
+    valueExpression?: string;
+    valueExpressionTitle?: string;
+    classBreakInfos?: ClassBreakInfoCompat[];
+}
+export type ClassBreaksRendererLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface ClassBreaksRendererHandleCompat {
+    remove(): void;
+}
+export declare class ClassBreaksRendererCompat {
+    loaded: boolean;
+    loadStatus: ClassBreaksRendererLoadStatusCompat;
+    field: string | undefined;
+    normalizationField: string | undefined;
+    normalizationTotal: number | undefined;
+    minValue: number | undefined;
+    defaultSymbol: unknown;
+    defaultLabel: string | undefined;
+    legendOptions: unknown;
+    valueExpression: string | undefined;
+    valueExpressionTitle: string | undefined;
+    classBreakInfos: ClassBreakInfoCompat[];
+    private readonly watchListeners;
+    constructor(options?: ClassBreaksRendererCompatOptions);
+    load(): Promise<ClassBreaksRendererCompat>;
+    when(callback?: (renderer: ClassBreaksRendererCompat) => void): Promise<ClassBreaksRendererCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): ClassBreaksRendererHandleCompat;
+    update(options: ClassBreaksRendererCompatOptions): void;
+    addClassBreakInfo(info: ClassBreakInfoCompat): void;
+    removeClassBreakInfo(maxValue: number): boolean;
+    clone(): ClassBreaksRendererCompat;
+    toJSON(): ClassBreaksRendererCompatOptions;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=class-breaks-renderer.d.ts.map

package/esri-compat/class-breaks-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-breaks-renderer.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/class-breaks-renderer.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,gCAAgC;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,eAAe,CAAC,EAAE,oBAAoB,EAAE,CAAC;CAC1C;AAED,MAAM,MAAM,mCAAmC,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEtF,MAAM,WAAW,+BAA+B;IAC9C,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,yBAAyB;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,mCAAmC,CAAC;IAChD,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,aAAa,EAAE,OAAO,CAAC;IACvB,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,eAAe,EAAE,oBAAoB,EAAE,CAAC;IAC/C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,gCAAqC;IAoBpD,IAAI,IAAI,OAAO,CAAC,yBAAyB,CAAC;IAc1C,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,yBAAyB,KAAK,IAAI,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAQxG,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,+BAA+B;IAehG,MAAM,CAAC,OAAO,EAAE,gCAAgC,GAAG,IAAI;IA+CvD,iBAAiB,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI;IAKnD,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAW/C,KAAK,IAAI,yBAAyB;IAIlC,MAAM,IAAI,gCAAgC;IAe1C,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/class-breaks-renderer.js

@@ -0,0 +1,164 @@
+import { safeInvokeCompatListener } from "./event-bus.js";
+export class ClassBreaksRendererCompat {
+    loaded;
+    loadStatus;
+    field;
+    normalizationField;
+    normalizationTotal;
+    minValue;
+    defaultSymbol;
+    defaultLabel;
+    legendOptions;
+    valueExpression;
+    valueExpressionTitle;
+    classBreakInfos;
+    watchListeners;
+    constructor(options = {}) {
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.field = options.field;
+        this.normalizationField = options.normalizationField;
+        this.normalizationTotal =
+            typeof options.normalizationTotal === "number" && Number.isFinite(options.normalizationTotal)
+                ? options.normalizationTotal
+                : undefined;
+        this.minValue =
+            typeof options.minValue === "number" && Number.isFinite(options.minValue) ? options.minValue : undefined;
+        this.defaultSymbol = options.defaultSymbol;
+        this.defaultLabel = options.defaultLabel;
+        this.legendOptions = options.legendOptions;
+        this.valueExpression = options.valueExpression;
+        this.valueExpressionTitle = options.valueExpressionTitle;
+        this.classBreakInfos = options.classBreakInfos ? options.classBreakInfos.map(cloneClassBreakInfo) : [];
+        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 renderer = await this.load();
+        if (callback) {
+            callback(renderer);
+        }
+        return renderer;
+    }
+    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.field !== undefined) {
+            this.field = options.field;
+            this.notifyWatchers("field", this.field);
+        }
+        if (options.normalizationField !== undefined) {
+            this.normalizationField = options.normalizationField;
+            this.notifyWatchers("normalizationField", this.normalizationField);
+        }
+        if (options.normalizationTotal !== undefined) {
+            this.normalizationTotal =
+                typeof options.normalizationTotal === "number" && Number.isFinite(options.normalizationTotal)
+                    ? options.normalizationTotal
+                    : undefined;
+            this.notifyWatchers("normalizationTotal", this.normalizationTotal);
+        }
+        if (options.minValue !== undefined) {
+            this.minValue =
+                typeof options.minValue === "number" && Number.isFinite(options.minValue) ? options.minValue : undefined;
+            this.notifyWatchers("minValue", this.minValue);
+        }
+        if (options.defaultSymbol !== undefined) {
+            this.defaultSymbol = options.defaultSymbol;
+            this.notifyWatchers("defaultSymbol", this.defaultSymbol);
+        }
+        if (options.defaultLabel !== undefined) {
+            this.defaultLabel = options.defaultLabel;
+            this.notifyWatchers("defaultLabel", this.defaultLabel);
+        }
+        if (options.legendOptions !== undefined) {
+            this.legendOptions = options.legendOptions;
+            this.notifyWatchers("legendOptions", this.legendOptions);
+        }
+        if (options.valueExpression !== undefined) {
+            this.valueExpression = options.valueExpression;
+            this.notifyWatchers("valueExpression", this.valueExpression);
+        }
+        if (options.valueExpressionTitle !== undefined) {
+            this.valueExpressionTitle = options.valueExpressionTitle;
+            this.notifyWatchers("valueExpressionTitle", this.valueExpressionTitle);
+        }
+        if (options.classBreakInfos !== undefined) {
+            this.classBreakInfos = options.classBreakInfos.map(cloneClassBreakInfo);
+            this.notifyWatchers("classBreakInfos", this.classBreakInfos);
+        }
+    }
+    addClassBreakInfo(info) {
+        this.classBreakInfos.push(cloneClassBreakInfo(info));
+        this.notifyWatchers("classBreakInfos", this.classBreakInfos);
+    }
+    removeClassBreakInfo(maxValue) {
+        const index = this.classBreakInfos.findIndex((item) => item.maxValue === maxValue);
+        if (index < 0) {
+            return false;
+        }
+        this.classBreakInfos.splice(index, 1);
+        this.notifyWatchers("classBreakInfos", this.classBreakInfos);
+        return true;
+    }
+    clone() {
+        return new ClassBreaksRendererCompat(this.toJSON());
+    }
+    toJSON() {
+        return {
+            field: this.field,
+            normalizationField: this.normalizationField,
+            normalizationTotal: this.normalizationTotal,
+            minValue: this.minValue,
+            defaultSymbol: this.defaultSymbol,
+            defaultLabel: this.defaultLabel,
+            legendOptions: this.legendOptions,
+            valueExpression: this.valueExpression,
+            valueExpressionTitle: this.valueExpressionTitle,
+            classBreakInfos: this.classBreakInfos.map(cloneClassBreakInfo),
+        };
+    }
+    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 cloneClassBreakInfo(info) {
+    return {
+        maxValue: info.maxValue,
+        minValue: info.minValue,
+        symbol: info.symbol,
+        label: info.label,
+        description: info.description,
+    };
+}

package/esri-compat/color.d.ts

@@ -0,0 +1,22 @@
+export type ColorCompatInput = string | number[] | Record<string, unknown>;
+export type ColorLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface ColorHandleCompat {
+    remove(): void;
+}
+export declare class ColorCompat {
+    loaded: boolean;
+    loadStatus: ColorLoadStatusCompat;
+    private value;
+    private readonly watchListeners;
+    constructor(input?: ColorCompatInput);
+    load(): Promise<ColorCompat>;
+    when(callback?: (color: ColorCompat) => void): Promise<ColorCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): ColorHandleCompat;
+    set(input: ColorCompatInput): void;
+    clone(): ColorCompat;
+    toJSON(): ColorCompatInput;
+    toCss(includeAlpha?: boolean): string;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=color.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/color.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE3E,MAAM,MAAM,qBAAqB,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAExE,MAAM,WAAW,iBAAiB;IAChC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,WAAW;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,qBAAqB,CAAC;IACzC,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,KAAK,GAAE,gBAA+B;IAO5C,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC;IAc5B,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC;IAQzE,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,iBAAiB;IAelF,GAAG,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAKlC,KAAK,IAAI,WAAW;IAIpB,MAAM,IAAI,gBAAgB;IAU1B,KAAK,CAAC,YAAY,UAAO,GAAG,MAAM;IAwBlC,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}