@treasuryspatial/viewer-kit 0.2.31

package/README.md

@@ -0,0 +1,5 @@
+# @treasuryspatial/viewer-kit
+
+Framework-agnostic viewer core for Composer products.
+
+This package will host the stable viewer API and “systems” (renderer/environment/lighting/postfx/debug).

package/dist/camera.d.ts

@@ -0,0 +1,28 @@
+import * as THREE from "three";
+export type CameraFrameMode = "iso" | "interior";
+export type CameraFrameConfig = {
+    mode?: CameraFrameMode;
+    padding?: number;
+    direction?: [number, number, number];
+};
+export type CameraNormalizationConfig = {
+    recenter?: boolean;
+    floorToZero?: boolean;
+    normalizePlan?: {
+        target?: number;
+        maxScale?: number;
+    };
+};
+export type CameraNormalizationResult = {
+    bounds: THREE.Box3;
+    center: THREE.Vector3;
+    size: THREE.Vector3;
+    scale: number;
+    offset: THREE.Vector3;
+};
+export declare const normalizeObject3d: (object: THREE.Object3D, config?: CameraNormalizationConfig) => CameraNormalizationResult;
+export declare const computeCameraFrame: (bounds: THREE.Box3, fovDegrees: number, config?: CameraFrameConfig) => {
+    position: THREE.Vector3;
+    target: THREE.Vector3;
+};
+//# sourceMappingURL=camera.d.ts.map

package/dist/camera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera.d.ts","sourceRoot":"","sources":["../src/camera.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,UAAU,CAAC;AAEjD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC;IACnB,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC;IACtB,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC;CACvB,CAAC;AAKF,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,KAAK,CAAC,QAAQ,EACtB,SAAS,yBAAyB,KACjC,yBA8CF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,KAAK,CAAC,IAAI,EAClB,YAAY,MAAM,EAClB,SAAS,iBAAiB,KACzB;IAAE,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAA;CAoBlD,CAAC"}

package/dist/camera.js

@@ -0,0 +1,63 @@
+import * as THREE from "three";
+const DEFAULT_FRAME_PADDING = 1.22;
+const DEFAULT_FRAME_DIRECTION = [1, 0.7, 1];
+export const normalizeObject3d = (object, config) => {
+    const resolved = config ?? {};
+    const offset = new THREE.Vector3();
+    let scale = 1;
+    object.updateMatrixWorld(true);
+    let bounds = new THREE.Box3().setFromObject(object);
+    let size = new THREE.Vector3();
+    let center = new THREE.Vector3();
+    bounds.getSize(size);
+    bounds.getCenter(center);
+    const targetPlan = resolved.normalizePlan?.target;
+    if (typeof targetPlan === "number" && Number.isFinite(targetPlan) && targetPlan > 0) {
+        const planMax = Math.max(size.x, size.z);
+        if (planMax > 1e-6) {
+            const maxScale = resolved.normalizePlan?.maxScale ?? 3;
+            scale = Math.min(maxScale, targetPlan / planMax);
+            if (Number.isFinite(scale) && scale > 0 && scale !== 1) {
+                object.scale.multiplyScalar(scale);
+                object.updateMatrixWorld(true);
+                bounds = new THREE.Box3().setFromObject(object);
+                bounds.getSize(size);
+                bounds.getCenter(center);
+            }
+        }
+    }
+    if (resolved.recenter) {
+        offset.x -= center.x;
+        offset.z -= center.z;
+    }
+    if (resolved.floorToZero) {
+        offset.y -= bounds.min.y;
+    }
+    if (offset.lengthSq() > 0) {
+        object.position.add(offset);
+        object.updateMatrixWorld(true);
+        bounds = new THREE.Box3().setFromObject(object);
+        bounds.getSize(size);
+        bounds.getCenter(center);
+    }
+    return { bounds, center, size, scale, offset };
+};
+export const computeCameraFrame = (bounds, fovDegrees, config) => {
+    const size = new THREE.Vector3();
+    const center = new THREE.Vector3();
+    bounds.getSize(size);
+    bounds.getCenter(center);
+    const mode = config?.mode ?? "iso";
+    if (mode === "interior") {
+        const position = new THREE.Vector3(center.x, center.y + size.y * 0.2, center.z + size.z * 0.2);
+        return { position, target: center };
+    }
+    const padding = config?.padding ?? DEFAULT_FRAME_PADDING;
+    const direction = new THREE.Vector3(...(config?.direction ?? DEFAULT_FRAME_DIRECTION)).normalize();
+    const sphere = bounds.getBoundingSphere(new THREE.Sphere());
+    const radius = Math.max(0.5, sphere.radius);
+    const vFov = THREE.MathUtils.degToRad(fovDegrees);
+    const distance = (radius / Math.sin(vFov / 2)) * padding;
+    const position = center.clone().add(direction.multiplyScalar(distance));
+    return { position, target: center };
+};

