@splnlss/3d-story-viewer 0.5.0

package/build/types/src/main.d.ts

@@ -0,0 +1,95 @@
+export type Vector3Tuple = [number, number, number];
+export type GaussianSplatLayerDefinition = {
+    id: string;
+    name: string;
+    type: "gaussian-splat";
+    labels: string[];
+    data: {
+        url: string;
+        format: "ply" | "sog";
+    };
+    options: {
+        renderOrder?: 0;
+        transform: {
+            anchor: {
+                longitude: number;
+                latitude: number;
+                altitude: number;
+            };
+            translationENU?: Vector3Tuple;
+            rotationDegrees?: Vector3Tuple;
+            scale?: number;
+        };
+    };
+};
+export type TilesLayerDefinition = {
+    id: string;
+    name: string;
+    type: "3d-tiles";
+    labels: string[];
+    data: {
+        url: string;
+    };
+    options?: {
+        renderOrder?: number;
+        implicit?: boolean;
+        offset?: {
+            lon?: number;
+            lat?: number;
+            alt?: number;
+        };
+        blendeMode?: string;
+        firstSet?: unknown;
+    };
+};
+export type MeshLayerDefinition = {
+    id: string;
+    name: string;
+    type: "mesh";
+    labels: string[];
+    data: {
+        url: string;
+    };
+    options?: {
+        renderOrder?: number;
+        offset?: {
+            lon?: number;
+            lat?: number;
+            alt?: number;
+        };
+    };
+};
+export type GeojsonLayerDefinition = {
+    id: string;
+    name: string;
+    type: "geojson";
+    labels: string[];
+    data: {
+        type?: string;
+        features?: unknown[];
+    };
+    options?: {
+        renderOrder?: number;
+    };
+};
+export type ContentLayerDefinition = GaussianSplatLayerDefinition | TilesLayerDefinition | MeshLayerDefinition | GeojsonLayerDefinition;
+export type ContentLayerLoadProgress = {
+    loaded: number;
+    total: number;
+    lengthComputable: boolean;
+};
+export type ContentLayerLoadEvent = {
+    layerId: string;
+};
+export type ContentLayerProgressEvent = {
+    layerId: string;
+    progress: ContentLayerLoadProgress;
+};
+export type ContentLayerErrorEvent = {
+    layerId: string | null;
+    error: Error;
+};
+import Viewer from './viewer';
+import { ViewerEvents } from './viewer';
+import computeElevation from '../utils/elevation/index.js';
+export { Viewer, ViewerEvents, computeElevation };

package/build/types/src/modules/EventDispatcher.d.ts

@@ -0,0 +1,7 @@
+export class EventDispatcher {
+    listeners: {};
+    addEventListener(type: any, listener: any): void;
+    hasEventListener(type: any, listener: any): boolean;
+    removeEventListener(type: any, listener: any): void;
+    dispatchEvent(event: any): void;
+}

package/build/types/src/modules/StateDispatcher.d.ts

@@ -0,0 +1,18 @@
+export const DefaultStateDispatcher: StateDispatcher;
+export class StateDispatcher extends EventDispatcher {
+    constructor(values: any);
+    initialValues: {};
+    values: {};
+    define(values?: {}, overwrite?: boolean): {};
+    update(values?: {}, options?: {}): {};
+    get(keys: any): any;
+    reset(keys: any): {};
+    delete(keys?: any[]): {};
+    clone(): StateDispatcher;
+}
+export namespace StateDispatcherEvents {
+    let DEFINE: string;
+    let UPDATE: string;
+    let DELETE: string;
+}
+import { EventDispatcher } from './EventDispatcher';

package/build/types/src/viewer/CesiumInAuth.d.ts

@@ -0,0 +1,10 @@
+export class CesiumIonAuth {
+    constructor(options?: {});
+    apiToken: any;
+    autoRefreshToken: any;
+    authURL: any;
+    _tokenRefreshPromise: any;
+    _bearerToken: string;
+    fetch(url: any, options: any): Promise<Response>;
+    refreshToken(options: any): any;
+}

