@honua/app-platform 0.0.20-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,13 @@
+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;
+export declare function parseImageServiceUrl(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;AASD,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAkBvE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAanE;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAarE"}

package/esri-compat/url.js

@@ -0,0 +1,68 @@
+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+)?\/?$/;
+const IMAGE_SERVICE_PATH_RE = /^(?<prefix>.*)\/rest\/services\/(?<serviceId>[^/]+)\/ImageServer(?:\/\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 };
+}
+export function parseImageServiceUrl(url) {
+    const { parsed, absolute } = parseServiceUrl(url);
+    const match = parsed.pathname.match(IMAGE_SERVICE_PATH_RE);
+    if (!match || !match.groups) {
+        throw new Error("Invalid ImageServer URL. Expected .../rest/services/{serviceId}/ImageServer");
+    }
+    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/vector-tile-layer.d.ts

@@ -0,0 +1,47 @@
+import { CompatEventBus } from "./event-bus.js";
+export interface VectorTileLayerCompatOptions {
+    url?: string;
+    style?: string | Record<string, unknown>;
+    id?: string;
+    title?: string;
+    opacity?: number;
+    visible?: boolean;
+    minScale?: number;
+    maxScale?: number;
+    listMode?: string;
+    eventBus?: CompatEventBus;
+}
+export type VectorTileLayerLoadStatusCompat = "not-loaded" | "loading" | "loaded" | "failed";
+export interface VectorTileLayerHandleCompat {
+    remove(): void;
+}
+export declare class VectorTileLayerCompat {
+    readonly type: "vector-tile";
+    id: string | undefined;
+    title: string | undefined;
+    url: string | undefined;
+    style: string | Record<string, unknown> | undefined;
+    opacity: number;
+    visible: boolean;
+    minScale: number;
+    maxScale: number;
+    listMode: string;
+    loaded: boolean;
+    loadStatus: VectorTileLayerLoadStatusCompat;
+    readonly eventBus: CompatEventBus;
+    private styleJson;
+    private readonly watchListeners;
+    private readonly eventListeners;
+    constructor(options?: VectorTileLayerCompatOptions);
+    load(): Promise<VectorTileLayerCompat>;
+    when(callback?: (layer: VectorTileLayerCompat) => void): Promise<VectorTileLayerCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): VectorTileLayerHandleCompat;
+    on(eventName: string, listener: (event: unknown) => void): VectorTileLayerHandleCompat;
+    setVisibility(visible: boolean): void;
+    setOpacity(opacity: number): void;
+    getStyle(): Record<string, unknown> | undefined;
+    loadStyle(style: Record<string, unknown>): void;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=vector-tile-layer.d.ts.map

package/esri-compat/vector-tile-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-tile-layer.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/vector-tile-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAmD,MAAM,gBAAgB,CAAC;AAEjG,MAAM,WAAW,4BAA4B;IAC3C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,MAAM,MAAM,+BAA+B,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE7F,MAAM,WAAW,2BAA2B;IAC1C,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,qBAAqB;IAChC,SAAgB,IAAI,EAAE,aAAa,CAAC;IAC7B,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IACpD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,+BAA+B,CAAC;IACnD,SAAgB,QAAQ,EAAE,cAAc,CAAC;IACzC,OAAO,CAAC,SAAS,CAAsC;IACvD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;IAC5E,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,4BAAiC;IAmBhD,IAAI,IAAI,OAAO,CAAC,qBAAqB,CAAC;IAwBtC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAM7F,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,2BAA2B;IAc5F,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,2BAA2B;IAkBtF,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAMrC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAMjC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS;IAI/C,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAO/C,OAAO,IAAI,IAAI;IAMtB,OAAO,CAAC,cAAc;CAKvB"}

package/esri-compat/vector-tile-layer.js

@@ -0,0 +1,130 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+export class VectorTileLayerCompat {
+    type;
+    id;
+    title;
+    url;
+    style;
+    opacity;
+    visible;
+    minScale;
+    maxScale;
+    listMode;
+    loaded;
+    loadStatus;
+    eventBus;
+    styleJson;
+    watchListeners;
+    eventListeners;
+    constructor(options = {}) {
+        this.type = "vector-tile";
+        this.id = options.id;
+        this.title = options.title;
+        this.url = options.url;
+        this.style = options.style;
+        this.opacity = options.opacity ?? 1;
+        this.visible = options.visible ?? true;
+        this.minScale = options.minScale ?? 0;
+        this.maxScale = options.maxScale ?? 0;
+        this.listMode = options.listMode ?? "show";
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.style) ?? new CompatEventBus();
+        this.styleJson = typeof options.style === "object" && options.style !== null ? { ...options.style } : undefined;
+        this.watchListeners = new Map();
+        this.eventListeners = new Map();
+    }
+    async load() {
+        if (this.loaded)
+            return this;
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        try {
+            if (this.styleJson === undefined && typeof this.style === "string") {
+                const response = await fetch(this.style);
+                if (!response.ok)
+                    throw new Error(`Failed to fetch vector tile style: ${response.status}`);
+                this.styleJson = (await response.json());
+            }
+            this.loaded = true;
+            this.loadStatus = "loaded";
+            this.notifyWatchers("loaded", this.loaded);
+            this.notifyWatchers("loadStatus", this.loadStatus);
+            this.eventBus.emit("vector-tile-layer.loaded", { layerId: this.id, url: this.url }, this);
+        }
+        catch (error) {
+            this.loadStatus = "failed";
+            this.notifyWatchers("loadStatus", this.loadStatus);
+            this.eventBus.emit("vector-tile-layer.failed", { layerId: this.id, error }, this);
+            throw error;
+        }
+        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);
+            },
+        };
+    }
+    on(eventName, listener) {
+        let listeners = this.eventListeners.get(eventName);
+        if (!listeners) {
+            listeners = new Set();
+            this.eventListeners.set(eventName, listeners);
+        }
+        listeners.add(listener);
+        const subscription = this.eventBus.on(`vector-tile-layer.${eventName}`, (event) => {
+            safeInvokeCompatListener(listener, event.payload);
+        });
+        return {
+            remove: () => {
+                listeners?.delete(listener);
+                subscription.remove();
+            },
+        };
+    }
+    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 = Math.min(Math.max(opacity, 0), 1);
+        this.notifyWatchers("opacity", this.opacity);
+        this.eventBus.emit("layer.opacity-changed", { layerId: this.id, opacity: this.opacity }, this);
+    }
+    getStyle() {
+        return this.styleJson ? { ...this.styleJson } : undefined;
+    }
+    loadStyle(style) {
+        this.styleJson = { ...style };
+        this.style = style;
+        this.notifyWatchers("style", this.styleJson);
+        this.eventBus.emit("vector-tile-layer.style-changed", { layerId: this.id, style: this.styleJson }, this);
+    }
+    destroy() {
+        this.watchListeners.clear();
+        this.eventListeners.clear();
+        this.eventBus.emit("vector-tile-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);
+    }
+}