package/dist/engine/ViewerEngine.d.ts

@@ -0,0 +1,41 @@
+import type { CameraState, RenderPresetDefinition, ViewerCreateOptions, ViewerHandle, ViewerSnapshot } from "./types";
+export declare class ViewerEngine {
+    private static readonly RUNTIME_PRESET_ID;
+    private container;
+    private renderer;
+    private scene;
+    private camera;
+    private controls;
+    private rootGroup;
+    private sceneBounds;
+    private environmentSystem;
+    private lightingSystem;
+    private postFxSystem;
+    private debugSystem;
+    private usePostprocessing;
+    private presets;
+    private presetId;
+    private running;
+    private animationFrame;
+    private lastWidth;
+    private lastHeight;
+    private maxPixelRatio;
+    constructor(options: ViewerCreateOptions);
+    getHandle(): ViewerHandle;
+    private invalidate;
+    start(): void;
+    stop(): void;
+    resize(): void;
+    dispose(): void;
+    setPreset(presetId: string): void;
+    setRuntimePreset(preset: RenderPresetDefinition): void;
+    setSceneRoot(root: unknown): void;
+    setCamera(state: Partial<CameraState>): void;
+    getCameraState(): CameraState;
+    capturePng(): Promise<Blob>;
+    getSnapshot(): ViewerSnapshot;
+    private getDebugInfo;
+    private applyPreset;
+    private resolvePreset;
+}
+//# sourceMappingURL=ViewerEngine.d.ts.map

package/dist/engine/ViewerEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ViewerEngine.d.ts","sourceRoot":"","sources":["../../src/engine/ViewerEngine.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAiB,WAAW,EAAiB,sBAAsB,EAAE,mBAAmB,EAAmB,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAQrK,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAiB;IAE1D,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,WAAW,CAA2B;IAE9C,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,iBAAiB,CAAU;IAEnC,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAS;gBAElB,OAAO,EAAE,mBAAmB;IAwDxC,SAAS,IAAI,YAAY;IAmBzB,OAAO,CAAC,UAAU;IAKlB,KAAK,IAAI,IAAI;IAgBb,IAAI,IAAI,IAAI;IAQZ,MAAM,IAAI,IAAI;IAcd,OAAO,IAAI,IAAI;IAef,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIjC,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI;IAStD,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IA6CjC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI;IAuB5C,cAAc,IAAI,WAAW;IAUvB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAmCjC,WAAW,IAAI,cAAc;IAe7B,OAAO,CAAC,YAAY;IAuCpB,OAAO,CAAC,WAAW;IAyBnB,OAAO,CAAC,aAAa;CAKtB"}

package/dist/engine/ViewerEngine.js

