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

package/esri-compat/track.d.ts

@@ -0,0 +1,51 @@
+import { CompatEventBus } from "./event-bus.js";
+export interface TrackPositionCompat {
+    coords: {
+        latitude: number;
+        longitude: number;
+        accuracy?: number;
+        heading?: number | null;
+        speed?: number | null;
+    };
+    timestamp?: number;
+}
+export interface TrackCompatOptions {
+    view?: unknown;
+    container?: unknown;
+    eventBus?: CompatEventBus;
+    tracking?: boolean;
+    goToLocationEnabled?: boolean;
+    useHeadingEnabled?: boolean;
+    rotationEnabled?: boolean;
+    scale?: number;
+    trackProvider?: () => Promise<TrackPositionCompat>;
+}
+export type TrackLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface TrackHandleCompat {
+    remove(): void;
+}
+export declare class TrackCompat {
+    readonly view: unknown;
+    readonly container: unknown;
+    readonly eventBus: CompatEventBus;
+    loaded: boolean;
+    loadStatus: TrackLoadStatusCompat;
+    tracking: boolean;
+    readonly goToLocationEnabled: boolean;
+    readonly useHeadingEnabled: boolean;
+    readonly rotationEnabled: boolean;
+    readonly scale: number | undefined;
+    position: TrackPositionCompat | undefined;
+    private readonly watchListeners;
+    private readonly trackProvider;
+    constructor(options?: TrackCompatOptions);
+    load(): Promise<TrackCompat>;
+    when(callback?: (widget: TrackCompat) => void): Promise<TrackCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): TrackHandleCompat;
+    start(): Promise<TrackPositionCompat>;
+    stop(): void;
+    toggle(force?: boolean): Promise<boolean>;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=track.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"track.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/track.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAmD,MAAM,gBAAgB,CAAC;AAEjG,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACxB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KACvB,CAAC;IACF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACpD;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,QAAQ,EAAE,OAAO,CAAC;IACzB,SAAgB,mBAAmB,EAAE,OAAO,CAAC;IAC7C,SAAgB,iBAAiB,EAAE,OAAO,CAAC;IAC3C,SAAgB,eAAe,EAAE,OAAO,CAAC;IACzC,SAAgB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,QAAQ,EAAE,mBAAmB,GAAG,SAAS,CAAC;IACjD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;IAE5E,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;gBAEhD,OAAO,GAAE,kBAAuB;IAgBtC,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;IAe5E,KAAK,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAoD3C,IAAI,IAAI,IAAI;IASN,MAAM,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAW/C,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/track.js