package/build/types/src/viewer/CesiumIonAuthPlugin.d.ts

@@ -0,0 +1,27 @@
+export class CesiumIonAuthPlugin {
+    constructor({ apiToken, assetId, autoRefreshToken, useRecommendedSettings }: {
+        apiToken: any;
+        assetId?: any;
+        autoRefreshToken?: boolean;
+        useRecommendedSettings?: boolean;
+    });
+    set apiToken(v: any);
+    get apiToken(): any;
+    set autoRefreshToken(v: any);
+    get autoRefreshToken(): any;
+    name: string;
+    priority: number;
+    auth: CesiumIonAuth;
+    assetId: any;
+    useRecommendedSettings: boolean;
+    tiles: any;
+    _tileSetVersion: number;
+    _attributions: any[];
+    init(tiles: any): void;
+    loadRootTileSet(): any;
+    preprocessURL(uri: any): any;
+    fetchData(uri: any, options: any): Promise<Response>;
+    getAttributions(target: any): void;
+    _initializeFromAsset(json: any): void;
+}
+import { CesiumIonAuth } from './CesiumInAuth.js';

package/build/types/src/viewer/ContentLayer/GaussianSplatLayer.d.ts

@@ -0,0 +1,17 @@
+export class GaussianSplatLayer extends ContentLayer {
+    constructor(definition: any, callbacks?: {});
+    isGaussianSplatLayer: boolean;
+    contentLayerId: any;
+    definition: any;
+    callbacks: {};
+    loadState: string;
+    loadAttempt: number;
+    abortController: AbortController;
+    splatMesh: SplatMesh;
+    visible: boolean;
+    transformMatrix: any;
+    load(): Promise<void>;
+    disposeMesh(mesh: any): void;
+}
+import { ContentLayer } from '.';
+import { SplatMesh } from '@sparkjsdev/spark';

package/build/types/src/viewer/ContentLayer/GeojsonLayer.d.ts

@@ -0,0 +1,6 @@
+export class GeojsonLayer extends ContentLayer {
+    constructor(data: any, options?: {});
+    isGeojsonLayer: boolean;
+    setTimeFrame(start: any, end: any): void;
+}
+import { ContentLayer } from '.';

package/build/types/src/viewer/ContentLayer/MeshLayer.d.ts

@@ -0,0 +1,6 @@
+export class MeshLayer extends ContentLayer {
+    constructor(url: any, options?: {});
+    isMeshLayer: boolean;
+    mesh: any;
+}
+import { ContentLayer } from '.';

package/build/types/src/viewer/ContentLayer/TilesLayer.d.ts

@@ -0,0 +1,12 @@
+export class TilesLayer extends ContentLayer {
+    constructor(url: any, options?: {});
+    isTilesLayer: boolean;
+    firstSet: any;
+    camera: any;
+    renderer: any;
+    dracoLoader: any;
+    ktx2loader: any;
+    tiles: TilesRenderer<import("3d-tiles-renderer").TilesRendererEventMap>;
+}
+import { ContentLayer } from '.';
+import { TilesRenderer } from '3d-tiles-renderer';

package/build/types/src/viewer/ContentLayer/gaussianSplatUtils.d.ts

@@ -0,0 +1,2 @@
+export function validateGaussianSplatLayerDefinition(definition: any): any;
+export function makeGaussianSplatTransform(transform: any): any;

package/build/types/src/viewer/ContentLayer/index.d.ts

@@ -0,0 +1,11 @@
+export class ContentLayer {
+    type: string;
+    isContentLayer: boolean;
+    labels: Set<any>;
+    setLabels(labels: any): void;
+    setEnabled(enabled: any): void;
+    visible: any;
+    update(): void;
+    dispose(): void;
+    disposeObjectResources(root?: this): void;
+}

package/build/types/src/viewer/EnvironmentControls.d.ts

