@honua/react 0.0.20-alpha.0

package/esri-compat/text-symbol.d.ts

@@ -0,0 +1,37 @@
+export interface TextSymbolCompatOptions {
+    text?: string;
+    color?: unknown;
+    haloColor?: unknown;
+    haloSize?: number | string;
+    font?: unknown;
+    xoffset?: number;
+    yoffset?: number;
+    angle?: number;
+}
+export type TextSymbolLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface TextSymbolHandleCompat {
+    remove(): void;
+}
+export declare class TextSymbolCompat {
+    loaded: boolean;
+    loadStatus: TextSymbolLoadStatusCompat;
+    text: string;
+    color: unknown;
+    haloColor: unknown;
+    haloSize: number | string | undefined;
+    font: unknown;
+    xoffset: number;
+    yoffset: number;
+    angle: number;
+    private readonly watchListeners;
+    constructor(options?: TextSymbolCompatOptions);
+    load(): Promise<TextSymbolCompat>;
+    when(callback?: (symbol: TextSymbolCompat) => void): Promise<TextSymbolCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): TextSymbolHandleCompat;
+    update(options: TextSymbolCompatOptions): void;
+    clone(): TextSymbolCompat;
+    toJSON(): TextSymbolCompatOptions;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=text-symbol.d.ts.map

package/esri-compat/text-symbol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-symbol.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/text-symbol.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,0BAA0B,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE7E,MAAM,WAAW,sBAAsB;IACrC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,gBAAgB;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,0BAA0B,CAAC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACtC,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,uBAA4B;IAc3C,IAAI,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAcjC,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,MAAM,CAAC,OAAO,EAAE,uBAAuB,GAAG,IAAI;IAmC9C,KAAK,IAAI,gBAAgB;IAIzB,MAAM,IAAI,uBAAuB;IAajC,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/text-symbol.js

@@ -0,0 +1,123 @@
+import { safeInvokeCompatListener } from "./event-bus.js";
+export class TextSymbolCompat {
+    loaded;
+    loadStatus;
+    text;
+    color;
+    haloColor;
+    haloSize;
+    font;
+    xoffset;
+    yoffset;
+    angle;
+    watchListeners;
+    constructor(options = {}) {
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.text = options.text ?? "";
+        this.color = options.color;
+        this.haloColor = options.haloColor;
+        this.haloSize = options.haloSize;
+        this.font = options.font;
+        this.xoffset = finiteNumber(options.xoffset, 0);
+        this.yoffset = finiteNumber(options.yoffset, 0);
+        this.angle = finiteNumber(options.angle, 0);
+        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 symbol = await this.load();
+        if (callback) {
+            callback(symbol);
+        }
+        return symbol;
+    }
+    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.text !== undefined) {
+            this.text = options.text;
+            this.notifyWatchers("text", this.text);
+        }
+        if (options.color !== undefined) {
+            this.color = options.color;
+            this.notifyWatchers("color", this.color);
+        }
+        if (options.haloColor !== undefined) {
+            this.haloColor = options.haloColor;
+            this.notifyWatchers("haloColor", this.haloColor);
+        }
+        if (options.haloSize !== undefined) {
+            this.haloSize = options.haloSize;
+            this.notifyWatchers("haloSize", this.haloSize);
+        }
+        if (options.font !== undefined) {
+            this.font = options.font;
+            this.notifyWatchers("font", this.font);
+        }
+        if (options.xoffset !== undefined) {
+            this.xoffset = finiteNumber(options.xoffset, this.xoffset);
+            this.notifyWatchers("xoffset", this.xoffset);
+        }
+        if (options.yoffset !== undefined) {
+            this.yoffset = finiteNumber(options.yoffset, this.yoffset);
+            this.notifyWatchers("yoffset", this.yoffset);
+        }
+        if (options.angle !== undefined) {
+            this.angle = finiteNumber(options.angle, this.angle);
+            this.notifyWatchers("angle", this.angle);
+        }
+    }
+    clone() {
+        return new TextSymbolCompat(this.toJSON());
+    }
+    toJSON() {
+        return {
+            text: this.text,
+            color: this.color,
+            haloColor: this.haloColor,
+            haloSize: this.haloSize,
+            font: this.font,
+            xoffset: this.xoffset,
+            yoffset: this.yoffset,
+            angle: this.angle,
+        };
+    }
+    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 finiteNumber(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}

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

