@honua/react 0.0.20-alpha.0

package/esri-compat/controls.js

@@ -0,0 +1,479 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener, } from "./event-bus.js";
+export class BaseControlCompat {
+    view;
+    container;
+    eventBus;
+    loaded;
+    loadStatus;
+    subscriptions;
+    watchListeners;
+    constructor(options, ...extraEventBusCandidates) {
+        this.view = options.view;
+        this.container = options.container ?? null;
+        this.eventBus =
+            options.eventBus ?? resolveCompatEventBus(options.view, ...extraEventBusCandidates) ?? new CompatEventBus();
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.watchListeners = new Map();
+        this.subscriptions = [];
+    }
+    /**
+     * Subclasses override to provide the event-name prefix used in load(), e.g.
+     * `"home"` yields `"home.loading"` / `"home.loaded"`.
+     */
+    get controlName() {
+        return "control";
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit(`${this.controlName}.loading`, undefined, this);
+        this.onLoad();
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit(`${this.controlName}.loaded`, undefined, this);
+        return this;
+    }
+    /** Hook for subclasses to perform work during load (e.g. ScaleBarCompat.refresh). */
+    onLoad() {
+        // default: no-op
+    }
+    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);
+            },
+        };
+    }
+    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);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// HomeCompat
+// ---------------------------------------------------------------------------
+export class HomeCompat extends BaseControlCompat {
+    viewpoint;
+    get controlName() {
+        return "home";
+    }
+    constructor(options = {}) {
+        super(options);
+        this.viewpoint = options.viewpoint ?? {
+            center: extractViewCenter(options.view),
+            zoom: extractViewZoom(options.view),
+        };
+    }
+    async go() {
+        const target = {
+            center: this.viewpoint.center,
+            zoom: this.viewpoint.zoom,
+        };
+        if (isGoToProvider(this.view)) {
+            await this.view.goTo(target);
+        }
+        else {
+            setViewCenterZoom(this.view, target);
+        }
+        this.eventBus.emit("home.go", target, this);
+    }
+    reset() {
+        this.viewpoint = {
+            center: extractViewCenter(this.view),
+            zoom: extractViewZoom(this.view),
+        };
+        this.notifyWatchers("viewpoint", this.viewpoint);
+        this.eventBus.emit("home.reset", this.viewpoint, this);
+    }
+}
+export class BasemapToggleCompat extends BaseControlCompat {
+    map;
+    activeBasemap;
+    nextBasemap;
+    get controlName() {
+        return "basemap-toggle";
+    }
+    constructor(options = {}) {
+        const map = options.map ?? extractViewMap(options.view);
+        super({ view: options.view, container: options.container, eventBus: options.eventBus }, map);
+        this.map = map;
+        this.activeBasemap = extractMapBasemap(this.map);
+        this.nextBasemap = options.nextBasemap;
+        this.subscriptions.push(this.eventBus.on("map.basemap-changed", (event) => {
+            this.activeBasemap = extractPayloadBasemap(event.payload);
+            this.notifyWatchers("activeBasemap", this.activeBasemap);
+        }));
+    }
+    toggle() {
+        const currentMap = this.map;
+        if (!isRecord(currentMap)) {
+            return undefined;
+        }
+        const previous = currentMap.basemap;
+        setMapBasemap(currentMap, this.nextBasemap, this.eventBus, this);
+        this.activeBasemap = extractMapBasemap(currentMap);
+        this.notifyWatchers("activeBasemap", this.activeBasemap);
+        this.nextBasemap = previous;
+        this.notifyWatchers("nextBasemap", this.nextBasemap);
+        this.eventBus.emit("basemap.toggle", {
+            activeBasemap: this.activeBasemap,
+            nextBasemap: this.nextBasemap,
+        }, this);
+        return this.activeBasemap;
+    }
+}
+export class ScaleBarCompat extends BaseControlCompat {
+    unit;
+    scale;
+    text;
+    get controlName() {
+        return "scalebar";
+    }
+    constructor(options = {}) {
+        super(options);
+        this.unit = options.unit ?? "metric";
+        this.scale = undefined;
+        this.text = "";
+        this.subscriptions.push(this.eventBus.on("view.go-to", () => {
+            this.refresh();
+        }));
+        this.refresh();
+    }
+    onLoad() {
+        this.refresh();
+    }
+    refresh() {
+        const zoom = extractViewZoom(this.view);
+        if (zoom === undefined) {
+            this.scale = undefined;
+            this.notifyWatchers("scale", this.scale);
+            this.text = "";
+            this.notifyWatchers("text", this.text);
+            return this.text;
+        }
+        const mapScale = 591657527.591555 / 2 ** zoom;
+        this.scale = mapScale;
+        this.notifyWatchers("scale", this.scale);
+        this.text = buildScaleBarText(mapScale, this.unit);
+        this.notifyWatchers("text", this.text);
+        this.eventBus.emit("scalebar.updated", { scale: mapScale, text: this.text, unit: this.unit }, this);
+        return this.text;
+    }
+}
+export class LocateCompat extends BaseControlCompat {
+    zoom;
+    lastPosition;
+    locateProvider;
+    get controlName() {
+        return "locate";
+    }
+    constructor(options = {}) {
+        super(options);
+        this.zoom = options.zoom;
+        this.lastPosition = undefined;
+        this.locateProvider = options.locateProvider ?? getDefaultLocateProvider();
+    }
+    async locate() {
+        this.eventBus.emit("locate.start", undefined, this);
+        try {
+            const position = await this.locateProvider();
+            this.lastPosition = position;
+            this.notifyWatchers("lastPosition", this.lastPosition);
+            const center = [position.coords.longitude, position.coords.latitude];
+            const target = {
+                center,
+                zoom: this.zoom,
+            };
+            if (isGoToProvider(this.view)) {
+                await this.view.goTo(target);
+            }
+            else {
+                setViewCenterZoom(this.view, target);
+            }
+            this.eventBus.emit("locate.success", {
+                position,
+                center,
+                zoom: this.zoom,
+            }, this);
+            return position;
+        }
+        catch (error) {
+            this.eventBus.emit("locate.error", { error }, this);
+            throw error;
+        }
+    }
+}
+export class CompassCompat extends BaseControlCompat {
+    orientation;
+    get controlName() {
+        return "compass";
+    }
+    constructor(options = {}) {
+        super(options);
+        this.orientation = extractViewRotation(options.view) ?? 0;
+    }
+    rotateTo(rotation) {
+        const next = Number.isFinite(rotation) ? rotation : this.orientation;
+        this.orientation = next;
+        this.notifyWatchers("orientation", this.orientation);
+        if (isRecord(this.view)) {
+            this.view.rotation = next;
+        }
+        this.eventBus.emit("compass.rotated", { rotation: next }, this);
+        return this.orientation;
+    }
+    reset() {
+        const rotation = this.rotateTo(0);
+        this.eventBus.emit("compass.reset", { rotation }, this);
+        return rotation;
+    }
+    goToNorth() {
+        return this.reset();
+    }
+}
+export class ZoomCompat extends BaseControlCompat {
+    layout;
+    get controlName() {
+        return "zoom";
+    }
+    constructor(options = {}) {
+        super(options);
+        this.layout = options.layout ?? "vertical";
+    }
+    zoomIn(step = 1) {
+        return this.adjustZoom(Math.abs(step));
+    }
+    zoomOut(step = 1) {
+        return this.adjustZoom(-Math.abs(step));
+    }
+    adjustZoom(delta) {
+        if (!isRecord(this.view) || typeof this.view.zoom !== "number" || !Number.isFinite(this.view.zoom)) {
+            return undefined;
+        }
+        const next = this.view.zoom + delta;
+        this.view.zoom = next;
+        this.notifyWatchers("zoom", next);
+        this.eventBus.emit("zoom.changed", { zoom: next, delta }, this);
+        return next;
+    }
+}
+export class FullscreenCompat extends BaseControlCompat {
+    element;
+    active;
+    get controlName() {
+        return "fullscreen";
+    }
+    constructor(options = {}) {
+        super(options);
+        this.element = options.element ?? null;
+        this.active = false;
+    }
+    enter() {
+        if (this.active) {
+            return;
+        }
+        this.active = true;
+        this.notifyWatchers("active", this.active);
+        this.eventBus.emit("fullscreen.changed", { active: true }, this);
+    }
+    exit() {
+        if (!this.active) {
+            return;
+        }
+        this.active = false;
+        this.notifyWatchers("active", this.active);
+        this.eventBus.emit("fullscreen.changed", { active: false }, this);
+    }
+    toggle(force) {
+        const next = force ?? !this.active;
+        if (next) {
+            this.enter();
+        }
+        else {
+            this.exit();
+        }
+        return this.active;
+    }
+}
+export class AttributionCompat extends BaseControlCompat {
+    map;
+    itemDelimiter;
+    attributions;
+    get controlName() {
+        return "attribution";
+    }
+    constructor(options = {}) {
+        super({ view: options.view, container: options.container, eventBus: options.eventBus }, options.map);
+        this.map = options.map ?? extractViewMap(options.view);
+        this.itemDelimiter = options.itemDelimiter ?? " | ";
+        this.attributions = options.attributions ? [...options.attributions] : [];
+    }
+    addAttribution(value) {
+        if (value.trim().length === 0) {
+            return;
+        }
+        this.attributions.push(value);
+        this.notifyWatchers("attributions", this.attributions);
+        this.notifyWatchers("text", this.getText());
+        this.eventBus.emit("attribution.updated", { count: this.attributions.length }, this);
+    }
+    removeAttribution(value) {
+        const index = this.attributions.indexOf(value);
+        if (index < 0) {
+            return false;
+        }
+        this.attributions.splice(index, 1);
+        this.notifyWatchers("attributions", this.attributions);
+        this.notifyWatchers("text", this.getText());
+        this.eventBus.emit("attribution.updated", { count: this.attributions.length }, this);
+        return true;
+    }
+    getText() {
+        if (this.attributions.length === 0) {
+            return "";
+        }
+        return this.attributions.join(this.itemDelimiter);
+    }
+}
+function isGoToProvider(value) {
+    return isRecord(value) && typeof value.goTo === "function";
+}
+function setViewCenterZoom(view, target) {
+    if (!isRecord(view)) {
+        return;
+    }
+    if (target.center !== undefined) {
+        view.center = target.center;
+    }
+    if (typeof target.zoom === "number") {
+        view.zoom = target.zoom;
+    }
+}
+function extractViewCenter(view) {
+    if (!isRecord(view)) {
+        return undefined;
+    }
+    return view.center;
+}
+function extractViewZoom(view) {
+    if (!isRecord(view) || typeof view.zoom !== "number" || !Number.isFinite(view.zoom)) {
+        return undefined;
+    }
+    return view.zoom;
+}
+function extractViewMap(view) {
+    if (!isRecord(view)) {
+        return undefined;
+    }
+    return view.map;
+}
+function extractMapBasemap(map) {
+    if (!isRecord(map)) {
+        return undefined;
+    }
+    return map.basemap;
+}
+function extractPayloadBasemap(payload) {
+    if (!isRecord(payload)) {
+        return undefined;
+    }
+    return payload.basemap;
+}
+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 isMapBasemapSetter(value) {
+    return isRecord(value) && typeof value.setBasemap === "function";
+}
+function buildScaleBarText(scale, unit) {
+    const ratioText = `1:${Math.max(1, Math.round(scale)).toLocaleString("en-US")}`;
+    if (unit === "metric") {
+        return `${ratioText} | ${formatMetricDistance(scale)}`;
+    }
+    if (unit === "imperial") {
+        return `${ratioText} | ${formatImperialDistance(scale)}`;
+    }
+    return `${ratioText} | ${formatMetricDistance(scale)} / ${formatImperialDistance(scale)}`;
+}
+function formatMetricDistance(scale) {
+    const meters = Math.max(1, Math.round(scale * 0.00028));
+    if (meters >= 1000) {
+        return `${Math.round(meters / 1000)} km`;
+    }
+    return `${meters} m`;
+}
+function formatImperialDistance(scale) {
+    const feet = Math.max(1, Math.round(scale * 0.0009186351706));
+    if (feet >= 5280) {
+        return `${Math.round(feet / 5280)} mi`;
+    }
+    return `${feet} ft`;
+}
+function getDefaultLocateProvider() {
+    return () => new Promise((resolve, reject) => {
+        const geolocation = globalThis.navigator?.geolocation;
+        if (!geolocation || typeof geolocation.getCurrentPosition !== "function") {
+            reject(new Error("Geolocation API is unavailable; provide locateProvider."));
+            return;
+        }
+        geolocation.getCurrentPosition((position) => {
+            resolve({
+                coords: {
+                    latitude: position.coords.latitude,
+                    longitude: position.coords.longitude,
+                    accuracy: position.coords.accuracy,
+                },
+            });
+        }, (error) => {
+            reject(error);
+        });
+    });
+}
+function extractViewRotation(view) {
+    if (!isRecord(view)) {
+        return undefined;
+    }
+    const rotation = view.rotation;
+    return typeof rotation === "number" && Number.isFinite(rotation) ? rotation : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/esri-compat/coordinate-conversion.d.ts

@@ -0,0 +1,41 @@
+import { CompatEventBus } from "./event-bus.js";
+export type CoordinateFormatCompat = "lonlat" | "dms" | "dd";
+export interface CoordinateConversionCompatOptions {
+    view?: unknown;
+    container?: unknown;
+    eventBus?: CompatEventBus;
+    formats?: readonly CoordinateFormatCompat[];
+    mode?: "live" | "capture";
+    multipleConversionsEnabled?: boolean;
+}
+export interface CoordinateConversionResultCompat {
+    format: CoordinateFormatCompat;
+    text: string;
+}
+export type CoordinateConversionLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface CoordinateConversionHandleCompat {
+    remove(): void;
+}
+export declare class CoordinateConversionCompat {
+    readonly view: unknown;
+    readonly container: unknown;
+    readonly eventBus: CompatEventBus;
+    loaded: boolean;
+    loadStatus: CoordinateConversionLoadStatusCompat;
+    formats: CoordinateFormatCompat[];
+    mode: "live" | "capture";
+    multipleConversionsEnabled: boolean;
+    location: [number, number] | undefined;
+    conversions: CoordinateConversionResultCompat[];
+    private readonly watchListeners;
+    constructor(options?: CoordinateConversionCompatOptions);
+    load(): Promise<CoordinateConversionCompat>;
+    when(callback?: (widget: CoordinateConversionCompat) => void): Promise<CoordinateConversionCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): CoordinateConversionHandleCompat;
+    setLocation(location: [number, number]): readonly CoordinateConversionResultCompat[];
+    addFormat(format: CoordinateFormatCompat): void;
+    removeFormat(format: CoordinateFormatCompat): boolean;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=coordinate-conversion.d.ts.map

package/esri-compat/coordinate-conversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinate-conversion.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/coordinate-conversion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAmD,MAAM,gBAAgB,CAAC;AAEjG,MAAM,MAAM,sBAAsB,GAAG,QAAQ,GAAG,KAAK,GAAG,IAAI,CAAC;AAE7D,MAAM,WAAW,iCAAiC;IAChD,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,OAAO,CAAC,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC5C,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACtC;AAED,MAAM,WAAW,gCAAgC;IAC/C,MAAM,EAAE,sBAAsB,CAAC;IAC/B,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,oCAAoC,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEvF,MAAM,WAAW,gCAAgC;IAC/C,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,0BAA0B;IACrC,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,oCAAoC,CAAC;IACjD,OAAO,EAAE,sBAAsB,EAAE,CAAC;IAClC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,0BAA0B,EAAE,OAAO,CAAC;IACpC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACvC,WAAW,EAAE,gCAAgC,EAAE,CAAC;IACvD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,iCAAsC;IAcrD,IAAI,IAAI,OAAO,CAAC,0BAA0B,CAAC;IAgB3C,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,0BAA0B,KAAK,IAAI,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAQxG,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,gCAAgC;IAejG,WAAW,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,gCAAgC,EAAE;IAapF,SAAS,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI;IAY/C,YAAY,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO;IAcrD,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/coordinate-conversion.js

@@ -0,0 +1,125 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+export class CoordinateConversionCompat {
+    view;
+    container;
+    eventBus;
+    loaded;
+    loadStatus;
+    formats;
+    mode;
+    multipleConversionsEnabled;
+    location;
+    conversions;
+    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.formats = options.formats ? [...options.formats] : ["lonlat", "dms"];
+        this.mode = options.mode ?? "live";
+        this.multipleConversionsEnabled = options.multipleConversionsEnabled ?? true;
+        this.location = undefined;
+        this.conversions = [];
+        this.watchListeners = new Map();
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("coordinate-conversion.loading", undefined, this);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("coordinate-conversion.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);
+            },
+        };
+    }
+    setLocation(location) {
+        this.location = [location[0], location[1]];
+        this.notifyWatchers("location", this.location);
+        const conversions = this.formats.map((format) => ({
+            format,
+            text: formatCoordinate(location, format),
+        }));
+        this.conversions = this.multipleConversionsEnabled ? conversions : conversions.slice(0, 1);
+        this.notifyWatchers("conversions", this.conversions);
+        this.eventBus.emit("coordinate-conversion.updated", { location: this.location }, this);
+        return this.conversions;
+    }
+    addFormat(format) {
+        if (this.formats.includes(format)) {
+            return;
+        }
+        this.formats.push(format);
+        this.notifyWatchers("formats", this.formats);
+        if (this.location) {
+            this.setLocation(this.location);
+        }
+        this.eventBus.emit("coordinate-conversion.formats-updated", { formats: [...this.formats] }, this);
+    }
+    removeFormat(format) {
+        const index = this.formats.indexOf(format);
+        if (index < 0) {
+            return false;
+        }
+        this.formats.splice(index, 1);
+        this.notifyWatchers("formats", this.formats);
+        if (this.location) {
+            this.setLocation(this.location);
+        }
+        this.eventBus.emit("coordinate-conversion.formats-updated", { formats: [...this.formats] }, this);
+        return true;
+    }
+    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 formatCoordinate(location, format) {
+    const [lon, lat] = location;
+    if (format === "lonlat" || format === "dd") {
+        return `${lat.toFixed(6)}, ${lon.toFixed(6)}`;
+    }
+    return `${toDms(lat, "N", "S")} ${toDms(lon, "E", "W")}`;
+}
+function toDms(value, positiveSuffix, negativeSuffix) {
+    const abs = Math.abs(value);
+    const degrees = Math.trunc(abs);
+    const minutesFloat = (abs - degrees) * 60;
+    const minutes = Math.trunc(minutesFloat);
+    const seconds = (minutesFloat - minutes) * 60;
+    const suffix = value >= 0 ? positiveSuffix : negativeSuffix;
+    return `${degrees}\u00B0${minutes}'${seconds.toFixed(2)}\"${suffix}`;
+}