@@ -0,0 +1,82 @@
+export const NONE: 0;
+export const DRAG: 1;
+export const ROTATE: 2;
+export const ZOOM: 3;
+export const WAITING: 4;
+export class EnvironmentControls {
+    constructor(scene?: any, camera?: any, domElement?: any, tilesRenderer?: any);
+    set enabled(v: boolean);
+    get enabled(): boolean;
+    _enabled: boolean;
+    isEnvironmentControls: boolean;
+    domElement: any;
+    camera: any;
+    scene: any;
+    tilesRenderer: any;
+    cameraRadius: number;
+    rotationSpeed: number;
+    minAltitude: number;
+    maxAltitude: number;
+    minDistance: number;
+    maxDistance: number;
+    minZoom: number;
+    maxZoom: number;
+    zoomSpeed: number;
+    adjustHeight: boolean;
+    enableDamping: boolean;
+    dampingFactor: number;
+    fallbackPlane: any;
+    useFallbackPlane: boolean;
+    scaleZoomOrientationAtEdges: boolean;
+    autoAdjustCameraRotation: boolean;
+    state: number;
+    pointerTracker: any;
+    needsUpdate: boolean;
+    actionHeightOffset: number;
+    pivotPoint: any;
+    zoomDirectionSet: boolean;
+    zoomPointSet: boolean;
+    zoomDirection: any;
+    zoomPoint: any;
+    zoomDelta: number;
+    rotationInertiaPivot: any;
+    rotationInertia: any;
+    dragInertia: any;
+    inertiaTargetDistance: number;
+    inertiaStableFrames: number;
+    pivotMesh: any;
+    raycaster: any;
+    up: any;
+    clock: any;
+    _detachCallback: () => void;
+    _upInitialized: boolean;
+    _lastUsedState: number;
+    _zoomPointWasSet: boolean;
+    _tilesOnChangeCallback: () => boolean;
+    setScene(scene: any): void;
+    setCamera(camera: any): void;
+    setTilesRenderer(tilesRenderer: any): void;
+    attach(domElement: any): void;
+    detach(): void;
+    getUpDirection(point: any, target: any): void;
+    getCameraUpDirection(target: any): void;
+    getPivotPoint(target: any): any;
+    resetState(): void;
+    setState(state?: number, fireEvent?: boolean): void;
+    update(deltaTime?: number): void;
+    adjustCamera(camera: any): void;
+    dispose(): void;
+    _updateInertia(deltaTime: any): void;
+    _inertiaNeedsUpdate(): boolean;
+    _updateZoom(): void;
+    _updateZoomDirection(): void;
+    _updateZoomPoint(): boolean;
+    _getPointBelowCamera(point?: any, up?: any): any;
+    _updatePosition(deltaTime: any): void;
+    _updateRotation(deltaTime: any): void;
+    _applyRotation(x: any, y: any, pivotPoint: any): void;
+    _setFrame(newUp: any): void;
+    _raycast(raycaster: any): any;
+    _alignCameraUp(up: any, alpha?: number): void;
+    _clampRotation(up: any): void;
+}

package/build/types/src/viewer/GlobeControls.d.ts

@@ -0,0 +1,30 @@
+export class GlobeControls extends EnvironmentControls {
+    get tilesGroup(): any;
+    get ellipsoidFrame(): any;
+    get ellipsoidFrameInverse(): any;
+    isGlobeControls: boolean;
+    _dragMode: number;
+    _rotationMode: number;
+    nearMargin: number;
+    farMargin: number;
+    globeInertia: any;
+    globeInertiaFactor: number;
+    ellipsoid: Ellipsoid;
+    ellipsoidGroup: any;
+    _ellipsoidFrameInverse: any;
+    setEllipsoid(ellipsoid: any, ellipsoidGroup: any): void;
+    getVectorToCenter(target: any): any;
+    getDistanceToCenter(): any;
+    setState(...args: any[]): void;
+    _updateRotation(...args: any[]): void;
+    _alignCameraUpToNorth(alpha: any): void;
+    _tiltTowardsCenter(alpha: any): void;
+    _getPerspectiveTransitionDistance(): number;
+    _getMaxPerspectiveDistance(): number;
+    _getOrthographicTransitionZoom(): number;
+    _getMinOrthographicZoom(): number;
+    _getVirtualOrthoCameraPosition(target: any, camera?: any): void;
+    _isNearControls(): boolean;
+}
+import { EnvironmentControls } from './EnvironmentControls.js';
+import { Ellipsoid } from '../../node_modules/3d-tiles-renderer/src/three/renderer/math/Ellipsoid.js';

