@wemap/viewer 0.0.0-stage → 14.8.0-beta.4

package/dist/src/WemapViewer.d.ts

@@ -0,0 +1,149 @@
+import { Coordinates } from '@wemap/geo';
+import { ClickMode } from './graph/PanoramaPointer';
+import { ViewerNode, ViewerOptions, OpenOptions, LocatedPoint, Measurement, VisionGeojsonGraph, ViewerPolygon, ViewerClick } from './types';
+/** Events a {@link WemapViewer} emits. Subscribe with `viewer.on(...)`. */
+export interface ViewerEvents {
+    /** Fired as soon as a move to a node starts, and again with the node still on screen if its image fails. */
+    navigate: ViewerNode;
+    /** Fired when the look heading changes (degrees). */
+    heading: number;
+    /** Fired once, when the first panorama is on screen. */
+    ready: void;
+    /** Fired with the position under a click, in `locate` click mode. */
+    locate: LocatedPoint;
+    /** Fired with the distance between two clicks, in `measure` click mode. */
+    measure: Measurement;
+    /** A click that walks nowhere, in `navigate` mode: above the horizon, or on the floor with no node there. */
+    click: ViewerClick;
+}
+/**
+ * Framework-agnostic 360° panorama viewer. Renders the Wemap image graph as an
+ * equirectangular sphere; moving to another node runs a panorama transition
+ * (see `transition/PanoramaTransition`).
+ *
+ * Requires `@wemap/core` to be initialized (`core.init()`) before use — it reads
+ * the VPS endpoint and emmid from `CoreConfig`.
+ *
+ * ```ts
+ * await core.init({ emmid, token });
+ * const viewer = new WemapViewer(el, { onNavigate: (id) => ... });
+ * await viewer.open(nodeId, { heading: 90 });
+ * ```
+ */
+export declare class WemapViewer {
+    private container;
+    private options;
+    private scene;
+    private camera;
+    private renderer;
+    private sphereObject;
+    private sphere;
+    private transition;
+    private controls;
+    private pointer;
+    private measureOverlay;
+    private polygonOverlay;
+    /** First point of a measurement in progress (pixel of the shown image). */
+    private measureStart;
+    /** Bumped on every reset, so a late answer for a cleared measurement is dropped. */
+    private measureRun;
+    private data;
+    private nodes;
+    private graph;
+    private current;
+    /** Settles when the current node's image is on screen (or overtaken). */
+    private arrival;
+    private geojson;
+    private listeners;
+    private turn;
+    private readyFired;
+    private rafId;
+    private resizeObserver;
+    constructor(container: HTMLElement, options?: ViewerOptions);
+    /**
+     * Open the viewer on a node: by id, or the nearest node to a position (on its
+     * level when it has one). The first call fetches the image graph. Resolves once
+     * that node's image is on screen, or once a later move overtakes it; rejects if
+     * the node is unknown or the graph or the image fails to load.
+     *
+     * `heading` / `pitch` (degrees) set where to look: instantly on the first open,
+     * as an animated turn after that. Without them the look direction is kept.
+     */
+    open(target: number | Coordinates, options?: OpenOptions): Promise<void>;
+    /**
+     * Fetch the image graph without opening a photo, e.g. to find the nearest
+     * node or draw the graph before showing anything. Fetched once and shared
+     * with `open()`; a failed fetch is retried by the next call.
+     */
+    loadGraph(): Promise<ViewerNode[]>;
+    /** Look at a heading: instantly before anything is on screen, animated after. */
+    private face;
+    /** The nodes of the image graph (empty until `loadGraph()` or the first `open()` has fetched it). */
+    getNodes(): ViewerNode[];
+    get currentNode(): ViewerNode | null;
+    /**
+     * The graph as GeoJSON (LineString edges + Point nodes), for drawing on a map.
+     * Fetched and cached on first call. Used by the `@wemap/viewer-map` bridge.
+     */
+    getGraphGeojson(): Promise<VisionGeojsonGraph>;
+    /**
+     * Subscribe to a viewer event. Returns an unsubscribe function. Unlike the
+     * `onXxx` constructor options (single callback each), any number of listeners
+     * can subscribe here — this is what the map bridges use.
+     */
+    on<K extends keyof ViewerEvents>(event: K, callback: (payload: ViewerEvents[K]) => void): () => void;
+    private emit;
+    /**
+     * Move to another node by id; no-op if unknown or already current. `navigate`
+     * fires right away. If the node's image then fails to load, the viewer goes
+     * back to the node still on screen (`navigate` again) and reports `onError`.
+     */
+    navigateTo(nodeId: number): void;
+    /**
+     * Make `node` current and bring its image on screen. The camera (lon/lat) is
+     * left untouched: the look direction is a real-world compass heading, so the
+     * user keeps facing the same way. On failure, falls back to the
+     * node still on screen.
+     */
+    private moveTo;
+    private fireReady;
+    private setCurrent;
+    /**
+     * Node closest to a geo position, on `level` when given. Null when the graph
+     * is not loaded yet (see `loadGraph()`) or has no node on that level.
+     */
+    nearestNode(to: Coordinates, level?: number): ViewerNode | null;
+    private closestNode;
+    /**
+     * Draw these polygons over the panorama, replacing the ones drawn before; an
+     * empty list clears them. They are anchored in the world, so they follow the
+     * user from node to node. The panorama has no depth: a polygon behind a wall
+     * still shows.
+     */
+    setPolygons(polygons: ViewerPolygon[]): void;
+    /** Turn to a compass heading and pitch (degrees), animated the short way round. */
+    lookAt(heading: number, pitch?: number): void;
+    resize(): void;
+    /** Tear down the renderer, controls, observers and DOM. */
+    destroy(): void;
+    /** What a click on the panorama does: walk (`navigate`, the default), `locate` or `measure`. */
+    get clickMode(): ClickMode;
+    /**
+     * Switch what a click on the panorama does, instead of walking:
+     * - `locate`: a click reports the geo position under it (`locate` / `onLocate`).
+     * - `measure`: two clicks report the distance between the two points
+     *   (`measure` / `onMeasure`), drawn as two dots and a line; a third click
+     *   clears them.
+     */
+    setClickMode(mode: ClickMode): void;
+    /** One click of a measurement: first point, second point (then measure), or clear. */
+    private measureAt;
+    private clearMeasurement;
+    /** Locate what is under a click, from the shown node's image and the VPS depth. */
+    private locateAt;
+    /** Current look heading in degrees (0 = north, clockwise). */
+    getHeading(): number;
+    private emitHeading;
+    private animate;
+}
+//# sourceMappingURL=WemapViewer.d.ts.map