@@ -0,0 +1,174 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+export class TrackCompat {
+    view;
+    container;
+    eventBus;
+    loaded;
+    loadStatus;
+    tracking;
+    goToLocationEnabled;
+    useHeadingEnabled;
+    rotationEnabled;
+    scale;
+    position;
+    watchListeners;
+    trackProvider;
+    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.tracking = options.tracking ?? false;
+        this.goToLocationEnabled = options.goToLocationEnabled ?? true;
+        this.useHeadingEnabled = options.useHeadingEnabled ?? false;
+        this.rotationEnabled = options.rotationEnabled ?? false;
+        this.scale = options.scale;
+        this.position = undefined;
+        this.trackProvider = options.trackProvider ?? getDefaultTrackProvider();
+        this.watchListeners = new Map();
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("track.loading", undefined, this);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("track.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);
+            },
+        };
+    }
+    async start() {
+        this.tracking = true;
+        this.notifyWatchers("tracking", this.tracking);
+        this.eventBus.emit("track.start", undefined, this);
+        try {
+            const position = await this.trackProvider();
+            this.position = position;
+            this.notifyWatchers("position", this.position);
+            const center = [position.coords.longitude, position.coords.latitude];
+            if (this.goToLocationEnabled) {
+                const target = { center };
+                if (typeof this.scale === "number" && Number.isFinite(this.scale)) {
+                    target.scale = this.scale;
+                }
+                if (isGoToProvider(this.view)) {
+                    await this.view.goTo(target);
+                }
+                else {
+                    applyViewCenterScale(this.view, target);
+                }
+            }
+            if (this.rotationEnabled &&
+                this.useHeadingEnabled &&
+                typeof position.coords.heading === "number" &&
+                Number.isFinite(position.coords.heading) &&
+                isRecord(this.view)) {
+                this.view.rotation = position.coords.heading;
+            }
+            this.eventBus.emit("track.position", {
+                position,
+                center,
+                tracking: this.tracking,
+            }, this);
+            return position;
+        }
+        catch (error) {
+            this.tracking = false;
+            this.notifyWatchers("tracking", this.tracking);
+            this.eventBus.emit("track.error", { error }, this);
+            throw error;
+        }
+    }
+    stop() {
+        if (!this.tracking) {
+            return;
+        }
+        this.tracking = false;
+        this.notifyWatchers("tracking", this.tracking);
+        this.eventBus.emit("track.stop", undefined, this);
+    }
+    async toggle(force) {
+        const next = force ?? !this.tracking;
+        if (!next) {
+            this.stop();
+            return this.tracking;
+        }
+        await this.start();
+        return this.tracking;
+    }
+    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 applyViewCenterScale(view, target) {
+    if (!isRecord(view)) {
+        return;
+    }
+    view.center = target.center;
+    if (typeof target.scale === "number") {
+        view.scale = target.scale;
+    }
+}
+function getDefaultTrackProvider() {
+    return () => new Promise((resolve, reject) => {
+        const geolocation = globalThis.navigator?.geolocation;
+        if (!geolocation || typeof geolocation.getCurrentPosition !== "function") {
+            reject(new Error("Geolocation API is unavailable; provide trackProvider."));
+            return;
+        }
+        geolocation.getCurrentPosition((position) => {
+            resolve({
+                coords: {
+                    latitude: position.coords.latitude,
+                    longitude: position.coords.longitude,
+                    accuracy: position.coords.accuracy,
+                    heading: position.coords.heading,
+                    speed: position.coords.speed,
+                },
+                timestamp: position.timestamp,
+            });
+        }, (error) => {
+            reject(error);
+        });
+    });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/esri-compat/unique-value-renderer.d.ts

@@ -0,0 +1,41 @@
+export interface UniqueValueInfoCompat {
+    value: string | number;
+    symbol?: unknown;
+    label?: string;
+    description?: string;
+}
+export interface UniqueValueRendererCompatOptions {
+    field?: string;
+    field2?: string;
+    field3?: string;
+    defaultSymbol?: unknown;
+    defaultLabel?: string;
+    uniqueValueInfos?: UniqueValueInfoCompat[];
+}
+export type UniqueValueRendererLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface UniqueValueRendererHandleCompat {
+    remove(): void;
+}
+export declare class UniqueValueRendererCompat {
+    loaded: boolean;
+    loadStatus: UniqueValueRendererLoadStatusCompat;
+    field: string | undefined;
+    field2: string | undefined;
+    field3: string | undefined;
+    defaultSymbol: unknown;
+    defaultLabel: string | undefined;
+    uniqueValueInfos: UniqueValueInfoCompat[];
+    private readonly watchListeners;
+    constructor(options?: UniqueValueRendererCompatOptions);
+    load(): Promise<UniqueValueRendererCompat>;
+    when(callback?: (renderer: UniqueValueRendererCompat) => void): Promise<UniqueValueRendererCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): UniqueValueRendererHandleCompat;
+    update(options: UniqueValueRendererCompatOptions): void;
+    addUniqueValueInfo(info: UniqueValueInfoCompat): void;
+    removeUniqueValueInfo(value: string | number): boolean;
+    clone(): UniqueValueRendererCompat;
+    toJSON(): UniqueValueRendererCompatOptions;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=unique-value-renderer.d.ts.map

package/esri-compat/unique-value-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique-value-renderer.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/unique-value-renderer.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,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,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,qBAAqB,EAAE,CAAC;CAC5C;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,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,aAAa,EAAE,OAAO,CAAC;IACvB,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,gBAAgB,EAAE,qBAAqB,EAAE,CAAC;IACjD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,gCAAqC;IAYpD,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;IA2BvD,kBAAkB,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI;IAKrD,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;IAUtD,KAAK,IAAI,yBAAyB;IAIlC,MAAM,IAAI,gCAAgC;IAW1C,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/unique-value-renderer.js

@@ -0,0 +1,127 @@
+import { safeInvokeCompatListener } from "./event-bus.js";
+export class UniqueValueRendererCompat {
+    loaded;
+    loadStatus;
+    field;
+    field2;
+    field3;
+    defaultSymbol;
+    defaultLabel;
+    uniqueValueInfos;
+    watchListeners;
+    constructor(options = {}) {
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.field = options.field;
+        this.field2 = options.field2;
+        this.field3 = options.field3;
+        this.defaultSymbol = options.defaultSymbol;
+        this.defaultLabel = options.defaultLabel;
+        this.uniqueValueInfos = options.uniqueValueInfos ? options.uniqueValueInfos.map(cloneUniqueValueInfo) : [];
+        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.field2 !== undefined) {
+            this.field2 = options.field2;
+            this.notifyWatchers("field2", this.field2);
+        }
+        if (options.field3 !== undefined) {
+            this.field3 = options.field3;
+            this.notifyWatchers("field3", this.field3);
+        }
+        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.uniqueValueInfos !== undefined) {
+            this.uniqueValueInfos = options.uniqueValueInfos.map(cloneUniqueValueInfo);
+            this.notifyWatchers("uniqueValueInfos", this.uniqueValueInfos);
+        }
+    }
+    addUniqueValueInfo(info) {
+        this.uniqueValueInfos.push(cloneUniqueValueInfo(info));
+        this.notifyWatchers("uniqueValueInfos", this.uniqueValueInfos);
+    }
+    removeUniqueValueInfo(value) {
+        const index = this.uniqueValueInfos.findIndex((item) => item.value === value);
+        if (index < 0) {
+            return false;
+        }
+        this.uniqueValueInfos.splice(index, 1);
+        this.notifyWatchers("uniqueValueInfos", this.uniqueValueInfos);
+        return true;
+    }
+    clone() {
+        return new UniqueValueRendererCompat(this.toJSON());
+    }
+    toJSON() {
+        return {
+            field: this.field,
+            field2: this.field2,
+            field3: this.field3,
+            defaultSymbol: this.defaultSymbol,
+            defaultLabel: this.defaultLabel,
+            uniqueValueInfos: this.uniqueValueInfos.map(cloneUniqueValueInfo),
+        };
+    }
+    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 cloneUniqueValueInfo(info) {
+    return {
+        value: info.value,
+        symbol: info.symbol,
+        label: info.label,
+        description: info.description,
+    };
+}

