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

package/esri-compat/route-layer.js

@@ -0,0 +1,223 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+export class RouteLayerCompat {
+    type;
+    id;
+    title;
+    url;
+    visible;
+    opacity;
+    listMode;
+    eventBus;
+    route;
+    autoSolve;
+    solving;
+    loaded;
+    loadStatus;
+    stopsInternal;
+    routeProvider;
+    watchListeners;
+    constructor(options = {}) {
+        this.type = "route";
+        this.id = options.id;
+        this.title = options.title;
+        this.url = options.url;
+        this.visible = options.visible ?? true;
+        this.opacity = options.opacity ?? 1;
+        this.listMode = options.listMode ?? "show";
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.stops) ?? new CompatEventBus();
+        this.route = undefined;
+        this.autoSolve = options.autoSolve ?? false;
+        this.solving = false;
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.stopsInternal = options.stops ? options.stops.map(cloneRouteStop) : [];
+        this.routeProvider = options.routeProvider ?? defaultRouteProvider;
+        this.watchListeners = new Map();
+    }
+    get stops() {
+        return this.stopsInternal;
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("route-layer.loading", { layerId: this.id }, this);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("route-layer.loaded", { layerId: this.id }, this);
+        return 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);
+            },
+        };
+    }
+    addStop(stop, index) {
+        const normalized = cloneRouteStop(stop);
+        if (index === undefined) {
+            this.stopsInternal.push(normalized);
+            this.eventBus.emit("route-layer.stop-added", { layerId: this.id, stop: normalized, index: this.stopsInternal.length - 1 }, this);
+        }
+        else {
+            const insertAt = normalizeInsertIndex(index, this.stopsInternal.length);
+            this.stopsInternal.splice(insertAt, 0, normalized);
+            this.eventBus.emit("route-layer.stop-added", { layerId: this.id, stop: normalized, index: insertAt }, this);
+        }
+        this.notifyWatchers("stops", this.stops);
+        if (this.autoSolve) {
+            void this.solve();
+        }
+    }
+    addStops(stops, index) {
+        if (stops.length === 0) {
+            return;
+        }
+        const normalized = stops.map(cloneRouteStop);
+        if (index === undefined) {
+            const startIndex = this.stopsInternal.length;
+            this.stopsInternal.push(...normalized);
+            this.eventBus.emit("route-layer.stops-added", { layerId: this.id, stops: normalized, index: startIndex }, this);
+        }
+        else {
+            const insertAt = normalizeInsertIndex(index, this.stopsInternal.length);
+            this.stopsInternal.splice(insertAt, 0, ...normalized);
+            this.eventBus.emit("route-layer.stops-added", { layerId: this.id, stops: normalized, index: insertAt }, this);
+        }
+        this.notifyWatchers("stops", this.stops);
+        if (this.autoSolve) {
+            void this.solve();
+        }
+    }
+    clearStops() {
+        if (this.stopsInternal.length === 0) {
+            return;
+        }
+        const removed = [...this.stopsInternal];
+        this.stopsInternal.length = 0;
+        this.route = undefined;
+        this.notifyWatchers("stops", this.stops);
+        this.notifyWatchers("route", this.route);
+        this.eventBus.emit("route-layer.stops-cleared", { layerId: this.id, stops: removed }, this);
+    }
+    async solve() {
+        if (this.stopsInternal.length < 2) {
+            this.route = undefined;
+            this.notifyWatchers("route", this.route);
+            return undefined;
+        }
+        this.solving = true;
+        this.notifyWatchers("solving", this.solving);
+        this.eventBus.emit("route-layer.solve-started", { layerId: this.id, stopCount: this.stopsInternal.length }, this);
+        try {
+            const result = await this.routeProvider([...this.stopsInternal], this);
+            this.route = {
+                path: result.path.map((point) => [point[0], point[1]]),
+                totalLengthMeters: result.totalLengthMeters,
+                totalTimeSeconds: result.totalTimeSeconds,
+            };
+            this.notifyWatchers("route", this.route);
+            this.eventBus.emit("route-layer.solve-completed", { layerId: this.id, route: this.route }, this);
+            return this.route;
+        }
+        catch (error) {
+            this.route = undefined;
+            this.notifyWatchers("route", this.route);
+            this.eventBus.emit("route-layer.solve-error", { layerId: this.id, error }, this);
+            throw error;
+        }
+        finally {
+            this.solving = false;
+            this.notifyWatchers("solving", this.solving);
+        }
+    }
+    async refresh() {
+        return this.solve();
+    }
+    async when(callback) {
+        await this.load();
+        if (callback) {
+            callback(this);
+        }
+        return this;
+    }
+    destroy() {
+        this.watchListeners.clear();
+        this.eventBus.emit("route-layer.destroyed", { layerId: this.id }, this);
+    }
+    setVisibility(visible) {
+        this.visible = visible;
+        this.notifyWatchers("visible", this.visible);
+        this.eventBus.emit("layer.visibility-changed", { layerId: this.id, visible }, this);
+    }
+    setOpacity(opacity) {
+        this.opacity = normalizeOpacity(opacity);
+        this.notifyWatchers("opacity", this.opacity);
+        this.eventBus.emit("layer.opacity-changed", { layerId: this.id, opacity: this.opacity }, this);
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+}
+function cloneRouteStop(stop) {
+    return {
+        name: stop.name,
+        location: [stop.location[0], stop.location[1]],
+    };
+}
+function defaultRouteProvider(stops) {
+    const path = stops.map((stop) => [stop.location[0], stop.location[1]]);
+    let totalLengthMeters = 0;
+    for (let i = 1; i < path.length; i += 1) {
+        totalLengthMeters += haversineDistanceMeters(path[i - 1], path[i]);
+    }
+    const averageMetersPerSecond = 13.4112; // ~30mph
+    const totalTimeSeconds = totalLengthMeters / averageMetersPerSecond;
+    return {
+        path,
+        totalLengthMeters,
+        totalTimeSeconds,
+    };
+}
+function haversineDistanceMeters(a, b) {
+    const [lonA, latA] = a;
+    const [lonB, latB] = b;
+    const dLat = toRadians(latB - latA);
+    const dLon = toRadians(lonB - lonA);
+    const latARad = toRadians(latA);
+    const latBRad = toRadians(latB);
+    const h = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(latARad) * Math.cos(latBRad) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+    const c = 2 * Math.atan2(Math.sqrt(h), Math.sqrt(1 - h));
+    return 6371008.8 * c;
+}
+function toRadians(value) {
+    return (value * Math.PI) / 180;
+}
+function normalizeOpacity(opacity) {
+    if (!Number.isFinite(opacity)) {
+        return 1;
+    }
+    return Math.min(Math.max(opacity, 0), 1);
+}
+function normalizeInsertIndex(index, length) {
+    const sanitized = Number.isFinite(index) ? Math.trunc(index) : length;
+    return Math.min(Math.max(sanitized, 0), length);
+}