package/dist/src/WemapViewer.d.ts.map

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

package/dist/src/controls/SphereControls.d.ts

@@ -0,0 +1,63 @@
+import { EventDispatcher, Object3D, PerspectiveCamera } from 'three';
+export interface SphereControlsConfig {
+    zoomEnable?: boolean;
+    minFov?: number;
+    maxFov?: number;
+}
+type Events = {
+    change: object;
+    start: object;
+    end: object;
+};
+/**
+ * Drag / wheel / keyboard orbit controller for looking around an equirectangular
+ * sphere, with inertia; its animations run on the viewer's shared tween group.
+ */
+declare class SphereControls extends EventDispatcher<Events> {
+    config: SphereControlsConfig;
+    minFov: number;
+    maxFov: number;
+    defaultFov: number;
+    _autoRotate: boolean;
+    autoRotateSpeed: number;
+    sensibility: number;
+    camera: PerspectiveCamera;
+    sphere: Object3D;
+    _lat: number;
+    _lon: number;
+    isUserInteracting: boolean;
+    onMouseDownMouseX: number;
+    onMouseDownMouseY: number;
+    onMouseDownLon: number;
+    onMouseDownLat: number;
+    autoRotateTimestamp: number;
+    private isArrowKeyPressed;
+    private currentTween;
+    private velocityLon;
+    private velocityLat;
+    private lastMouseX;
+    private lastMouseY;
+    private lastUpdateTime;
+    private animationFrameId;
+    private element;
+    constructor(element: HTMLElement, camera: PerspectiveCamera, sphere: Object3D, config?: SphereControlsConfig);
+    /** Detach every listener. Call from the viewer's `destroy()`. */
+    dispose(): void;
+    get lat(): number;
+    set lat(lat: number);
+    get lon(): number;
+    set lon(lon: number);
+    get autoRotate(): boolean;
+    set autoRotate(autoRotate: boolean);
+    updateFov(fov: number): void;
+    retrieveLatLonFromCamera(): void;
+    onPointerStart: (event: TouchEvent | MouseEvent) => void;
+    onPointerMove: (event: TouchEvent | MouseEvent) => void;
+    onPointerUp: (event: TouchEvent | MouseEvent) => void;
+    onDocumentMouseWheel: (event: WheelEvent) => void;
+    private onKeyDown;
+    update(): void;
+    private updateVelocity;
+}
+export default SphereControls;
+//# sourceMappingURL=SphereControls.d.ts.map