package/esri-compat/url.d.ts

@@ -0,0 +1,12 @@
+export interface ParsedFeatureLayerUrl {
+    baseUrl: string;
+    serviceId: string;
+    layerId: number;
+}
+export interface ParsedMapServiceUrl {
+    baseUrl: string;
+    serviceId: string;
+}
+export declare function parseFeatureLayerUrl(url: string): ParsedFeatureLayerUrl;
+export declare function parseMapServiceUrl(url: string): ParsedMapServiceUrl;
+//# sourceMappingURL=url.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/url.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAQD,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAkBvE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAanE"}

package/esri-compat/url.js

@@ -0,0 +1,54 @@
+const ABSOLUTE_URL_RE = /^[A-Za-z][A-Za-z\d+.-]*:\/\//;
+const PROTOCOL_RELATIVE_URL_RE = /^\/\//;
+const RELATIVE_URL_BASE = "https://honua.invalid";
+const FEATURE_LAYER_PATH_RE = /^(?<prefix>.*)\/rest\/services\/(?<serviceId>[^/]+)\/FeatureServer\/(?<layerId>\d+)\/?$/;
+const MAP_SERVICE_PATH_RE = /^(?<prefix>.*)\/rest\/services\/(?<serviceId>[^/]+)\/MapServer(?:\/\d+)?\/?$/;
+export function parseFeatureLayerUrl(url) {
+    const { parsed, absolute } = parseServiceUrl(url);
+    const match = parsed.pathname.match(FEATURE_LAYER_PATH_RE);
+    if (!match || !match.groups) {
+        throw new Error("Invalid FeatureLayer URL. Expected .../rest/services/{serviceId}/FeatureServer/{layerId}");
+    }
+    const serviceId = decodeURIComponent(match.groups.serviceId);
+    const layerId = Number.parseInt(match.groups.layerId, 10);
+    if (Number.isNaN(layerId)) {
+        throw new Error("FeatureLayer URL contains an invalid numeric layerId.");
+    }
+    const prefix = match.groups.prefix || "";
+    const baseUrl = absolute
+        ? `${parsed.protocol}//${parsed.host}${prefix}`.replace(/\/+$/, "")
+        : prefix.replace(/\/+$/, "");
+    return { baseUrl, serviceId, layerId };
+}
+export function parseMapServiceUrl(url) {
+    const { parsed, absolute } = parseServiceUrl(url);
+    const match = parsed.pathname.match(MAP_SERVICE_PATH_RE);
+    if (!match || !match.groups) {
+        throw new Error("Invalid MapServer URL. Expected .../rest/services/{serviceId}/MapServer");
+    }
+    const serviceId = decodeURIComponent(match.groups.serviceId);
+    const prefix = match.groups.prefix || "";
+    const baseUrl = absolute
+        ? `${parsed.protocol}//${parsed.host}${prefix}`.replace(/\/+$/, "")
+        : prefix.replace(/\/+$/, "");
+    return { baseUrl, serviceId };
+}
+function parseServiceUrl(url) {
+    if (ABSOLUTE_URL_RE.test(url)) {
+        return {
+            parsed: new URL(url),
+            absolute: true,
+        };
+    }
+    if (PROTOCOL_RELATIVE_URL_RE.test(url)) {
+        return {
+            parsed: new URL(`https:${url}`),
+            absolute: true,
+        };
+    }
+    const normalized = url.startsWith("/") ? url : `/${url}`;
+    return {
+        parsed: new URL(normalized, RELATIVE_URL_BASE),
+        absolute: false,
+    };
+}

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