package/esri-compat/route-task.d.ts

@@ -0,0 +1,88 @@
+import { CompatEventBus } from "./event-bus.js";
+import { type RouteLayerCompatOptions, type RouteStopCompat } from "./route-layer.js";
+export interface RouteTaskCompatOptions {
+    url?: string;
+    apiKey?: string;
+    requestOptions?: Record<string, unknown>;
+    eventBus?: CompatEventBus;
+    routeProvider?: RouteLayerCompatOptions["routeProvider"];
+}
+export interface RouteTaskStopFeatureCompat {
+    geometry?: {
+        x?: number;
+        y?: number;
+        longitude?: number;
+        latitude?: number;
+    };
+    attributes?: Record<string, unknown>;
+}
+export interface RouteTaskStopsFeatureSetCompat {
+    features?: readonly RouteTaskStopFeatureCompat[];
+}
+export interface RouteTaskSolveParametersCompat {
+    stops?: readonly RouteStopCompat[] | RouteTaskStopsFeatureSetCompat;
+    returnDirections?: boolean;
+}
+export interface RouteTaskDirectionsFeatureCompat {
+    attributes: {
+        text: string;
+        length: number;
+        time: number;
+    };
+    geometry: {
+        paths: [number, number][][];
+        spatialReference: {
+            wkid: number;
+        };
+    };
+}
+export interface RouteTaskDirectionsSummaryCompat {
+    totalLength: number;
+    totalTime: number;
+    features: readonly RouteTaskDirectionsFeatureCompat[];
+}
+export interface RouteTaskResultGraphicCompat {
+    geometry: {
+        paths: [number, number][][];
+        spatialReference: {
+            wkid: number;
+        };
+    };
+    attributes: {
+        Total_Kilometers: number;
+        Total_Miles: number;
+        Total_TravelTime: number;
+        Total_Length: number;
+    };
+}
+export interface RouteTaskRouteResultCompat {
+    route: RouteTaskResultGraphicCompat;
+    directions?: RouteTaskDirectionsSummaryCompat;
+    stops: readonly RouteStopCompat[];
+}
+export interface RouteTaskSolveResultCompat {
+    routeResults: readonly RouteTaskRouteResultCompat[];
+}
+export type RouteTaskLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface RouteTaskHandleCompat {
+    remove(): void;
+}
+export declare class RouteTaskCompat {
+    readonly url: string | undefined;
+    readonly apiKey: string | undefined;
+    readonly requestOptions: Readonly<Record<string, unknown>> | undefined;
+    readonly eventBus: CompatEventBus;
+    loaded: boolean;
+    loadStatus: RouteTaskLoadStatusCompat;
+    lastSolveResult: RouteTaskSolveResultCompat | undefined;
+    private readonly watchListeners;
+    private readonly routeProvider;
+    constructor(options?: RouteTaskCompatOptions | string);
+    load(): Promise<RouteTaskCompat>;
+    when(callback?: (task: RouteTaskCompat) => void): Promise<RouteTaskCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): RouteTaskHandleCompat;
+    solve(params?: RouteTaskSolveParametersCompat): Promise<RouteTaskSolveResultCompat>;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=route-task.d.ts.map