package/dist/src/controls/SphereControls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SphereControls.d.ts","sourceRoot":"","sources":["../../../src/controls/SphereControls.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,eAAe,EAEf,KAAK,QAAQ,EACb,KAAK,iBAAiB,EAEvB,MAAM,OAAO,CAAC;AAef,MAAM,WAAW,oBAAoB;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,KAAK,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7D;;;GAGG;AACH,cAAM,cAAe,SAAQ,eAAe,CAAC,MAAM,CAAC;IAClD,MAAM,EAAE,oBAAoB,CAAC;IAE7B,MAAM,SAAM;IACZ,MAAM,SAAO;IACb,UAAU,SAAM;IAEhB,WAAW,UAAS;IACpB,eAAe,SAAQ;IAEvB,WAAW,SAAO;IAElB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,QAAQ,CAAC;IAEjB,IAAI,SAAK;IACT,IAAI,SAAK;IAET,iBAAiB,UAAS;IAC1B,iBAAiB,SAAK;IACtB,iBAAiB,SAAK;IACtB,cAAc,SAAK;IACnB,cAAc,SAAK;IACnB,mBAAmB,SAAK;IAExB,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,YAAY,CAAqC;IAGzD,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,gBAAgB,CAAuB;IAE/C,OAAO,CAAC,OAAO,CAAc;gBAG3B,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,QAAQ,EAChB,MAAM,GAAE,oBAAyB;IAwCnC,iEAAiE;IACjE,OAAO;IAgBP,IAAI,GAAG,WAEN;IAED,IAAI,GAAG,CAAC,GAAG,QAAA,EAGV;IAED,IAAI,GAAG,WAEN;IAED,IAAI,GAAG,CAAC,GAAG,QAAA,EAGV;IAED,IAAI,UAAU,YAEb;IAED,IAAI,UAAU,CAAC,UAAU,SAAA,EAQxB;IAED,SAAS,CAAC,GAAG,EAAE,MAAM;IAoBrB,wBAAwB;IAUxB,cAAc,GAAI,OAAO,UAAU,GAAG,UAAU,UA0B9C;IAEF,aAAa,GAAI,OAAO,UAAU,GAAG,UAAU,UA4B7C;IAEF,WAAW,GAAI,OAAO,UAAU,GAAG,UAAU,UAS3C;IAEF,oBAAoB,GAAI,OAAO,UAAU,UAMvC;IAEF,OAAO,CAAC,SAAS,CA0Bf;IAEF,MAAM;IA+CN,OAAO,CAAC,cAAc,CAqBpB;CACH;AAED,eAAe,cAAc,CAAC"}

package/dist/src/data/ViewerDataClient.d.ts

@@ -0,0 +1,31 @@
+import { Coordinates } from '@wemap/geo';
+import { VisionGraph, VisionGeojsonGraph, ViewerNode } from '../types';
+/**
+ * Map a raw {@link VisionGraph} to renderable {@link ViewerNode}s. Pure — no
+ * network, no config — so it is unit-testable.
+ */
+export declare function graphToNodes(graph: VisionGraph, imageUrl: (filename: string) => string): ViewerNode[];
+/**
+ * Fetches the 360° image graph and resolves image URLs from the Wemap VPS
+ * endpoint. The endpoint comes from `@wemap/core` (`CoreConfig.getViewerOptions`)
+ * unless one is passed explicitly (e.g. for tests or staging).
+ */
+export declare class ViewerDataClient {
+    private endpoint;
+    constructor(endpoint?: string);
+    imageUrl(filename: string): string;
+    getGraph(): Promise<VisionGraph>;
+    getGraphGeojson(): Promise<VisionGeojsonGraph>;
+    getNodes(): Promise<ViewerNode[]>;
+    /**
+     * Geo position of what is under pixel (x, y) of a node's image, from the
+     * VPS depth estimate. Takes the node's level when the answer has none.
+     */
+    locate(node: ViewerNode, x: number, y: number): Promise<Coordinates>;
+    /**
+     * Distance in metres between what is under two pixels of a node's image,
+     * from the VPS depth estimate.
+     */
+    measure(node: ViewerNode, from: [number, number], to: [number, number]): Promise<number>;
+}
+//# sourceMappingURL=ViewerDataClient.d.ts.map