package/build/types/src/viewer/GlobeManager.d.ts

@@ -0,0 +1,15 @@
+export class GlobeManager extends EventDispatcher {
+    constructor(scene: any, camera: any, renderer: any, options?: {});
+    scene: any;
+    camera: any;
+    renderer: any;
+    tiles: TilesRenderer<import("3d-tiles-renderer").TilesRendererEventMap>;
+    apiToken: any;
+    googleMapsToken: any;
+    initTiles(): void;
+    dracoLoader: any;
+    update(): void;
+    dispose(): void;
+}
+import { EventDispatcher } from '../modules/EventDispatcher';
+import { TilesRenderer } from '3d-tiles-renderer';

package/build/types/src/viewer/RGBEPromise.d.ts

@@ -0,0 +1 @@
+export function RGBEPromise(url: any, options?: {}): Promise<any>;

package/build/types/src/viewer/Sky.d.ts

@@ -0,0 +1,6 @@
+export class Sky {
+    isSky: boolean;
+    type: string;
+    material: any;
+    setSurfaceUp(v: any): void;
+}

package/build/types/src/viewer/TransitionControls.d.ts

@@ -0,0 +1,13 @@
+export class TransitionControls extends EventDispatcher {
+    constructor(camera: any);
+    camera: any;
+    lookAt: any;
+    cameraTween: any;
+    lookAtTween: any;
+    is2D: boolean;
+    animateTo(position: any, quaternion: any, duration?: number): Promise<any>;
+    update(time: any): void;
+    cancel(): void;
+    cameraUpTween: any;
+}
+import { EventDispatcher } from '../modules/EventDispatcher';

package/build/types/src/viewer/constants.d.ts

@@ -0,0 +1,45 @@
+export const NAMESPACE: "hvwr";
+export namespace AppEnvironments {
+    let PRODUCTION: string;
+    let STAGING: string;
+    let DEVELOPMENT: string;
+}
+export namespace BrowserTypes {
+    let UNDEFINED: string;
+    let CHROME: string;
+    let FIREFOX: string;
+    let SAFARI: string;
+    let EDGE: string;
+    let IE: string;
+}
+export namespace Bytes {
+    let FLOAT32: number;
+    let UINT16: number;
+    let UINT8: number;
+}
+export namespace DeviceTypes {
+    let DESKTOP: string;
+    let MOBILE: string;
+}
+export namespace IndicatorStates {
+    let IDLE: string;
+    let HOVER: string;
+    let ACTIVE: string;
+}
+export namespace OSTypes {
+    let UNDEFINED_1: string;
+    export { UNDEFINED_1 as UNDEFINED };
+    export let LINUX: string;
+    export let MAC_OS: string;
+    export let WINDOWS: string;
+    export let IOS: string;
+    export let ANDROID: string;
+}
+export namespace Tokens {
+    let CESIUM: any;
+    let GOOGLEMAPS: any;
+}
+export namespace TweenSettings {
+    let DURATION: number;
+    let EASING: (amount: number) => number;
+}

package/build/types/src/viewer/index.d.ts