@@ -0,0 +1,344 @@
+import * as THREE from "three";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
+import { DEFAULT_PRESET_ID, DEFAULT_PRESETS } from "../presets/defaults";
+import { applyRendererConfig } from "../systems/rendererSystem";
+import { EnvironmentSystem } from "../systems/environmentSystem";
+import { LightingSystem } from "../systems/lightingSystem";
+import { PostFxSystem } from "../systems/postfxSystem";
+import { DebugSystem } from "../systems/debugSystem";
+export class ViewerEngine {
+    static RUNTIME_PRESET_ID = "__runtime__";
+    container;
+    renderer;
+    scene;
+    camera;
+    controls;
+    rootGroup;
+    sceneBounds = null;
+    environmentSystem;
+    lightingSystem;
+    postFxSystem;
+    debugSystem;
+    usePostprocessing;
+    presets;
+    presetId;
+    running = false;
+    animationFrame = null;
+    lastWidth;
+    lastHeight;
+    maxPixelRatio;
+    constructor(options) {
+        this.container = options.container;
+        const basePresets = options.presets ?? DEFAULT_PRESETS;
+        this.presets = { ...basePresets };
+        this.presetId = options.presetId ?? DEFAULT_PRESET_ID;
+        const width = this.container.clientWidth || 1;
+        const height = this.container.clientHeight || 1;
+        this.scene = new THREE.Scene();
+        this.camera = new THREE.PerspectiveCamera(options.camera?.fov ?? 60, width / height, options.camera?.near ?? 0.1, options.camera?.far ?? 500);
+        const camPos = options.camera?.position ?? [15, 12, 15];
+        this.camera.position.set(...camPos);
+        const rendererOptions = {
+            antialias: options.renderer?.antialias ?? true,
+            alpha: options.renderer?.alpha ?? false,
+            preserveDrawingBuffer: options.renderer?.preserveDrawingBuffer ?? false,
+        };
+        this.renderer = new THREE.WebGLRenderer(rendererOptions);
+        this.renderer.setSize(width, height);
+        this.container.appendChild(this.renderer.domElement);
+        this.controls = new OrbitControls(this.camera, this.renderer.domElement);
+        this.controls.enableDamping = true;
+        this.controls.dampingFactor = 0.05;
+        this.controls.addEventListener("change", () => {
+            if (this.usePostprocessing) {
+                this.postFxSystem.invalidate();
+            }
+        });
+        const target = options.camera?.target ?? [0, 1.5, 0];
+        this.controls.target.set(...target);
+        this.controls.update();
+        this.rootGroup = new THREE.Group();
+        this.scene.add(this.rootGroup);
+        this.environmentSystem = new EnvironmentSystem(this.scene, this.renderer, options.assetResolver);
+        this.lightingSystem = new LightingSystem(this.scene);
+        this.postFxSystem = new PostFxSystem(this.renderer, this.scene, this.camera);
+        this.debugSystem = new DebugSystem(this.scene);
+        this.usePostprocessing = options.usePostprocessing ?? true;
+        this.lastWidth = width;
+        this.lastHeight = height;
+        this.maxPixelRatio = 1.75;
+        this.postFxSystem.resize(width, height);
+        this.applyPreset(this.presetId);
+    }
+    getHandle() {
+        return {
+            start: () => this.start(),
+            stop: () => this.stop(),
+            resize: () => this.resize(),
+            invalidate: () => this.invalidate(),
+            dispose: () => this.dispose(),
+            setPreset: (presetId) => this.setPreset(presetId),
+            setRuntimePreset: (preset) => this.setRuntimePreset(preset),
+            setSceneRoot: (root) => this.setSceneRoot(root),
+            setCamera: (state) => this.setCamera(state),
+            getCameraState: () => this.getCameraState(),
+            capturePng: () => this.capturePng(),
+            getSnapshot: () => this.getSnapshot(),
+            getDebugInfo: () => this.getDebugInfo(),
+            getCanvas: () => this.renderer.domElement,
+        };
+    }
+    invalidate() {
+        this.postFxSystem.invalidate();
+        this.start();
+    }
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        const loop = () => {
+            if (!this.running)
+                return;
+            this.controls.update();
+            if (this.usePostprocessing) {
+                this.postFxSystem.render();
+            }
+            else {
+                this.renderer.render(this.scene, this.camera);
+            }
+            this.animationFrame = requestAnimationFrame(loop);
+        };
+        this.animationFrame = requestAnimationFrame(loop);
+    }
+    stop() {
+        this.running = false;
+        if (this.animationFrame !== null) {
+            cancelAnimationFrame(this.animationFrame);
+            this.animationFrame = null;
+        }
+    }
+    resize() {
+        const width = this.container.clientWidth || 1;
+        const height = this.container.clientHeight || 1;
+        this.lastWidth = width;
+        this.lastHeight = height;
+        const deviceRatio = typeof window !== "undefined" ? window.devicePixelRatio : 1;
+        this.renderer.setPixelRatio(Math.min(deviceRatio, this.maxPixelRatio));
+        this.camera.aspect = width / height;
+        this.camera.updateProjectionMatrix();
+        this.renderer.setSize(width, height);
+        this.postFxSystem.resize(width, height);
+        this.postFxSystem.invalidate();
+    }
+    dispose() {
+        this.stop();
+        this.environmentSystem.dispose();
+        this.lightingSystem.dispose();
+        this.postFxSystem.dispose();
+        this.debugSystem.dispose();
+        this.scene.clear();
+        this.controls.dispose();
+        this.renderer.dispose();
+        if (this.renderer.domElement.parentElement === this.container) {
+            this.container.removeChild(this.renderer.domElement);
+        }
+    }
+    setPreset(presetId) {
+        this.applyPreset(presetId);
+    }
+    setRuntimePreset(preset) {
+        const normalized = {
+            ...preset,
+            id: ViewerEngine.RUNTIME_PRESET_ID,
+        };
+        this.presets[ViewerEngine.RUNTIME_PRESET_ID] = normalized;
+        this.applyPreset(ViewerEngine.RUNTIME_PRESET_ID);
+    }
+    setSceneRoot(root) {
+        this.rootGroup.clear();
+        const object3d = root;
+        if (object3d && object3d.isObject3D) {
+            this.rootGroup.add(object3d);
+            const bounds = new THREE.Box3().setFromObject(object3d);
+            this.sceneBounds = bounds.clone();
+            if (!bounds.isEmpty()) {
+                const size = new THREE.Vector3();
+                bounds.getSize(size);
+                const maxDim = Math.max(size.x, size.y, size.z);
+                if (Number.isFinite(maxDim) && maxDim > 0) {
+                    const target = this.controls.target.clone();
+                    const distance = this.camera.position.distanceTo(target);
+                    const sphere = new THREE.Sphere();
+                    bounds.getBoundingSphere(sphere);
+                    const safetyFar = 1.15;
+                    const safetyNear = 1.6;
+                    let near = Math.max(0.01, distance - sphere.radius * safetyNear);
+                    const maxNear = distance * 0.1;
+                    if (Number.isFinite(maxNear) && maxNear > 0) {
+                        near = Math.min(near, maxNear);
+                    }
+                    const minSkyFar = 350;
+                    const far = Math.max(distance + sphere.radius * safetyFar, near + sphere.radius * 2, minSkyFar);
+                    let needsUpdate = false;
+                    if (Number.isFinite(near) && this.camera.near !== near) {
+                        this.camera.near = near;
+                        needsUpdate = true;
+                    }
+                    if (Number.isFinite(far) && this.camera.far !== far) {
+                        this.camera.far = far;
+                        needsUpdate = true;
+                    }
+                    if (needsUpdate) {
+                        this.camera.updateProjectionMatrix();
+                    }
+                }
+            }
+        }
+        this.postFxSystem.invalidate();
+        // Ensure the render loop is running after a scene update.
+        this.start();
+    }
+    setCamera(state) {
+        if (state.position) {
+            this.camera.position.set(...state.position);
+        }
+        if (state.target) {
+            this.controls.target.set(...state.target);
+        }
+        if (typeof state.fov === "number") {
+            this.camera.fov = state.fov;
+            this.camera.updateProjectionMatrix();
+        }
+        if (typeof state.near === "number" && Number.isFinite(state.near)) {
+            this.camera.near = state.near;
+            this.camera.updateProjectionMatrix();
+        }
+        if (typeof state.far === "number" && Number.isFinite(state.far)) {
+            this.camera.far = state.far;
+            this.camera.updateProjectionMatrix();
+        }
+        this.controls.update();
+        this.postFxSystem.invalidate();
+    }
+    getCameraState() {
+        return {
+            position: [this.camera.position.x, this.camera.position.y, this.camera.position.z],
+            target: [this.controls.target.x, this.controls.target.y, this.controls.target.z],
+            fov: this.camera.fov,
+            near: this.camera.near,
+            far: this.camera.far,
+        };
+    }
+    async capturePng() {
+        const width = this.renderer.domElement.width || 1;
+        const height = this.renderer.domElement.height || 1;
+        const target = new THREE.WebGLRenderTarget(width, height);
+        const previousTarget = this.renderer.getRenderTarget();
+        this.renderer.setRenderTarget(target);
+        // Render without postfx for now (upgrade later)
+        this.renderer.render(this.scene, this.camera);
+        const buffer = new Uint8Array(width * height * 4);
+        this.renderer.readRenderTargetPixels(target, 0, 0, width, height, buffer);
+        this.renderer.setRenderTarget(previousTarget);
+        target.dispose();
+        const canvas = document.createElement("canvas");
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+            return new Blob();
+        }
+        const imageData = ctx.createImageData(width, height);
+        const rowSize = width * 4;
+        for (let y = 0; y < height; y += 1) {
+            const src = (height - 1 - y) * rowSize;
+            const dst = y * rowSize;
+            imageData.data.set(buffer.subarray(src, src + rowSize), dst);
+        }
+        ctx.putImageData(imageData, 0, 0);
+        return new Promise((resolve) => {
+            canvas.toBlob((blob) => resolve(blob ?? new Blob()), "image/png");
+        });
+    }
+    getSnapshot() {
+        const envState = this.environmentSystem.getState();
+        return {
+            capturedAt: new Date().toISOString(),
+            presetId: this.presetId,
+            renderer: {
+                toneMapping: String(this.renderer.toneMapping),
+                toneMappingExposure: this.renderer.toneMappingExposure,
+                outputColorSpace: String(this.renderer.outputColorSpace),
+            },
+            environment: envState,
+            postfx: this.postFxSystem.getState(),
+        };
+    }
+    getDebugInfo() {
+        const envState = this.environmentSystem.getState();
+        const postfxState = this.postFxSystem.getState();
+        const renderInfo = this.renderer.info.render;
+        const clearColor = new THREE.Color();
+        this.renderer.getClearColor(clearColor);
+        return {
+            presetId: this.presetId,
+            camera: this.getCameraState(),
+            canvas: {
+                width: this.renderer.domElement.width,
+                height: this.renderer.domElement.height,
+                clientWidth: this.renderer.domElement.clientWidth,
+                clientHeight: this.renderer.domElement.clientHeight,
+            },
+            renderer: {
+                toneMapping: String(this.renderer.toneMapping),
+                toneMappingExposure: this.renderer.toneMappingExposure,
+                outputColorSpace: String(this.renderer.outputColorSpace),
+                pixelRatio: this.renderer.getPixelRatio(),
+                clearColor: `#${clearColor.getHexString()}`,
+                clearAlpha: this.renderer.getClearAlpha(),
+            },
+            renderInfo: {
+                calls: renderInfo.calls,
+                triangles: renderInfo.triangles,
+                lines: renderInfo.lines,
+                points: renderInfo.points,
+            },
+            scene: {
+                children: this.scene.children.length,
+                rootChildren: this.rootGroup.children.length,
+                lights: this.scene.children.filter((child) => child?.isLight).length,
+            },
+            environment: envState,
+            postfx: postfxState,
+        };
+    }
+    applyPreset(presetId) {
+        const preset = this.resolvePreset(presetId);
+        this.presetId = preset.id;
+        const exposureOverride = preset.sky?.mode === "hdr"
+            ? preset.sky.hdr?.exposure
+            : preset.sky?.mode === "cube"
+                ? preset.sky.cube?.exposure
+                : undefined;
+        const rendererConfig = exposureOverride !== undefined
+            ? { ...preset.renderer, toneMappingExposure: exposureOverride }
+            : preset.renderer;
+        applyRendererConfig(this.renderer, rendererConfig);
+        this.maxPixelRatio = rendererConfig?.maxPixelRatio ?? this.maxPixelRatio;
+        // applyRendererConfig can change pixel ratio; keep drawing buffer in sync.
+        this.renderer.setSize(this.lastWidth, this.lastHeight);
+        this.postFxSystem.resize(this.lastWidth, this.lastHeight);
+        void this.environmentSystem.apply(preset);
+        this.lightingSystem.apply(preset);
+        this.postFxSystem.apply(this.usePostprocessing ? preset.postfx : undefined);
+        this.postFxSystem.invalidate();
+        this.debugSystem.apply(preset, this.sceneBounds);
+    }
+    resolvePreset(presetId) {
+        if (presetId in this.presets)
+            return this.presets[presetId];
+        if (DEFAULT_PRESET_ID in this.presets)
+            return this.presets[DEFAULT_PRESET_ID];
+        return Object.values(this.presets)[0] ?? DEFAULT_PRESETS[DEFAULT_PRESET_ID];
+    }
+}

package/dist/engine/createViewer.d.ts

@@ -0,0 +1,3 @@
+import type { ViewerCreateOptions, ViewerHandle } from "./types";
+export declare function createViewer(options: ViewerCreateOptions): ViewerHandle;
+//# sourceMappingURL=createViewer.d.ts.map

package/dist/engine/createViewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createViewer.d.ts","sourceRoot":"","sources":["../../src/engine/createViewer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAGjE,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,YAAY,CAKvE"}

package/dist/engine/createViewer.js

@@ -0,0 +1,7 @@
+import { ViewerEngine } from "./ViewerEngine";
+export function createViewer(options) {
+    const engine = new ViewerEngine(options);
+    const handle = engine.getHandle();
+    queueMicrotask(() => options.hooks?.onReady?.(handle));
+    return handle;
+}