package/dist/src/data/ViewerDataClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ViewerDataClient.d.ts","sourceRoot":"","sources":["../../../src/data/ViewerDataClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAU5E;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GACrC,UAAU,EAAE,CAad;AAED;;;;GAIG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,CAAC,EAAE,MAAM;IAW7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAIlC,QAAQ,IAAI,OAAO,CAAC,WAAW,CAAC;IAIhC,eAAe,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAIxC,QAAQ,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;IAKvC;;;OAGG;IACG,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAQ1E;;;OAGG;IACG,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CAgB/F"}

package/dist/src/frame/SceneFrame.d.ts

@@ -0,0 +1,39 @@
+import { Quaternion, Vector3 } from 'three';
+import { Coordinates } from '@wemap/geo';
+import { ViewerNode } from '../types';
+/** Image `u` offset (turns) that aligns a node's image to north, given its capture heading. */
+export declare function northOffset(captureHeading: number): number;
+/**
+ * Image coordinates (u, v in 0..1) seen in `direction` for a node with this
+ * capture heading. TypeScript twin of the panorama shader's `equirect()`.
+ */
+export declare function imageUv(direction: Vector3, captureHeading: number): [number, number];
+/**
+ * Pixel (x right, y down from the top-left) of a node's equirectangular image
+ * seen in `direction`, for an image of `width` × `height` pixels.
+ */
+export declare function imagePixel(direction: Vector3, captureHeading: number, width: number, height: number): [number, number];
+/** Camera rotation that looks at a compass heading and pitch (degrees). */
+export declare function lookRotation(heading: number, pitch?: number, out?: Quaternion): Quaternion;
+/** Compass heading (degrees, 0..360) and pitch (degrees, positive up) of a scene direction. */
+export declare function directionAngles(direction: Vector3): {
+    heading: number;
+    pitch: number;
+};
+/** Compass heading (degrees, 0..360) a camera rotation looks at. */
+export declare function headingOf(rotation: Quaternion): number;
+/** Position of `target` in the frame of a node at `origin`, at camera height (y = 0). */
+export declare function toLocal(origin: Coordinates, target: Coordinates, out?: Vector3): Vector3;
+/**
+ * Position of `target` in the frame of a node at `origin`, height included: y is
+ * the altitude difference. Both need an altitude, in the same reference.
+ */
+export declare function toScene(origin: Coordinates, target: Coordinates, out?: Vector3): Vector3;
+/** Geo position of a point in the frame of a node at `origin` (height ignored). */
+export declare function toGeo(origin: Coordinates, point: Vector3): Coordinates;
+/**
+ * How far the camera travels when going from one node to the next, in the
+ * frame of `from`. Zero (just cross-fade) across levels or beyond 8 m.
+ */
+export declare function hop(from: ViewerNode | null, to: ViewerNode): Vector3;
+//# sourceMappingURL=SceneFrame.d.ts.map

package/dist/src/frame/SceneFrame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneFrame.d.ts","sourceRoot":"","sources":["../../../src/frame/SceneFrame.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAa,UAAU,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAY3C,+FAA+F;AAC/F,wBAAgB,WAAW,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,SAAS,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAMpF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,SAAS,EAAE,OAAO,EAClB,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,CAAC,MAAM,EAAE,MAAM,CAAC,CAGlB;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,SAAI,EAAE,GAAG,aAAmB,GAAG,UAAU,CAI3F;AAED,+FAA+F;AAC/F,wBAAgB,eAAe,CAAC,SAAS,EAAE,OAAO,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAMtF;AAED,oEAAoE;AACpE,wBAAgB,SAAS,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAGtD;AAED,yFAAyF;AACzF,wBAAgB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,UAAgB,GAAG,OAAO,CAI9F;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,UAAgB,GAAG,OAAO,CAK9F;AAED,mFAAmF;AACnF,wBAAgB,KAAK,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,GAAG,WAAW,CAItE;AAED;;;GAGG;AACH,wBAAgB,GAAG,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,EAAE,EAAE,EAAE,UAAU,GAAG,OAAO,CAMpE"}

package/dist/src/graph/MeasureOverlay.d.ts