@@ -0,0 +1,52 @@
+import { HonuaClient } from "../core/client.js";
+import type { HonuaServiceMetadata } from "../core/types.js";
+import { CompatEventBus } from "./event-bus.js";
+export interface TileLayerCompatOptions {
+    url: string;
+    id?: string;
+    title?: string;
+    opacity?: number;
+    visible?: boolean;
+    minScale?: number;
+    maxScale?: number;
+    listMode?: string;
+    client?: HonuaClient;
+    eventBus?: CompatEventBus;
+}
+export type TileLayerLoadStatusCompat = "not-loaded" | "loading" | "loaded" | "failed";
+export interface TileLayerHandleCompat {
+    remove(): void;
+}
+export declare class TileLayerCompat {
+    readonly url: string;
+    id: string;
+    title: string | undefined;
+    readonly serviceId: string;
+    opacity: number;
+    visible: boolean;
+    minScale: number;
+    maxScale: number;
+    listMode: string;
+    loaded: boolean;
+    loadStatus: TileLayerLoadStatusCompat;
+    metadata: HonuaServiceMetadata | undefined;
+    readonly eventBus: CompatEventBus;
+    private readonly client;
+    private readonly baseUrl;
+    private readonly watchListeners;
+    private readonly eventListeners;
+    constructor(options: TileLayerCompatOptions);
+    load(): Promise<TileLayerCompat>;
+    when(callback?: (layer: TileLayerCompat) => void): Promise<TileLayerCompat>;
+    refresh(): void;
+    watch(propertyName: string, listener: (value: unknown) => void): TileLayerHandleCompat;
+    setVisibility(visible: boolean): void;
+    setOpacity(opacity: number): void;
+    setScaleRange(minScale: number | undefined, maxScale: number | undefined): void;
+    on(eventName: string, listener: (event: unknown) => void): TileLayerHandleCompat;
+    destroy(): void;
+    setListMode(listMode: string): void;
+    getTileUrl(level: number, row: number, col: number): string;
+    private notifyWatchers;
+}
+//# sourceMappingURL=tile-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tile-layer.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/tile-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAmD,MAAM,gBAAgB,CAAC;AAGjG,MAAM,WAAW,sBAAsB;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,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,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,MAAM,MAAM,yBAAyB,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEvF,MAAM,WAAW,qBAAqB;IACpC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,eAAe;IAC1B,SAAgB,GAAG,EAAE,MAAM,CAAC;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,SAAgB,SAAS,EAAE,MAAM,CAAC;IAC3B,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,yBAAyB,CAAC;IACtC,QAAQ,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAClD,SAAgB,QAAQ,EAAE,cAAc,CAAC;IAEzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;IAC5E,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,EAAE,sBAAsB;IAqBrC,IAAI,IAAI,OAAO,CAAC,eAAe,CAAC;IA2BhC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,GAAG,OAAO,CAAC,eAAe,CAAC;IAQjF,OAAO,IAAI,IAAI;IAUf,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,qBAAqB;IAetF,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAMrC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAMjC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAY/E,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,qBAAqB;IAqBhF,OAAO,IAAI,IAAI;IAMf,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAMnC,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAIlE,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/tile-layer.js