@@ -0,0 +1,107 @@
+declare class Viewer extends EventDispatcher {
+    constructor(container: any, options?: {});
+    isViewer: boolean;
+    type: string;
+    disposed: boolean;
+    sparkRenderer: SparkRenderer;
+    state: StateDispatcher;
+    renderer: any;
+    css2DRenderer: any;
+    clock: any;
+    camera: any;
+    cameraForward: any;
+    cameraRight: any;
+    cameraUp: any;
+    scene: any;
+    content: any;
+    topLayerIndex: number;
+    enabledLayers: any[];
+    labels: Map<any, any>;
+    features: Map<any, any>;
+    globeControls: GlobeControls;
+    _onGlobeControlsStart: () => void;
+    transitionControls: TransitionControls;
+    globeManager: GlobeManager;
+    cameraCoords: {};
+    pointerCoords: {};
+    pointerXYZ: any;
+    keysDown: {};
+    keysEnabled: boolean;
+    movementKeys: {
+        BOOST: string[];
+        FRONT: string[];
+        BACK: string[];
+        LEFT: string[];
+        RIGHT: string[];
+        UP: string[];
+        DOWN: string[];
+    };
+    movementState: {
+        BOOST: boolean;
+        FRONT: boolean;
+        BACK: boolean;
+        LEFT: boolean;
+        RIGHT: boolean;
+        UP: boolean;
+        DOWN: boolean;
+    };
+    _onKeyDown: (event: any) => void;
+    _onKeyUp: (event: any) => void;
+    _onResize: (event: any) => void;
+    sky: Sky;
+    pointerRaycaster: any;
+    _onPointerMove: (event: any) => void;
+    updateMovementState(): void;
+    getElevation(lon: any, lat: any): {
+        lon: number;
+        lat: number;
+        alt: number;
+    };
+    updateCoordsElevation(coords: any): any;
+    setBackgroundColor(color: any): void;
+    appendTo(container: any): void;
+    container: any;
+    stats: any;
+    updateCameraDirections(): void;
+    setAnimate(bool?: boolean): void;
+    resizeView(event: any): void;
+    loadEnv(url: any): Promise<void>;
+    clearContentLayers(): void;
+    ensureSparkRenderer(): SparkRenderer;
+    disposeSparkRenderer(): void;
+    /** @param {import('../main.js').ContentLayerDefinition[]} content */
+    defineContentLayers(content?: import("../main.js").ContentLayerDefinition[]): void;
+    enableContentLayers(labels?: any[]): void;
+    setTimeFrame(start: any, end: any): void;
+    timeFrameStart: Date;
+    timeFrameEnd: Date;
+    updateLabel(id: any, params?: {}): any;
+    animate(time: any): void;
+    render(): void;
+    getCameraPivot(): any;
+    alignCamera(lon: any, lat: any, alt: any, pitch?: any, yaw?: any, roll?: any, duration?: number): Promise<void>;
+    focusCamera(lon: any, lat: any, alt: any, distance?: number, pitch?: any, duration?: number): Promise<void>;
+    angleCamera(pitch?: any, yaw?: any, duration?: number): Promise<void>;
+    setViewMode(mode?: string): void;
+    exportScene(): void;
+    saveScreenshot(name?: string): void;
+    dispose(): void;
+}
+export namespace ViewerEvents {
+    let APPENDED: "viewer-appended";
+    let READY: "viewer-ready";
+    let ANIMATED: "viewer-animated";
+    let TRANSITIONED: "viewer-transitioned";
+    let CONTENT_LAYER_LOAD_START: "content-layer-load-start";
+    let CONTENT_LAYER_LOAD_PROGRESS: "content-layer-load-progress";
+    let CONTENT_LAYER_READY: "content-layer-ready";
+    let CONTENT_LAYER_ERROR: "content-layer-error";
+}
+import { EventDispatcher } from '../modules/EventDispatcher';
+import { SparkRenderer } from '@sparkjsdev/spark';
+import { StateDispatcher } from '../modules/StateDispatcher';
+import { GlobeControls } from './GlobeControls';
+import { TransitionControls } from './TransitionControls';
+import { GlobeManager } from './GlobeManager';
+import { Sky } from './Sky';
+export { Viewer as default };

package/build/types/src/viewer/mods.d.ts

@@ -0,0 +1 @@
+export { ShaderChunk as default };

package/build/types/src/viewer/shaders/chunks.d.ts

@@ -0,0 +1 @@
+export { ShaderChunk as default };

package/build/types/src/viewer/utils.d.ts