@@ -0,0 +1,19 @@
+import { Scene, Vector3 } from 'three';
+/**
+ * The measurement drawn over the panorama: a red dot (white
+ * ring) on each clicked point and a red dashed line once there are two.
+ * Positions are view directions in the scene frame.
+ */
+export declare class MeasureOverlay {
+    private readonly scene;
+    private readonly group;
+    constructor(scene: Scene);
+    /** Number of points placed (0, 1 or 2). */
+    get count(): number;
+    /** Place a point in `direction`; the second one also draws the line. */
+    add(direction: Vector3): void;
+    /** Remove every point and the line. */
+    clear(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=MeasureOverlay.d.ts.map

package/dist/src/graph/MeasureOverlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeasureOverlay.d.ts","sourceRoot":"","sources":["../../../src/graph/MeasureOverlay.ts"],"names":[],"mappings":"AAAA,OAAO,EAUL,KAAK,KAAK,EACV,KAAK,OAAO,EACb,MAAM,OAAO,CAAC;AAef;;;;GAIG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAC9B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;gBAEzB,KAAK,EAAE,KAAK;IAKxB,2CAA2C;IAC3C,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,wEAAwE;IACxE,GAAG,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI;IA+B7B,uCAAuC;IACvC,KAAK,IAAI,IAAI;IAYb,OAAO,IAAI,IAAI;CAIhB"}

package/dist/src/graph/PanoramaPointer.d.ts

@@ -0,0 +1,59 @@
+import { Vector3, PerspectiveCamera, Scene } from 'three';
+import { Coordinates } from '@wemap/geo';
+import { ViewerNode } from '../types';
+/** What a click on the panorama does. */
+export type ClickMode = 'navigate' | 'locate' | 'measure';
+export interface PanoramaPointerCallbacks {
+    /** The node on screen, or null while none is (loading, mid-transition). */
+    current: () => ViewerNode | null;
+    /** Nearest other node on the same level as `to`, or null. */
+    nearest: (to: Coordinates) => ViewerNode | null;
+    /** `navigate` mode: the user clicked/tapped the floor near a node. */
+    select: (node: ViewerNode) => void;
+    /** `locate` / `measure` modes: the user clicked/tapped the panorama in this view direction. */
+    pick: (direction: Vector3) => void;
+    /** `navigate` mode: a click that walks nowhere (above the horizon, or no node there), in this view direction. */
+    miss: (direction: Vector3) => void;
+}
+/**
+ * Pointer interaction on the panorama. A drag that looks around is never a click.
+ *
+ * - `navigate` (walking): hovering the floor shows a disc under the
+ *   pointer and a cross on the nearest node; clicking walks there. Off when
+ *   `walk` is false.
+ * - `locate` / `measure`: a crosshair cursor; clicking reports the view
+ *   direction, to locate or measure what is under it.
+ *
+ * Positions are in the scene frame (see `frame/SceneFrame`), with the floor
+ * GROUND_OFFSET below the camera.
+ */
+export declare class PanoramaPointer {
+    /** What a click does. */
+    mode: ClickMode;
+    private readonly scene;
+    private readonly camera;
+    private readonly element;
+    private readonly callbacks;
+    private readonly walk;
+    private readonly raycaster;
+    private readonly floor;
+    private readonly pointer;
+    private readonly hit;
+    private readonly disc;
+    private readonly cross;
+    private pressedAt;
+    private target;
+    constructor(scene: Scene, camera: PerspectiveCamera, element: HTMLElement, callbacks: PanoramaPointerCallbacks, walk?: boolean);
+    /** Hide both markers (e.g. right after navigating, or when the mode changes). */
+    hide(): void;
+    dispose(): void;
+    private readonly onPointerMove;
+    private readonly onPointerDown;
+    private readonly onPointerUp;
+    private readonly onPointerLeave;
+    /** Point the raycaster from the camera through the pointer. */
+    private aim;
+    /** Refresh the hover feedback: floor disc, cross and target, or the locate cursor. */
+    private update;
+}
+//# sourceMappingURL=PanoramaPointer.d.ts.map

package/dist/src/graph/PanoramaPointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PanoramaPointer.d.ts","sourceRoot":"","sources":["../../../src/graph/PanoramaPointer.ts"],"names":[],"mappings":"AAAA,OAAO,EAWL,OAAO,EACP,KAAK,iBAAiB,EACtB,KAAK,KAAK,EACX,MAAM,OAAO,CAAC;AACf,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AA8B3C,yCAAyC;AACzC,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE1D,MAAM,WAAW,wBAAwB;IACvC,2EAA2E;IAC3E,OAAO,EAAE,MAAM,UAAU,GAAG,IAAI,CAAC;IACjC,6DAA6D;IAC7D,OAAO,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,UAAU,GAAG,IAAI,CAAC;IAChD,sEAAsE;IACtE,MAAM,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IACnC,+FAA+F;IAC/F,IAAI,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC,iHAAiH;IACjH,IAAI,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,eAAe;IAC1B,yBAAyB;IACzB,IAAI,EAAE,SAAS,CAAc;IAE7B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2B;IACrD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAU;IAE/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmB;IAC7C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkD;IACxE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAiB;IAErC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAO;IAC5B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;IAEjC,OAAO,CAAC,SAAS,CAAyC;IAC1D,OAAO,CAAC,MAAM,CAA2B;gBAGvC,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,wBAAwB,EACnC,IAAI,UAAO;IA6Bb,iFAAiF;IACjF,IAAI,IAAI,IAAI;IAOZ,OAAO,IAAI,IAAI;IAYf,OAAO,CAAC,QAAQ,CAAC,aAAa,CAK5B;IAEF,OAAO,CAAC,QAAQ,CAAC,aAAa,CAE5B;IAEF,OAAO,CAAC,QAAQ,CAAC,WAAW,CAwB1B;IAEF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAE7B;IAEF,+DAA+D;IAC/D,OAAO,CAAC,GAAG;IASX,sFAAsF;IACtF,OAAO,CAAC,MAAM;CAoCf"}

package/dist/src/graph/PolygonOverlay.d.ts

@@ -0,0 +1,22 @@
+import { Scene } from 'three';
+import { ViewerNode, ViewerPolygon } from '../types';
+/**
+ * Polygons anchored in the real world, drawn over the panorama. The scene frame is
+ * the shown node's, so they are placed again each time another node is shown;
+ * while the camera travels to the next node they stay where they are in the world.
+ * The panorama has no depth: a polygon behind a wall still shows.
+ */
+export declare class PolygonOverlay {
+    private readonly scene;
+    private readonly group;
+    private polygons;
+    private origin;
+    constructor(scene: Scene);
+    set(polygons: ViewerPolygon[]): void;
+    /** Place the polygons in the frame of `node`; nothing to do if it already is the origin. */
+    placeAt(node: ViewerNode | null): void;
+    private build;
+    private clear;
+    dispose(): void;
+}
+//# sourceMappingURL=PolygonOverlay.d.ts.map

package/dist/src/graph/PolygonOverlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PolygonOverlay.d.ts","sourceRoot":"","sources":["../../../src/graph/PolygonOverlay.ts"],"names":[],"mappings":"AAAA,OAAO,EAYL,KAAK,KAAK,EACX,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAyB1D;;;;;GAKG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAC9B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,MAAM,CAA2B;gBAE7B,KAAK,EAAE,KAAK;IAKxB,GAAG,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,IAAI;IAKpC,4FAA4F;IAC5F,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,GAAG,IAAI;IAQtC,OAAO,CAAC,KAAK;IAsCb,OAAO,CAAC,KAAK;IAUb,OAAO,IAAI,IAAI;CAIhB"}

package/dist/src/transition/PanoramaTransition.d.ts

@@ -0,0 +1,50 @@
+import { ShaderMaterial, Vector3, Texture } from 'three';
+import { ViewerNode } from '../types';
+/** Loads a node's panorama image as a texture. */
+export type ImageLoader = (url: string) => Promise<Texture>;
+/**
+ * Moves the panorama from the node on screen to another: waits for the new
+ * image, then fades it in while the camera travels between the two capture
+ * points (a plain fade across levels or long hops, a fade from black for the
+ * first image). Owns the panorama material and every texture it shows.
+ *
+ * Driven by the render loop: call {@link update} every frame with the current
+ * time and place the camera at the offset it returns.
+ */
+export declare class PanoramaTransition {
+    /** The panorama material, for the viewer's inside-out sphere. */
+    readonly material: ShaderMaterial;
+    private shownNode;
+    private pending;
+    private fade;
+    private disposed;
+    private readonly cameraOffset;
+    private readonly loadImage;
+    constructor(loadImage?: ImageLoader);
+    /** The node whose image is fully on screen: where the next transition starts from. */
+    get shown(): ViewerNode | null;
+    /** Pixel size of the shown node's image, or null before the first one is on screen. */
+    get shownImageSize(): {
+        width: number;
+        height: number;
+    } | null;
+    /** True while a requested node is loading or fading in. */
+    get busy(): boolean;
+    /**
+     * Go to a node. Resolves true once its image has loaded and the transition has
+     * started; false if a later {@link show} (or {@link dispose}) overtook it.
+     * Rejects if the image fails to load; the shown node then stays on screen.
+     * A transition still running when the new image arrives jumps to its end.
+     */
+    show(node: ViewerNode): Promise<boolean>;
+    /**
+     * Advance to `now` (ms, any monotonic clock). Returns where the camera sits,
+     * in the frame of the shown node: zero at rest.
+     */
+    update(now: number): Vector3;
+    /** Free the material and every texture, including images still loading. */
+    dispose(): void;
+    /** End the running fade: the incoming image becomes the shown one. */
+    private settle;
+}
+//# sourceMappingURL=PanoramaTransition.d.ts.map

package/dist/src/transition/PanoramaTransition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PanoramaTransition.d.ts","sourceRoot":"","sources":["../../../src/transition/PanoramaTransition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,cAAc,EAEd,OAAO,EACP,KAAK,OAAO,EACb,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAQ3C,kDAAkD;AAClD,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AA8E5D;;;;;;;;GAQG;AACH,qBAAa,kBAAkB;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,iBAAoB;IAErC,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,IAAI,CAAqB;IACjC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAiB;IAC9C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAc;gBAE5B,SAAS,GAAE,WAA2B;IAIlD,sFAAsF;IACtF,IAAI,KAAK,IAAI,UAAU,GAAG,IAAI,CAE7B;IAED,uFAAuF;IACvF,IAAI,cAAc,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAK7D;IAED,2DAA2D;IAC3D,IAAI,IAAI,IAAI,OAAO,CAElB;IAED;;;;;OAKG;IACG,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC;IA2C9C;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAgB5B,2EAA2E;IAC3E,OAAO,IAAI,IAAI;IAYf,sEAAsE;IACtE,OAAO,CAAC,MAAM;CAef"}

package/dist/src/tweens.d.ts

@@ -0,0 +1,11 @@
+import { Group } from '@tweenjs/tween.js';
+/**
+ * Shared tween group for the viewer: a tween.js Group that the render loop
+ * ticks each frame via {@link WemapViewer}.
+ *
+ * `SphereControls` and `WemapViewer.lookAt` add their tweens here; whoever
+ * added them removes them on complete. (The panorama transition runs on the
+ * render loop's clock instead.)
+ */
+export declare const tweenGroup: Group;
+//# sourceMappingURL=tweens.d.ts.map

package/dist/src/tweens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tweens.d.ts","sourceRoot":"","sources":["../../src/tweens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE1C;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,OAAc,CAAC"}

package/dist/src/types/index.d.ts

@@ -0,0 +1,147 @@
+import { Coordinates } from '@wemap/geo';
+/**
+ * A single node in the 360° image graph: one panorama image at a geo position,
+ * with the edges (transitions) to neighbouring nodes.
+ */
+export interface ViewerNode {
+    /** Keyframe id — unique within the graph. */
+    id: number;
+    /** Geo position of the capture point. */
+    coordinates: Coordinates;
+    /** Indoor level (0 = ground). */
+    level: number;
+    /** Absolute URL of the equirectangular image. */
+    image: string;
+    /** Capture heading in degrees, used to align the panorama to north. */
+    heading: number;
+}
+/**
+ * Behaviour options for a {@link WemapViewer}. Identity (emmid), auth and the
+ * VPS endpoint are NOT here — they come from `@wemap/core` (`core.init()`).
+ */
+export interface ViewerOptions {
+    /** Enable mouse-wheel zoom. Defaults to true. */
+    zoom?: boolean;
+    /** Widest vertical field of view the wheel zooms out to, in degrees. Defaults to 80. */
+    maxFov?: number;
+    /**
+     * In-panorama navigation: hovering the floor shows a disc and a
+     * cross on the nearest node; clicking walks there. Defaults to true.
+     */
+    navigation?: boolean;
+    /**
+     * Fired as soon as a move to a node starts (programmatically or by click), and
+     * again with the node still on screen if the new image fails to load.
+     */
+    onNavigate?: (nodeId: number) => void;
+    /** Fired when look heading changes (degrees), e.g. to sync a compass. */
+    onHeadingChange?: (heading: number) => void;
+    /** Fired once, when the first image is on screen. */
+    onReady?: () => void;
+    /** Fired with the position under a click, in `locate` click mode. */
+    onLocate?: (point: LocatedPoint) => void;
+    /** Fired with the distance between two clicks, in `measure` click mode. */
+    onMeasure?: (measurement: Measurement) => void;
+    /** Fired with the view direction of a click that walks nowhere, in `navigate` mode. */
+    onClick?: (click: ViewerClick) => void;
+    /** Fired when the graph, an image, a located point or a measurement fails to load. */
+    onError?: (error: Error) => void;
+}
+/** The distance between two clicked points in `measure` mode, from the VPS depth estimate. */
+export interface Measurement {
+    /** Distance in metres. */
+    distance: number;
+    /** The node whose image was clicked. */
+    node: ViewerNode;
+}
+/**
+ * A click on the panorama that walked nowhere: what the user pointed at, as a
+ * direction from the node on screen. Cast it against your own geometry to pick
+ * what is there (a shelf, a door).
+ */
+export interface ViewerClick {
+    /** Compass heading of the direction, degrees (0 = north, 90 = east). */
+    heading: number;
+    /** Pitch of the direction, degrees, positive up. */
+    pitch: number;
+    /** The node the direction starts from. */
+    node: ViewerNode;
+}
+/** What is under a click in `locate` mode, from the VPS depth estimate. */
+export interface LocatedPoint {
+    /** Geo position, with altitude and level (the node's when the VPS gives none). */
+    coordinates: Coordinates;
+    /** The node whose image was clicked. */
+    node: ViewerNode;
+}
+/**
+ * A polygon anchored in the real world, drawn over the panorama: an area on the
+ * floor, a shelf front, a door. See {@link WemapViewer.setPolygons}.
+ */
+export interface ViewerPolygon {
+    /** Vertices in order, not closed. Each needs an altitude, in the same reference as the graph nodes'. */
+    coordinates: Coordinates[];
+    /** Fill colour (CSS). Defaults to Wemap blue. */
+    color?: string;
+    /** Fill opacity, 0 to 1. Defaults to 0.25. */
+    fillOpacity?: number;
+    /** Outline colour (CSS). Defaults to `color`. */
+    outlineColor?: string;
+}
+/** Where {@link WemapViewer.open} makes the user look, in degrees. */
+export interface OpenOptions {
+    /** Look heading, 0 = north, 90 = east. Omit to keep the current look direction. */
+    heading?: number;
+    /** Look pitch, positive up. Defaults to 0 when `heading` is given. */
+    pitch?: number;
+}
+export interface VisionGraph {
+    images: Array<{
+        filename: string;
+        id: number;
+        coords: {
+            lat: number;
+            lng: number;
+            level: number;
+            alt?: number | null;
+        };
+        heading: number;
+    }>;
+    edges: Array<{
+        keyframeId1: number;
+        keyframeId2: number;
+        weight: number;
+        level: number | number[];
+    }>;
+}
+export interface GraphPoint {
+    type: 'Feature';
+    id: number;
+    properties: {
+        id: number;
+        level: number;
+        heading: number;
+    };
+    geometry: {
+        type: 'Point';
+        coordinates: [number, number];
+    };
+}
+export interface GraphLine {
+    type: 'Feature';
+    properties: {
+        keyframeId1: number;
+        keyframeId2: number;
+        weight: number;
+        level: number | [number, number];
+    };
+    geometry: {
+        type: 'LineString';
+        coordinates: [[number, number], [number, number]];
+    };
+}
+export interface VisionGeojsonGraph {
+    type: 'FeatureCollection';
+    features: Array<GraphLine | GraphPoint>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/types/index.d.ts.map

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

package/dist/style.css

@@ -0,0 +1,2 @@
+.wemap-viewer__canvas{touch-action:none;-webkit-user-select:none;user-select:none;cursor:grab;width:100%;height:100%;display:block}.wemap-viewer__canvas:active{cursor:grabbing}.wemap-viewer__canvas:focus:not(:focus-visible){outline:none}
+/*$vite$:1*/