@@ -0,0 +1,168 @@
+import { HonuaClient } from "../core/client.js";
+import { encodeServiceIdPath } from "../core/path-utils.js";
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+import { parseMapServiceUrl } from "./url.js";
+export class TileLayerCompat {
+    url;
+    id;
+    title;
+    serviceId;
+    opacity;
+    visible;
+    minScale;
+    maxScale;
+    listMode;
+    loaded;
+    loadStatus;
+    metadata;
+    eventBus;
+    client;
+    baseUrl;
+    watchListeners;
+    eventListeners;
+    constructor(options) {
+        const parsed = parseMapServiceUrl(options.url);
+        this.url = options.url;
+        this.baseUrl = parsed.baseUrl;
+        this.serviceId = parsed.serviceId;
+        this.id = options.id ?? this.serviceId;
+        this.title = options.title;
+        this.opacity = options.opacity ?? 1;
+        this.visible = options.visible ?? true;
+        this.minScale = normalizeScale(options.minScale);
+        this.maxScale = normalizeScale(options.maxScale);
+        this.listMode = options.listMode ?? "show";
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.metadata = undefined;
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.client) ?? new CompatEventBus();
+        this.client = options.client ?? new HonuaClient({ baseUrl: parsed.baseUrl });
+        this.watchListeners = new Map();
+        this.eventListeners = new Map();
+    }
+    async load() {
+        if (!this.loaded) {
+            this.loadStatus = "loading";
+            this.notifyWatchers("loadStatus", this.loadStatus);
+            this.eventBus.emit("tile-layer.loading", { serviceId: this.serviceId, id: this.id }, this);
+            try {
+                this.metadata = await this.client.getMapServiceMetadata(this.serviceId);
+                this.notifyWatchers("metadata", this.metadata);
+                this.loaded = true;
+                this.notifyWatchers("loaded", this.loaded);
+                this.loadStatus = "loaded";
+                this.notifyWatchers("loadStatus", this.loadStatus);
+                this.eventBus.emit("tile-layer.loaded", { serviceId: this.serviceId, id: this.id }, this);
+            }
+            catch (error) {
+                this.metadata = undefined;
+                this.notifyWatchers("metadata", this.metadata);
+                this.loaded = false;
+                this.notifyWatchers("loaded", this.loaded);
+                this.loadStatus = "failed";
+                this.notifyWatchers("loadStatus", this.loadStatus);
+                this.eventBus.emit("tile-layer.failed", { serviceId: this.serviceId, id: this.id, error }, this);
+                throw error;
+            }
+        }
+        return this;
+    }
+    async when(callback) {
+        const layer = await this.load();
+        if (callback) {
+            callback(layer);
+        }
+        return layer;
+    }
+    refresh() {
+        this.loaded = false;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "not-loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.metadata = undefined;
+        this.notifyWatchers("metadata", this.metadata);
+        this.eventBus.emit("tile-layer.refreshed", { serviceId: this.serviceId, id: this.id }, this);
+    }
+    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);
+            },
+        };
+    }
+    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);
+    }
+    setScaleRange(minScale, maxScale) {
+        this.minScale = normalizeScale(minScale);
+        this.maxScale = normalizeScale(maxScale);
+        this.notifyWatchers("minScale", this.minScale);
+        this.notifyWatchers("maxScale", this.maxScale);
+        this.eventBus.emit("tile-layer.scale-range-changed", { layerId: this.id, minScale: this.minScale, maxScale: this.maxScale }, this);
+    }
+    on(eventName, listener) {
+        const namespacedEvent = `tile-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("tile-layer.destroyed", { id: this.id }, this);
+    }
+    setListMode(listMode) {
+        this.listMode = listMode;
+        this.notifyWatchers("listMode", this.listMode);
+        this.eventBus.emit("tile-layer.list-mode-changed", { layerId: this.id, listMode }, this);
+    }
+    getTileUrl(level, row, col) {
+        return `${this.baseUrl}/rest/services/${encodeServiceIdPath(this.serviceId)}/MapServer/tile/${level}/${row}/${col}`;
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+}
+function normalizeScale(scale) {
+    if (scale === undefined || !Number.isFinite(scale)) {
+        return 0;
+    }
+    return Math.max(0, Math.trunc(scale));
+}
+function normalizeOpacity(opacity) {
+    if (!Number.isFinite(opacity)) {
+        return 1;
+    }
+    return Math.min(Math.max(opacity, 0), 1);
+}

package/esri-compat/time-slider.d.ts

@@ -0,0 +1,70 @@
+import { CompatEventBus } from "./event-bus.js";
+export type TimeSliderModeCompat = "instant" | "time-window";
+export type TimeSliderIntervalUnitCompat = "milliseconds" | "seconds" | "minutes" | "hours" | "days";
+export interface TimeExtentCompat {
+    start: Date;
+    end: Date;
+}
+export interface TimeSliderStopsCompat {
+    values?: readonly (Date | string | number)[];
+    interval?: {
+        value: number;
+        unit: TimeSliderIntervalUnitCompat;
+    };
+}
+export interface TimeSliderCompatOptions {
+    view?: unknown;
+    container?: unknown;
+    eventBus?: CompatEventBus;
+    fullTimeExtent?: Partial<{
+        start: Date | string | number;
+        end: Date | string | number;
+    }>;
+    timeExtent?: Partial<{
+        start: Date | string | number;
+        end: Date | string | number;
+    }>;
+    stops?: TimeSliderStopsCompat;
+    mode?: TimeSliderModeCompat;
+    loop?: boolean;
+    playRate?: number;
+}
+export type TimeSliderLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface TimeSliderHandleCompat {
+    remove(): void;
+}
+export declare class TimeSliderCompat {
+    readonly view: unknown;
+    readonly container: unknown;
+    readonly eventBus: CompatEventBus;
+    loaded: boolean;
+    loadStatus: TimeSliderLoadStatusCompat;
+    readonly mode: TimeSliderModeCompat;
+    readonly loop: boolean;
+    readonly playRate: number;
+    readonly stops: TimeSliderStopsCompat;
+    fullTimeExtent: TimeExtentCompat | undefined;
+    timeExtent: TimeExtentCompat | undefined;
+    playing: boolean;
+    private stopIndex;
+    private readonly watchListeners;
+    constructor(options?: TimeSliderCompatOptions);
+    load(): Promise<TimeSliderCompat>;
+    when(callback?: (widget: TimeSliderCompat) => void): Promise<TimeSliderCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): TimeSliderHandleCompat;
+    setTimeExtent(timeExtent: TimeExtentCompat): void;
+    play(): void;
+    stop(): void;
+    next(): TimeExtentCompat | undefined;
+    previous(): TimeExtentCompat | undefined;
+    private shift;
+    connectLayer(layer: {
+        setTimeExtent(extent: {
+            start: Date;
+            end: Date;
+        } | undefined): void;
+    }): TimeSliderHandleCompat;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=time-slider.d.ts.map

package/esri-compat/time-slider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-slider.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/time-slider.ts"],"names":[],"mappings":"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"}

package/esri-compat/time-slider.js

@@ -0,0 +1,208 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener, } from "./event-bus.js";
+export class TimeSliderCompat {
+    view;
+    container;
+    eventBus;
+    loaded;
+    loadStatus;
+    mode;
+    loop;
+    playRate;
+    stops;
+    fullTimeExtent;
+    timeExtent;
+    playing;
+    stopIndex;
+    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.mode = options.mode ?? "instant";
+        this.loop = options.loop ?? false;
+        this.playRate = options.playRate ?? 1000;
+        this.stops = {
+            values: options.stops?.values ? [...options.stops.values] : undefined,
+            interval: options.stops?.interval ? { ...options.stops.interval } : undefined,
+        };
+        this.fullTimeExtent = parseTimeExtent(options.fullTimeExtent);
+        this.timeExtent = parseTimeExtent(options.timeExtent) ?? this.fullTimeExtent;
+        this.playing = false;
+        this.stopIndex = 0;
+        this.watchListeners = new Map();
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("timeslider.loading", undefined, this);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("timeslider.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);
+            },
+        };
+    }
+    setTimeExtent(timeExtent) {
+        this.timeExtent = {
+            start: new Date(timeExtent.start.getTime()),
+            end: new Date(timeExtent.end.getTime()),
+        };
+        this.notifyWatchers("timeExtent", this.timeExtent);
+        this.eventBus.emit("timeslider.updated", { timeExtent: this.timeExtent }, this);
+    }
+    play() {
+        if (this.playing) {
+            return;
+        }
+        this.playing = true;
+        this.notifyWatchers("playing", this.playing);
+        this.eventBus.emit("timeslider.play", { playRate: this.playRate }, this);
+    }
+    stop() {
+        if (!this.playing) {
+            return;
+        }
+        this.playing = false;
+        this.notifyWatchers("playing", this.playing);
+        this.eventBus.emit("timeslider.stop", undefined, this);
+    }
+    next() {
+        const nextExtent = this.shift(1);
+        if (nextExtent) {
+            this.eventBus.emit("timeslider.next", { timeExtent: nextExtent }, this);
+        }
+        return nextExtent;
+    }
+    previous() {
+        const previousExtent = this.shift(-1);
+        if (previousExtent) {
+            this.eventBus.emit("timeslider.previous", { timeExtent: previousExtent }, this);
+        }
+        return previousExtent;
+    }
+    shift(stepDirection) {
+        const stopValues = this.stops.values?.map((value) => toDate(value)).filter((value) => !!value);
+        if (stopValues && stopValues.length > 0) {
+            const lastIndex = stopValues.length - 1;
+            this.stopIndex += stepDirection;
+            if (this.stopIndex < 0 || this.stopIndex > lastIndex) {
+                if (!this.loop) {
+                    this.stopIndex = Math.max(0, Math.min(lastIndex, this.stopIndex));
+                    return this.timeExtent;
+                }
+                this.stopIndex = this.stopIndex < 0 ? lastIndex : 0;
+            }
+            const current = stopValues[this.stopIndex];
+            if (!current) {
+                return this.timeExtent;
+            }
+            const extent = {
+                start: current,
+                end: current,
+            };
+            this.setTimeExtent(extent);
+            return this.timeExtent;
+        }
+        const interval = this.stops.interval;
+        if (!interval || !this.timeExtent) {
+            return this.timeExtent;
+        }
+        const deltaMillis = intervalToMilliseconds(interval.value, interval.unit) * stepDirection;
+        const shifted = {
+            start: new Date(this.timeExtent.start.getTime() + deltaMillis),
+            end: new Date(this.timeExtent.end.getTime() + deltaMillis),
+        };
+        this.setTimeExtent(shifted);
+        return this.timeExtent;
+    }
+    connectLayer(layer) {
+        if (this.timeExtent) {
+            layer.setTimeExtent(this.timeExtent);
+        }
+        const subscription = this.eventBus.on("timeslider.updated", (event) => {
+            const payload = event.payload;
+            if (payload?.timeExtent) {
+                layer.setTimeExtent(payload.timeExtent);
+            }
+        });
+        return {
+            remove: () => {
+                subscription.remove();
+            },
+        };
+    }
+    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 parseTimeExtent(extent) {
+    if (!extent) {
+        return undefined;
+    }
+    const start = toDate(extent.start);
+    const end = toDate(extent.end);
+    if (!start || !end) {
+        return undefined;
+    }
+    return { start, end };
+}
+function toDate(value) {
+    if (value instanceof Date) {
+        return new Date(value.getTime());
+    }
+    if (typeof value === "string" || typeof value === "number") {
+        const parsed = new Date(value);
+        if (!Number.isNaN(parsed.getTime())) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function intervalToMilliseconds(value, unit) {
+    switch (unit) {
+        case "milliseconds":
+            return value;
+        case "seconds":
+            return value * 1000;
+        case "minutes":
+            return value * 60_000;
+        case "hours":
+            return value * 3_600_000;
+        case "days":
+            return value * 86_400_000;
+    }
+}