@@ -0,0 +1,17 @@
+export function ecefToGeodeticPosition(x: any, y: any, z: any): {
+    lon: number;
+    lat: number;
+    alt: number;
+};
+export function geodeticToEcefPosition(lon: any, lat: any, alt: any): number[];
+export function ecefToGeodeticRotation(x: any, y: any, z: any, quaternion: any): {
+    lon: number;
+    lat: number;
+    alt: number;
+    pitch: number;
+    yaw: any;
+    roll: any;
+};
+export function geodeticToEcefUpVector(lon: any, lat: any): any;
+export function geodeticToEcefRotation(lon: any, lat: any, pitch: any, yaw: any, roll: any): any;
+export function exportScene(root: any): void;

package/build/types/src/workers/WorkerPool.d.ts

@@ -0,0 +1,16 @@
+export class WorkerPool {
+    constructor(limit?: number);
+    limit: number;
+    queue: any[];
+    workers: any[];
+    workersResolve: any[];
+    workerStatus: number;
+    workerCreator: any;
+    initWorker(workerId: any): void;
+    getIdleWorker(): number;
+    onMessage(workerId: any, msg: any): void;
+    setWorkerCreator(workerCreator: any): void;
+    setWorkerLimit(limit: any): void;
+    postMessage(msg: any, transfer: any): Promise<any>;
+    dispose(): void;
+}

package/build/types/src/workers/geojson.worker.d.ts

@@ -0,0 +1,2 @@
+declare const self: Window & typeof globalThis;
+export default self;

package/build/types/utils/elevation/gltf.d.ts

@@ -0,0 +1,15 @@
+export function rayIntersectsTriangle(rayOrigin: any, rayDir: any, v0: any, v1: any, v2: any): {
+    t: number;
+    point: any[];
+    barycentric: number[];
+};
+export function dot(a: any, b: any): number;
+export function cross(a: any, b: any): number[];
+export function normalize(vec: any): any;
+export function loadGltf(url: any): Promise<import("@loaders.gl/gltf").GLTFWithBuffers>;
+export function raycastMesh(rayOrigin: any, rayDir: any, positions: any, indices: any): {
+    t: number;
+    point: any[];
+    barycentric: number[];
+};
+export function intersectGltf(nodes: any, meshes: any, point: any): any;

package/build/types/utils/elevation/index.d.ts

@@ -0,0 +1,6 @@
+export default computeElevation;
+declare function computeElevation(lon: any, lat: any, options: any): Promise<{
+    lon: number;
+    lat: number;
+    alt: number;
+}>;

package/build/types/utils/elevation/test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/utils/elevation/tiles.d.ts

@@ -0,0 +1,43 @@
+export function ecefToGeodeticPosition(x: any, y: any, z: any): {
+    lon: number;
+    lat: number;
+    alt: number;
+};
+export function geodeticToEcefPosition(lon: any, lat: any, alt: any): number[];
+export function buildTileUrl(path: any, apiKey: any): URL;
+export function fetchTileset(url: any, apiKey: any): Promise<any>;
+export function obbToBox(obb: any): {
+    position: any[];
+    rotation: number[];
+    size: number[];
+};
+export function pointInOBB(point: any, obb: any): boolean;
+export function rayIntersectsOBB(rayOrigin: any, rayDir: any, obb: any): boolean;
+export function getOGC3DTile(point: any, maxDepth: number, apiKey: any): Promise<any[]>;
+export function getDeepestTile(tileQueue: any): any;
+export namespace logColors {
+    let reset: string;
+    let bright: string;
+    let dim: string;
+    let underscore: string;
+    let blink: string;
+    let reverse: string;
+    let hidden: string;
+    let fgBlack: string;
+    let fgRed: string;
+    let fgGreen: string;
+    let fgYellow: string;
+    let fgBlue: string;
+    let fgMagenta: string;
+    let fgCyan: string;
+    let fgWhite: string;
+    let bgBlack: string;
+    let bgRed: string;
+    let bgGreen: string;
+    let bgYellow: string;
+    let bgBlue: string;
+    let bgMagenta: string;
+    let bgCyan: string;
+    let bgWhite: string;
+}
+export let sessionKeyCache: any;