@honua/react 0.0.20-alpha.0

package/esri-compat/geometry-engine.js

@@ -0,0 +1,266 @@
+/**
+ * `geometryEngine` compatibility shim, backed by `@honua/geometry` (curated
+ * `@turf/*` + `proj4`).
+ *
+ * This provides drop-in replacements for the subset of
+ * `@arcgis/core/geometry/geometryEngine` operations that map onto turf:
+ * `buffer`, `intersect`, `union`, `difference`, `geodesicArea` / `planarArea`,
+ * `geodesicLength` / `planarLength`, `simplify`, `convexHull`, `contains`, and
+ * `intersects`. Inputs may be plain Esri-JSON geometries or Honua compat
+ * geometry instances (`PointCompat`, `PolygonCompat`, …) that expose `toJSON()`.
+ *
+ * Semantic caveats (see `docs/geometry.md` for the full matrix):
+ * - turf area/length/buffer are **geodesic** (great-circle). The `planar*`
+ *   variants here are computed directly in the geometry's native coordinate
+ *   plane, matching Esri's planar contract only when that CRS is projected
+ *   (e.g. Web Mercator).
+ * - `geodesic*` operations reproject the geometry to WGS84 before measuring.
+ * - `simplify` performs topological normalization (ring rewinding via the
+ *   Esri↔GeoJSON round-trip), not vertex reduction; use
+ *   `@honua/geometry`'s `simplify(geometry, tolerance)` for RDP thinning.
+ * - Uncovered `geometryEngine` operations (geodesic densify, offset, cut,
+ *   generalize, …) are intentionally not shimmed; the migration codemod keeps
+ *   its manual-intervention warning for those call sites.
+ *
+ * @module
+ */
+import { esriGeometryToGeoJSON, geoJsonToEsriGeometry } from "../core/esri-geojson.js";
+import { booleanContains, booleanIntersects, buffer as bufferOp, convex, difference as differenceOp, area as geodesicAreaOp, length as geodesicLengthOp, intersect as intersectOp, project, union as unionOp, } from "../geometry/index.js";
+const LINEAR_UNIT_METERS = {
+    meters: 1,
+    feet: 0.3048,
+    "us-feet": 1200 / 3937,
+    kilometers: 1000,
+    miles: 1609.344,
+    "nautical-miles": 1852,
+    yards: 0.9144,
+};
+const AREA_UNIT_SQUARE_METERS = {
+    "square-meters": 1,
+    "square-kilometers": 1_000_000,
+    "square-feet": 0.09290304,
+    "square-miles": 2_589_988.110336,
+    "square-yards": 0.83612736,
+    acres: 4046.8564224,
+    hectares: 10_000,
+};
+const ESRI_TO_TURF_LINEAR = {
+    meters: "meters",
+    kilometers: "kilometers",
+    miles: "miles",
+    yards: "yards",
+    feet: "feet",
+    "nautical-miles": "nauticalmiles",
+};
+function resolveEsriGeometry(input) {
+    if (input === null || input === undefined) {
+        return null;
+    }
+    if (typeof input.toJSON === "function") {
+        return input.toJSON();
+    }
+    return input;
+}
+function readSpatialReference(geometry) {
+    const sr = geometry?.spatialReference;
+    return sr && typeof sr === "object" ? sr : undefined;
+}
+/** Esri Web Mercator well-known ids (3857 and its ArcGIS aliases). */
+function isWebMercator(sr) {
+    const wkid = sr?.latestWkid ?? sr?.wkid;
+    return wkid === 3857 || wkid === 102100 || wkid === 102113 || wkid === 900913 || wkid === 3785;
+}
+/** Resolve the native EPSG code of a geometry (defaults to WGS84). */
+function nativeCrs(sr) {
+    if (isWebMercator(sr)) {
+        return 3857;
+    }
+    return sr?.latestWkid ?? sr?.wkid ?? 4326;
+}
+function toGeoJson(input) {
+    const esri = resolveEsriGeometry(input);
+    const geometry = esriGeometryToGeoJSON(esri);
+    if (!geometry) {
+        throw new TypeError("geometryEngineCompat: input is not a valid geometry");
+    }
+    return { geometry, sr: readSpatialReference(esri) };
+}
+function toEsri(geometry, sr) {
+    return geometry ? geoJsonToEsriGeometry(geometry, sr) : null;
+}
+// ── Measurement ──────────────────────────────────────────────────
+/** Geodesic (great-circle) area, reprojecting to WGS84 first. */
+export function geodesicArea(input, unit = "square-meters") {
+    const { geometry, sr } = toGeoJson(input);
+    const wgs84 = project(geometry, nativeCrs(sr), 4326);
+    const squareMeters = geodesicAreaOp(wgs84);
+    return squareMeters / AREA_UNIT_SQUARE_METERS[unit];
+}
+/** Planar area in the geometry's native coordinate plane (shoelace). */
+export function planarArea(input, unit = "square-meters") {
+    const { geometry } = toGeoJson(input);
+    const squareMeters = planarAreaSquareMeters(geometry);
+    return squareMeters / AREA_UNIT_SQUARE_METERS[unit];
+}
+/** Geodesic (great-circle) length, reprojecting to WGS84 first. */
+export function geodesicLength(input, unit = "meters") {
+    const { geometry, sr } = toGeoJson(input);
+    const wgs84 = project(geometry, nativeCrs(sr), 4326);
+    const meters = geodesicLengthOp(wgs84, "meters");
+    return meters / LINEAR_UNIT_METERS[unit];
+}
+/** Planar length/perimeter in the geometry's native coordinate plane. */
+export function planarLength(input, unit = "meters") {
+    const { geometry } = toGeoJson(input);
+    const meters = planarLengthMeters(geometry);
+    return meters / LINEAR_UNIT_METERS[unit];
+}
+function planarLengthMeters(geometry) {
+    const lineDistance = (line) => {
+        let total = 0;
+        for (let i = 1; i < line.length; i += 1) {
+            const [x0, y0] = line[i - 1];
+            const [x1, y1] = line[i];
+            total += Math.hypot(x1 - x0, y1 - y0);
+        }
+        return total;
+    };
+    switch (geometry.type) {
+        case "LineString":
+            return lineDistance(geometry.coordinates);
+        case "MultiLineString":
+            return geometry.coordinates.reduce((sum, line) => sum + lineDistance(line), 0);
+        case "Polygon":
+            return geometry.coordinates.reduce((sum, ring) => sum + lineDistance(ring), 0);
+        case "MultiPolygon":
+            return geometry.coordinates.reduce((sum, polygon) => sum + polygon.reduce((s, ring) => s + lineDistance(ring), 0), 0);
+        default:
+            return 0;
+    }
+}
+function ringArea(ring) {
+    let area = 0;
+    for (let i = 0; i < ring.length; i += 1) {
+        const [x0, y0] = ring[i];
+        const [x1, y1] = ring[(i + 1) % ring.length];
+        area += x0 * y1 - x1 * y0;
+    }
+    return Math.abs(area) / 2;
+}
+function polygonArea(rings) {
+    return rings.reduce((sum, ring, index) => (index === 0 ? sum + ringArea(ring) : sum - ringArea(ring)), 0);
+}
+function planarAreaSquareMeters(geometry) {
+    switch (geometry.type) {
+        case "Polygon":
+            return polygonArea(geometry.coordinates);
+        case "MultiPolygon":
+            return geometry.coordinates.reduce((sum, polygon) => sum + polygonArea(polygon), 0);
+        default:
+            return 0;
+    }
+}
+// ── Constructive geometry ────────────────────────────────────────
+/**
+ * Buffer a geometry by `distance` in `unit`. Backed by geodesic `@turf/buffer`
+ * (reprojected through WGS84), which differs from Esri's planar `buffer`; use
+ * this where a `geometryEngine.geodesicBuffer`-equivalent result is acceptable.
+ */
+export function buffer(input, distance, unit = "meters") {
+    const { geometry, sr } = toGeoJson(input);
+    const turfUnit = ESRI_TO_TURF_LINEAR[unit];
+    // Fall back to meters via manual scaling for units turf does not name.
+    const crs = nativeCrs(sr);
+    const wgs84 = project(geometry, crs, 4326);
+    const buffered = turfUnit
+        ? bufferOp(wgs84, distance, turfUnit)
+        : bufferOp(wgs84, distance * LINEAR_UNIT_METERS[unit], "meters");
+    if (!buffered) {
+        return null;
+    }
+    return toEsri(project(buffered, 4326, crs), sr);
+}
+/** Union of two or more geometries. Backed by `@turf/union`. */
+export function union(inputs) {
+    if (inputs.length === 0) {
+        return null;
+    }
+    const resolved = inputs.map((input) => toGeoJson(input));
+    const sr = resolved[0]?.sr;
+    const merged = unionOp(...resolved.map((entry) => entry.geometry));
+    return toEsri(merged, sr);
+}
+/** Intersection of two geometries. Backed by `@turf/intersect`. */
+export function intersect(input, intersector) {
+    const a = toGeoJson(input);
+    const b = toGeoJson(intersector);
+    return toEsri(intersectOp(a.geometry, b.geometry), a.sr);
+}
+/** Difference `input − subtractor`. Backed by `@turf/difference`. */
+export function difference(input, subtractor) {
+    const a = toGeoJson(input);
+    const b = toGeoJson(subtractor);
+    return toEsri(differenceOp(a.geometry, b.geometry), a.sr);
+}
+/**
+ * Topologically normalize a geometry (rewind rings to a valid orientation via
+ * the Esri↔GeoJSON round-trip). This mirrors `geometryEngine.simplify`'s intent
+ * of producing a topologically valid geometry rather than reducing vertices.
+ */
+export function simplify(input) {
+    const { geometry, sr } = toGeoJson(input);
+    return toEsri(geometry, sr);
+}
+/** Convex hull of a geometry. Backed by `@turf/convex`. */
+export function convexHull(input) {
+    const { geometry, sr } = toGeoJson(input);
+    return toEsri(convex(geometry), sr);
+}
+// ── Predicates ───────────────────────────────────────────────────
+/** True if `container` completely contains `inside`. Backed by `@turf/boolean-contains`. */
+export function contains(container, inside) {
+    return booleanContains(toGeoJson(container).geometry, toGeoJson(inside).geometry);
+}
+/** True if `a` and `b` intersect. Backed by `@turf/boolean-intersects`. */
+export function intersects(a, b) {
+    return booleanIntersects(toGeoJson(a).geometry, toGeoJson(b).geometry);
+}
+/**
+ * The synchronous `geometryEngine` compat surface — a namespace object shaped
+ * like `@arcgis/core/geometry/geometryEngine`. The migration codemod rewrites
+ * `import geometryEngine from "@arcgis/core/geometry/geometryEngine"` to import
+ * this object.
+ */
+export const geometryEngineCompat = {
+    buffer,
+    intersect,
+    union,
+    difference,
+    geodesicArea,
+    planarArea,
+    geodesicLength,
+    planarLength,
+    simplify,
+    convexHull,
+    contains,
+    intersects,
+};
+/**
+ * The asynchronous `geometryEngineAsync` compat surface: the same operations,
+ * each returning a `Promise`. Mirrors
+ * `@arcgis/core/geometry/geometryEngineAsync`.
+ */
+export const geometryEngineAsyncCompat = {
+    buffer: (input, distance, unit) => Promise.resolve(buffer(input, distance, unit)),
+    intersect: (input, intersector) => Promise.resolve(intersect(input, intersector)),
+    union: (inputs) => Promise.resolve(union(inputs)),
+    difference: (input, subtractor) => Promise.resolve(difference(input, subtractor)),
+    geodesicArea: (input, unit) => Promise.resolve(geodesicArea(input, unit)),
+    planarArea: (input, unit) => Promise.resolve(planarArea(input, unit)),
+    geodesicLength: (input, unit) => Promise.resolve(geodesicLength(input, unit)),
+    planarLength: (input, unit) => Promise.resolve(planarLength(input, unit)),
+    simplify: (input) => Promise.resolve(simplify(input)),
+    convexHull: (input) => Promise.resolve(convexHull(input)),
+    contains: (container, inside) => Promise.resolve(contains(container, inside)),
+    intersects: (a, b) => Promise.resolve(intersects(a, b)),
+};