package/esri-compat/route-task.d.ts.map

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

package/esri-compat/route-task.js

@@ -0,0 +1,225 @@
+import { CompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+import { RouteLayerCompat, } from "./route-layer.js";
+export class RouteTaskCompat {
+    url;
+    apiKey;
+    requestOptions;
+    eventBus;
+    loaded;
+    loadStatus;
+    lastSolveResult;
+    watchListeners;
+    routeProvider;
+    constructor(options = {}) {
+        if (typeof options === "string") {
+            this.url = options;
+            this.apiKey = undefined;
+            this.requestOptions = undefined;
+            this.eventBus = new CompatEventBus();
+            this.loaded = false;
+            this.loadStatus = "not-loaded";
+            this.lastSolveResult = undefined;
+            this.watchListeners = new Map();
+            this.routeProvider = undefined;
+            return;
+        }
+        this.url = options.url;
+        this.apiKey = options.apiKey;
+        this.requestOptions = options.requestOptions ? { ...options.requestOptions } : undefined;
+        this.eventBus = options.eventBus ?? new CompatEventBus();
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.lastSolveResult = undefined;
+        this.watchListeners = new Map();
+        this.routeProvider = options.routeProvider;
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("route-task.loading", undefined, this);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("route-task.loaded", undefined, this);
+        return this;
+    }
+    async when(callback) {
+        const task = await this.load();
+        if (callback) {
+            callback(task);
+        }
+        return task;
+    }
+    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 solve(params = {}) {
+        const stops = normalizeStops(params.stops);
+        if (stops.length < 2) {
+            const error = new Error("RouteTask requires at least two stops.");
+            this.eventBus.emit("route-task.solve-error", { error }, this);
+            throw error;
+        }
+        this.eventBus.emit("route-task.solve-started", { stopCount: stops.length }, this);
+        try {
+            const layer = new RouteLayerCompat({
+                stops,
+                routeProvider: this.routeProvider,
+                eventBus: this.eventBus,
+            });
+            const route = await layer.solve();
+            if (!route) {
+                throw new Error("RouteTask solve produced no route result.");
+            }
+            const result = buildSolveResult(route, stops, params.returnDirections ?? true);
+            this.lastSolveResult = result;
+            this.notifyWatchers("lastSolveResult", this.lastSolveResult);
+            this.eventBus.emit("route-task.solve-completed", { routeResults: result.routeResults }, this);
+            return result;
+        }
+        catch (error) {
+            this.lastSolveResult = undefined;
+            this.notifyWatchers("lastSolveResult", this.lastSolveResult);
+            this.eventBus.emit("route-task.solve-error", { error }, this);
+            throw error;
+        }
+    }
+    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 normalizeStops(rawStops) {
+    if (!rawStops) {
+        return [];
+    }
+    if (Array.isArray(rawStops)) {
+        const arrayStops = rawStops;
+        return arrayStops.map((stop) => ({
+            name: stop.name,
+            location: [stop.location[0], stop.location[1]],
+        }));
+    }
+    const featureSet = rawStops;
+    const features = featureSet.features ?? [];
+    const stops = [];
+    for (const feature of features) {
+        const geometry = feature.geometry;
+        if (!geometry) {
+            continue;
+        }
+        const x = geometry.x ?? geometry.longitude;
+        const y = geometry.y ?? geometry.latitude;
+        if (typeof x !== "number" || typeof y !== "number") {
+            continue;
+        }
+        const name = typeof feature.attributes?.Name === "string" ? feature.attributes.Name : undefined;
+        stops.push({
+            name,
+            location: [x, y],
+        });
+    }
+    return stops;
+}
+function buildSolveResult(route, stops, includeDirections) {
+    const kilometers = route.totalLengthMeters / 1000;
+    const miles = route.totalLengthMeters * 0.000621371;
+    const totalMinutes = route.totalTimeSeconds / 60;
+    const directionsFeatures = includeDirections ? buildDirectionFeatures(route) : [];
+    return {
+        routeResults: [
+            {
+                route: {
+                    geometry: {
+                        paths: [route.path.map((point) => [point[0], point[1]])],
+                        spatialReference: { wkid: 4326 },
+                    },
+                    attributes: {
+                        Total_Kilometers: kilometers,
+                        Total_Miles: miles,
+                        Total_TravelTime: totalMinutes,
+                        Total_Length: kilometers,
+                    },
+                },
+                directions: includeDirections
+                    ? {
+                        totalLength: kilometers,
+                        totalTime: totalMinutes,
+                        features: directionsFeatures,
+                    }
+                    : undefined,
+                stops: stops.map((stop) => ({ name: stop.name, location: [stop.location[0], stop.location[1]] })),
+            },
+        ],
+    };
+}
+function buildDirectionFeatures(route) {
+    if (route.path.length < 2 || route.totalLengthMeters <= 0) {
+        return [];
+    }
+    const features = [];
+    for (let i = 1; i < route.path.length; i += 1) {
+        const start = route.path[i - 1];
+        const end = route.path[i];
+        const segmentMeters = haversineDistanceMeters(start, end);
+        if (segmentMeters <= 0) {
+            continue;
+        }
+        const ratio = segmentMeters / route.totalLengthMeters;
+        const segmentTimeMinutes = (route.totalTimeSeconds * ratio) / 60;
+        features.push({
+            attributes: {
+                text: `Segment ${i}`,
+                length: segmentMeters / 1000,
+                time: segmentTimeMinutes,
+            },
+            geometry: {
+                paths: [
+                    [
+                        [start[0], start[1]],
+                        [end[0], end[1]],
+                    ],
+                ],
+                spatialReference: { wkid: 4326 },
+            },
+        });
+    }
+    return features;
+}
+function haversineDistanceMeters(a, b) {
+    const [lonA, latA] = a;
+    const [lonB, latB] = b;
+    const dLat = toRadians(latB - latA);
+    const dLon = toRadians(lonB - lonA);
+    const latARad = toRadians(latA);
+    const latBRad = toRadians(latB);
+    const h = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(latARad) * Math.cos(latBRad) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+    const c = 2 * Math.atan2(Math.sqrt(h), Math.sqrt(1 - h));
+    return 6371008.8 * c;
+}
+function toRadians(value) {
+    return (value * Math.PI) / 180;
+}

package/esri-compat/scene-view.d.ts

@@ -0,0 +1,41 @@
+import { type MapViewCenterLike, MapViewCompat, type MapViewCompatOptions, type MapViewConstraintsLike, type MapViewExtentLike, type MapViewGoToInput, type MapViewGoToOptions, type MapViewHandle, type MapViewHighlightOptionsLike, type MapViewLayerViewCompat, type MapViewLoadStatusCompat, type MapViewPaddingLike, type MapViewSpatialReferenceLike } from "./map-view.js";
+export interface SceneViewCompatOptions extends MapViewCompatOptions {
+    viewingMode?: "global" | "local";
+    qualityProfile?: string;
+    camera?: unknown;
+}
+export type SceneViewLoadStatusCompat = MapViewLoadStatusCompat;
+export type SceneViewHandleCompat = MapViewHandle;
+export declare class SceneViewCompat extends MapViewCompat {
+    viewingMode: "global" | "local";
+    qualityProfile: string | undefined;
+    camera: unknown;
+    constructor(options?: SceneViewCompatOptions);
+    load(): Promise<SceneViewCompat>;
+    when(callback?: (view: SceneViewCompat) => void): Promise<SceneViewCompat>;
+    when(callback?: (view: MapViewCompat) => void): Promise<MapViewCompat>;
+    watch(propertyName: "zoom", listener: (value: number | undefined) => void): SceneViewHandleCompat;
+    watch(propertyName: "scale", listener: (value: number | undefined) => void): SceneViewHandleCompat;
+    watch(propertyName: "rotation", listener: (value: number | undefined) => void): SceneViewHandleCompat;
+    watch(propertyName: "center", listener: (value: MapViewCenterLike | undefined) => void): SceneViewHandleCompat;
+    watch(propertyName: "extent", listener: (value: MapViewExtentLike | undefined) => void): SceneViewHandleCompat;
+    watch(propertyName: "loaded", listener: (value: boolean) => void): SceneViewHandleCompat;
+    watch(propertyName: "loadStatus", listener: (value: MapViewLoadStatusCompat) => void): SceneViewHandleCompat;
+    watch(propertyName: "container", listener: (value: HTMLElement | string | null | undefined) => void): SceneViewHandleCompat;
+    watch(propertyName: "padding", listener: (value: MapViewPaddingLike | undefined) => void): SceneViewHandleCompat;
+    watch(propertyName: "constraints", listener: (value: MapViewConstraintsLike | undefined) => void): SceneViewHandleCompat;
+    watch(propertyName: "highlightOptions", listener: (value: MapViewHighlightOptionsLike | undefined) => void): SceneViewHandleCompat;
+    watch(propertyName: "spatialReference", listener: (value: MapViewSpatialReferenceLike | undefined) => void): SceneViewHandleCompat;
+    watch(propertyName: "allLayerViews", listener: (value: readonly MapViewLayerViewCompat[]) => void): SceneViewHandleCompat;
+    watch(propertyName: "popup.visible", listener: (value: boolean) => void): SceneViewHandleCompat;
+    watch(propertyName: "popup.viewModel.active", listener: (value: boolean) => void): SceneViewHandleCompat;
+    watch(propertyName: "popup.selectedFeatureIndex", listener: (value: number) => void): SceneViewHandleCompat;
+    watch(propertyName: "viewingMode", listener: (value: "global" | "local") => void): SceneViewHandleCompat;
+    watch(propertyName: "camera", listener: (value: unknown) => void): SceneViewHandleCompat;
+    watch(propertyName: string, listener: (value: unknown) => void): SceneViewHandleCompat;
+    setViewingMode(viewingMode: "global" | "local"): void;
+    setQualityProfile(qualityProfile: string | undefined): void;
+    setCamera(camera: unknown): void;
+    goTo(target: MapViewGoToInput, options?: MapViewGoToOptions): Promise<SceneViewCompat>;
+}
+//# sourceMappingURL=scene-view.d.ts.map

package/esri-compat/scene-view.d.ts.map

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

package/esri-compat/scene-view.js

@@ -0,0 +1,68 @@
+import { MapViewCompat, } from "./map-view.js";
+export class SceneViewCompat extends MapViewCompat {
+    viewingMode;
+    qualityProfile;
+    camera;
+    constructor(options = {}) {
+        super(options);
+        this.viewingMode = options.viewingMode ?? "global";
+        this.qualityProfile = options.qualityProfile;
+        this.camera = options.camera;
+    }
+    async load() {
+        await super.load();
+        return this;
+    }
+    async when(callback) {
+        const view = await this.load();
+        if (callback) {
+            callback(view);
+        }
+        return view;
+    }
+    watch(propertyName, listener) {
+        return super.watch(propertyName, listener);
+    }
+    setViewingMode(viewingMode) {
+        this.viewingMode = viewingMode;
+        this.notifyWatchers("viewingMode", this.viewingMode);
+        this.eventBus.emit("scene-view.viewing-mode-changed", { viewingMode }, this);
+    }
+    setQualityProfile(qualityProfile) {
+        this.qualityProfile = qualityProfile;
+        this.notifyWatchers("qualityProfile", this.qualityProfile);
+        this.eventBus.emit("scene-view.quality-profile-changed", { qualityProfile }, this);
+    }
+    setCamera(camera) {
+        this.camera = camera;
+        this.notifyWatchers("camera", this.camera);
+        this.eventBus.emit("scene-view.camera-changed", { camera }, this);
+    }
+    async goTo(target, options = {}) {
+        const camera = extractCameraTarget(target);
+        if (camera !== undefined) {
+            this.setCamera(camera);
+        }
+        await super.goTo(target, options);
+        return this;
+    }
+}
+function extractCameraTarget(target, visited = new Set()) {
+    if (typeof target !== "object" || target === null) {
+        return undefined;
+    }
+    if (visited.has(target)) {
+        return undefined;
+    }
+    visited.add(target);
+    if ("camera" in target && target.camera !== undefined) {
+        return target.camera;
+    }
+    if ("target" in target && target.target !== undefined) {
+        return extractCameraTarget(target.target, visited);
+    }
+    if ("position" in target || "heading" in target || "tilt" in target) {
+        return target;
+    }
+    return undefined;
+}