@@ -0,0 +1,14 @@
+import { MapCompat, type MapCompatHandle, type MapCompatOptions, type MapLoadStatusCompat } from "./map.js";
+export interface WebMapCompatOptions extends MapCompatOptions {
+    portalItem?: unknown;
+}
+export type WebMapLoadStatusCompat = MapLoadStatusCompat;
+export type WebMapHandleCompat = MapCompatHandle;
+export declare class WebMapCompat extends MapCompat {
+    constructor(options?: WebMapCompatOptions);
+    load(): Promise<WebMapCompat>;
+    when(callback?: (map: WebMapCompat) => void): Promise<WebMapCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): WebMapHandleCompat;
+    setPortalItem(portalItem: unknown): void;
+}
+//# sourceMappingURL=web-map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"web-map.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/web-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,KAAK,gBAAgB,EAAE,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE5G,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IAC3D,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,MAAM,sBAAsB,GAAG,mBAAmB,CAAC;AACzD,MAAM,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAEjD,qBAAa,YAAa,SAAQ,SAAS;gBACtB,OAAO,GAAE,mBAAwB;IAIvC,IAAI,IAAI,OAAO,CAAC,YAAY,CAAC;IAK7B,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC;IAQzE,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,kBAAkB;IAInF,aAAa,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI;CAIhD"}

package/esri-compat/web-map.js

@@ -0,0 +1,24 @@
+import { MapCompat } from "./map.js";
+export class WebMapCompat extends MapCompat {
+    constructor(options = {}) {
+        super(options);
+    }
+    async load() {
+        await super.load();
+        return this;
+    }
+    async when(callback) {
+        const map = await this.load();
+        if (callback) {
+            callback(map);
+        }
+        return map;
+    }
+    watch(propertyName, listener) {
+        return super.watch(propertyName, listener);
+    }
+    setPortalItem(portalItem) {
+        super.setPortalItem(portalItem);
+        this.eventBus.emit("web-map.portal-item-changed", { portalItem }, this);
+    }
+}