package/esri-compat/graphic.d.ts

@@ -0,0 +1,46 @@
+/** Structural type for geometry-like objects (point, polyline, polygon, extent, etc.). */
+export type CompatGeometryLike = Record<string, unknown>;
+/** Structural type for symbol-like objects (marker, line, fill, text, etc.). */
+export type CompatSymbolLike = Record<string, unknown>;
+/** Structural type for popup template-like objects. */
+export type CompatPopupTemplateLike = Record<string, unknown>;
+export interface GraphicCompatOptions {
+    geometry?: CompatGeometryLike | null;
+    symbol?: CompatSymbolLike | null;
+    attributes?: Record<string, unknown>;
+    popupTemplate?: CompatPopupTemplateLike | null;
+    layer?: unknown;
+}
+export type GraphicLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface GraphicHandleCompat {
+    remove(): void;
+}
+export declare class GraphicCompat {
+    loaded: boolean;
+    loadStatus: GraphicLoadStatusCompat;
+    geometry: CompatGeometryLike | null;
+    symbol: CompatSymbolLike | null;
+    attributes: Record<string, unknown>;
+    popupTemplate: CompatPopupTemplateLike | null;
+    layer: unknown;
+    private readonly watchListeners;
+    constructor(options?: GraphicCompatOptions);
+    load(): Promise<GraphicCompat>;
+    when(callback?: (graphic: GraphicCompat) => void): Promise<GraphicCompat>;
+    watch(propertyName: "loaded", listener: (value: boolean) => void): GraphicHandleCompat;
+    watch(propertyName: "loadStatus", listener: (value: GraphicLoadStatusCompat) => void): GraphicHandleCompat;
+    watch(propertyName: "geometry", listener: (value: CompatGeometryLike | null) => void): GraphicHandleCompat;
+    watch(propertyName: "symbol", listener: (value: CompatSymbolLike | null) => void): GraphicHandleCompat;
+    watch(propertyName: "attributes", listener: (value: Record<string, unknown>) => void): GraphicHandleCompat;
+    watch(propertyName: string, listener: (value: unknown) => void): GraphicHandleCompat;
+    setGeometry(geometry: CompatGeometryLike | null): void;
+    setSymbol(symbol: CompatSymbolLike | null): void;
+    setAttributes(attributes: Record<string, unknown>): void;
+    setPopupTemplate(popupTemplate: CompatPopupTemplateLike | null): void;
+    setLayer(layer: unknown): void;
+    clone(): GraphicCompat;
+    toJSON(): Record<string, unknown>;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=graphic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphic.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/graphic.ts"],"names":[],"mappings":"AAEA,0FAA0F;AAC1F,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEzD,gFAAgF;AAChF,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEvD,uDAAuD;AACvD,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE9D,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACrC,MAAM,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,aAAa,CAAC,EAAE,uBAAuB,GAAG,IAAI,CAAC;IAC/C,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,MAAM,uBAAuB,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE1E,MAAM,WAAW,mBAAmB;IAClC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,aAAa;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,uBAAuB,CAAC;IACpC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACpC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,aAAa,EAAE,uBAAuB,GAAG,IAAI,CAAC;IAC9C,KAAK,EAAE,OAAO,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,oBAAyB;IAWxC,IAAI,IAAI,OAAO,CAAC,aAAa,CAAC;IAc9B,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC;IAQ/E,KAAK,CAAC,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,mBAAmB;IACtF,KAAK,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,IAAI,GAAG,mBAAmB;IAC1G,KAAK,CAAC,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI,KAAK,IAAI,GAAG,mBAAmB;IAC1G,KAAK,CAAC,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI,KAAK,IAAI,GAAG,mBAAmB;IACtG,KAAK,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GAAG,mBAAmB;IAC1G,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,mBAAmB;IAgBpF,WAAW,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,GAAG,IAAI;IAKtD,SAAS,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAAG,IAAI;IAKhD,aAAa,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAKxD,gBAAgB,CAAC,aAAa,EAAE,uBAAuB,GAAG,IAAI,GAAG,IAAI;IAKrE,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAK9B,KAAK,IAAI,aAAa;IAUtB,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAUjC,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/graphic.js

@@ -0,0 +1,103 @@
+import { safeInvokeCompatListener } from "./event-bus.js";
+export class GraphicCompat {
+    loaded;
+    loadStatus;
+    geometry;
+    symbol;
+    attributes;
+    popupTemplate;
+    layer;
+    watchListeners;
+    constructor(options = {}) {
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.geometry = options.geometry ?? null;
+        this.symbol = options.symbol ?? null;
+        this.attributes = options.attributes ? { ...options.attributes } : {};
+        this.popupTemplate = options.popupTemplate ?? null;
+        this.layer = options.layer;
+        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 graphic = await this.load();
+        if (callback) {
+            callback(graphic);
+        }
+        return graphic;
+    }
+    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);
+            },
+        };
+    }
+    setGeometry(geometry) {
+        this.geometry = geometry;
+        this.notifyWatchers("geometry", this.geometry);
+    }
+    setSymbol(symbol) {
+        this.symbol = symbol;
+        this.notifyWatchers("symbol", this.symbol);
+    }
+    setAttributes(attributes) {
+        this.attributes = { ...attributes };
+        this.notifyWatchers("attributes", this.attributes);
+    }
+    setPopupTemplate(popupTemplate) {
+        this.popupTemplate = popupTemplate;
+        this.notifyWatchers("popupTemplate", this.popupTemplate);
+    }
+    setLayer(layer) {
+        this.layer = layer;
+        this.notifyWatchers("layer", this.layer);
+    }
+    clone() {
+        return new GraphicCompat({
+            geometry: this.geometry,
+            symbol: this.symbol,
+            attributes: this.attributes,
+            popupTemplate: this.popupTemplate,
+            layer: this.layer,
+        });
+    }
+    toJSON() {
+        return {
+            geometry: this.geometry,
+            symbol: this.symbol,
+            attributes: { ...this.attributes },
+            popupTemplate: this.popupTemplate,
+            layer: this.layer,
+        };
+    }
+    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/graphics-layer.d.ts