package/esri-compat/directions.d.ts

@@ -0,0 +1,45 @@
+import { CompatEventBus } from "./event-bus.js";
+import { RouteLayerCompat, type RouteLayerCompatOptions, type RouteSolveResultCompat, type RouteStopCompat } from "./route-layer.js";
+export interface DirectionsCompatOptions {
+    view?: unknown;
+    container?: unknown;
+    layer?: RouteLayerCompat;
+    eventBus?: CompatEventBus;
+    routeProvider?: RouteLayerCompatOptions["routeProvider"];
+    stops?: readonly RouteStopCompat[];
+    useDefaultRouteLayer?: boolean;
+    showSaveAsButton?: boolean;
+}
+export interface DirectionsSolveSummaryCompat {
+    stopCount: number;
+    distanceMeters: number;
+    durationSeconds: number;
+}
+export type DirectionsLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface DirectionsHandleCompat {
+    remove(): void;
+}
+export declare class DirectionsCompat {
+    readonly view: unknown;
+    readonly container: unknown;
+    readonly eventBus: CompatEventBus;
+    loaded: boolean;
+    loadStatus: DirectionsLoadStatusCompat;
+    readonly useDefaultRouteLayer: boolean;
+    readonly showSaveAsButton: boolean;
+    readonly layer: RouteLayerCompat;
+    route: RouteSolveResultCompat | undefined;
+    private readonly watchListeners;
+    constructor(options?: DirectionsCompatOptions);
+    load(): Promise<DirectionsCompat>;
+    when(callback?: (widget: DirectionsCompat) => void): Promise<DirectionsCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): DirectionsHandleCompat;
+    setStops(stops: readonly RouteStopCompat[]): void;
+    addStop(stop: RouteStopCompat): void;
+    clearStops(): void;
+    solve(): Promise<RouteSolveResultCompat | undefined>;
+    getSummary(): DirectionsSolveSummaryCompat | undefined;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=directions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"directions.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/directions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAmD,MAAM,gBAAgB,CAAC;AACjG,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,aAAa,CAAC,EAAE,uBAAuB,CAAC,eAAe,CAAC,CAAC;IACzD,KAAK,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;IACnC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,4BAA4B;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,0BAA0B,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE7E,MAAM,WAAW,sBAAsB;IACrC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,gBAAgB;IAC3B,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,0BAA0B,CAAC;IAC9C,SAAgB,oBAAoB,EAAE,OAAO,CAAC;IAC9C,SAAgB,gBAAgB,EAAE,OAAO,CAAC;IAC1C,SAAgB,KAAK,EAAE,gBAAgB,CAAC;IACjC,KAAK,EAAE,sBAAsB,GAAG,SAAS,CAAC;IACjD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,uBAA4B;IAmB3C,IAAI,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAiBjC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAQpF,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,sBAAsB;IAevF,QAAQ,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,GAAG,IAAI;IAOjD,OAAO,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI;IAMpC,UAAU,IAAI,IAAI;IAQZ,KAAK,IAAI,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC;IAgB1D,UAAU,IAAI,4BAA4B,GAAG,SAAS;IAWtD,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}