@@ -0,0 +1,49 @@
+import { CompatEventBus } from "./event-bus.js";
+export interface GraphicsLayerCompatOptions {
+    id?: string;
+    title?: string;
+    graphics?: unknown[];
+    visible?: boolean;
+    opacity?: number;
+    listMode?: "show" | "hide";
+    eventBus?: CompatEventBus;
+}
+export interface GraphicsLayerQueryResult {
+    features: unknown[];
+}
+export type GraphicsLayerLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface GraphicsLayerHandleCompat {
+    remove(): void;
+}
+export declare class GraphicsLayerCompat {
+    readonly type: "graphics";
+    id: string | undefined;
+    title: string | undefined;
+    visible: boolean;
+    opacity: number;
+    listMode: "show" | "hide";
+    loaded: boolean;
+    loadStatus: GraphicsLayerLoadStatusCompat;
+    readonly eventBus: CompatEventBus;
+    private readonly graphicsInternal;
+    private readonly watchListeners;
+    private readonly eventListeners;
+    constructor(options?: GraphicsLayerCompatOptions);
+    load(): Promise<GraphicsLayerCompat>;
+    when(callback?: (layer: GraphicsLayerCompat) => void): Promise<GraphicsLayerCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): GraphicsLayerHandleCompat;
+    get graphics(): readonly unknown[];
+    add(graphic: unknown, index?: number): unknown;
+    addMany(graphics: readonly unknown[], index?: number): readonly unknown[];
+    remove(graphic: unknown): unknown | undefined;
+    removeMany(graphics: readonly unknown[]): unknown[];
+    removeAll(): void;
+    setVisibility(visible: boolean): void;
+    setOpacity(opacity: number): void;
+    queryFeatures(): Promise<GraphicsLayerQueryResult>;
+    queryFeatureCount(): Promise<number>;
+    on(eventName: string, listener: (event: unknown) => void): GraphicsLayerHandleCompat;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=graphics-layer.d.ts.map

package/esri-compat/graphics-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphics-layer.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/graphics-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAmD,MAAM,gBAAgB,CAAC;AAEjG,MAAM,WAAW,0BAA0B;IACzC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAED,MAAM,MAAM,6BAA6B,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEhF,MAAM,WAAW,yBAAyB;IACxC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,mBAAmB;IAC9B,SAAgB,IAAI,EAAE,UAAU,CAAC;IAC1B,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,6BAA6B,CAAC;IACjD,SAAgB,QAAQ,EAAE,cAAc,CAAC;IACzC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAY;IAC7C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;IAC5E,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,0BAA+B;IAe9C,IAAI,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAgBpC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAQzF,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,yBAAyB;IAejG,IAAW,QAAQ,IAAI,SAAS,OAAO,EAAE,CAExC;IAEM,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO;IAmB9C,OAAO,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,OAAO,EAAE;IA4BzE,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS;IAY7C,UAAU,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE;IAWnD,SAAS,IAAI,IAAI;IAWjB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAMrC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAM3B,aAAa,IAAI,OAAO,CAAC,wBAAwB,CAAC;IAMlD,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAI1C,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,yBAAyB;IAqBpF,OAAO,IAAI,IAAI;IAMtB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/graphics-layer.js

@@ -0,0 +1,185 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+export class GraphicsLayerCompat {
+    type;
+    id;
+    title;
+    visible;
+    opacity;
+    listMode;
+    loaded;
+    loadStatus;
+    eventBus;
+    graphicsInternal;
+    watchListeners;
+    eventListeners;
+    constructor(options = {}) {
+        this.type = "graphics";
+        this.id = options.id;
+        this.title = options.title;
+        this.visible = options.visible ?? true;
+        this.opacity = options.opacity ?? 1;
+        this.listMode = options.listMode ?? "show";
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.graphicsInternal = Array.isArray(options.graphics) ? [...options.graphics] : [];
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.graphics) ?? new CompatEventBus();
+        this.watchListeners = new Map();
+        this.eventListeners = new Map();
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("graphics-layer.loading", { layerId: this.id }, this);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("graphics-layer.loaded", { layerId: this.id }, this);
+        return this;
+    }
+    async when(callback) {
+        const layer = await this.load();
+        if (callback) {
+            callback(layer);
+        }
+        return layer;
+    }
+    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);
+            },
+        };
+    }
+    get graphics() {
+        return this.graphicsInternal;
+    }
+    add(graphic, index) {
+        if (index === undefined) {
+            this.graphicsInternal.push(graphic);
+            this.notifyWatchers("graphics", this.graphics);
+            this.eventBus.emit("graphics-layer.graphic-added", { layerId: this.id, graphic, index: this.graphicsInternal.length - 1 }, this);
+            return graphic;
+        }
+        const insertAt = normalizeInsertIndex(index, this.graphicsInternal.length);
+        this.graphicsInternal.splice(insertAt, 0, graphic);
+        this.notifyWatchers("graphics", this.graphics);
+        this.eventBus.emit("graphics-layer.graphic-added", { layerId: this.id, graphic, index: insertAt }, this);
+        return graphic;
+    }
+    addMany(graphics, index) {
+        if (graphics.length === 0) {
+            return [];
+        }
+        if (index === undefined) {
+            const startIndex = this.graphicsInternal.length;
+            this.graphicsInternal.push(...graphics);
+            this.notifyWatchers("graphics", this.graphics);
+            this.eventBus.emit("graphics-layer.graphics-added", { layerId: this.id, graphics: [...graphics], index: startIndex }, this);
+            return graphics;
+        }
+        const insertAt = normalizeInsertIndex(index, this.graphicsInternal.length);
+        this.graphicsInternal.splice(insertAt, 0, ...graphics);
+        this.notifyWatchers("graphics", this.graphics);
+        this.eventBus.emit("graphics-layer.graphics-added", { layerId: this.id, graphics: [...graphics], index: insertAt }, this);
+        return graphics;
+    }
+    remove(graphic) {
+        const index = this.graphicsInternal.indexOf(graphic);
+        if (index < 0) {
+            return undefined;
+        }
+        const [removed] = this.graphicsInternal.splice(index, 1);
+        this.notifyWatchers("graphics", this.graphics);
+        this.eventBus.emit("graphics-layer.graphic-removed", { layerId: this.id, graphic: removed, index }, this);
+        return removed;
+    }
+    removeMany(graphics) {
+        const removed = [];
+        for (const graphic of graphics) {
+            const removedGraphic = this.remove(graphic);
+            if (removedGraphic !== undefined) {
+                removed.push(removedGraphic);
+            }
+        }
+        return removed;
+    }
+    removeAll() {
+        if (this.graphicsInternal.length === 0) {
+            return;
+        }
+        const removed = [...this.graphicsInternal];
+        this.graphicsInternal.length = 0;
+        this.notifyWatchers("graphics", this.graphics);
+        this.eventBus.emit("graphics-layer.graphics-cleared", { layerId: this.id, graphics: removed }, this);
+    }
+    setVisibility(visible) {
+        this.visible = visible;
+        this.notifyWatchers("visible", this.visible);
+        this.eventBus.emit("layer.visibility-changed", { layerId: this.id, visible }, this);
+    }
+    setOpacity(opacity) {
+        this.opacity = normalizeOpacity(opacity);
+        this.notifyWatchers("opacity", this.opacity);
+        this.eventBus.emit("layer.opacity-changed", { layerId: this.id, opacity: this.opacity }, this);
+    }
+    async queryFeatures() {
+        return {
+            features: [...this.graphicsInternal],
+        };
+    }
+    async queryFeatureCount() {
+        return this.graphicsInternal.length;
+    }
+    on(eventName, listener) {
+        const namespacedEvent = `graphics-layer.${eventName}`;
+        let listeners = this.eventListeners.get(eventName);
+        if (!listeners) {
+            listeners = new Set();
+            this.eventListeners.set(eventName, listeners);
+        }
+        listeners.add(listener);
+        const subscription = this.eventBus.on(namespacedEvent, (event) => {
+            safeInvokeCompatListener(listener, event.payload);
+        });
+        return {
+            remove: () => {
+                listeners?.delete(listener);
+                subscription.remove();
+            },
+        };
+    }
+    destroy() {
+        this.watchListeners.clear();
+        this.eventListeners.clear();
+        this.eventBus.emit("graphics-layer.destroyed", { layerId: this.id }, this);
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+}
+function normalizeInsertIndex(index, length) {
+    const sanitized = Number.isFinite(index) ? Math.trunc(index) : length;
+    return Math.min(Math.max(sanitized, 0), length);
+}
+function normalizeOpacity(opacity) {
+    if (!Number.isFinite(opacity)) {
+        return 1;
+    }
+    return Math.min(Math.max(opacity, 0), 1);
+}