@smarterplan/ngx-smarterplan-core 1.4.14 → 1.4.16

package/lib/services/threejs.service.d.ts

@@ -0,0 +1,423 @@
+import { NgZone } from '@angular/core';
+import { Subject } from 'rxjs';
+import { ThreeJsAlignment } from '../helpers.service';
+import { PoiType } from '../types.service';
+import * as i0 from "@angular/core";
+/**
+ * A tag to draw in the Three.js scene, mirroring a Mattertag.
+ *
+ * Positions are in the model's own coordinate space - the same numbers stored in POI.coordinate -
+ * not scene space. The service reparents tags under the model so they inherit the centering and
+ * scaling applied at load, which means callers never deal with that transform.
+ */
+export interface ThreeJsTag {
+    /** The tagged element's id (POI.elementID), used to update or remove the tag later. */
+    id: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Drives both the click route and type filtering, so it travels with the tag. */
+    poiType?: PoiType | null;
+    /** Icon drawn on the tag. Falls back to a plain disc when absent or it fails to load. */
+    iconUrl?: string | null;
+    /** Tint for the fallback disc, as a CSS colour. */
+    color?: string;
+}
+/** What a click on a tag reports: enough to route to the element's detail page. */
+export interface ThreeJsTagClick {
+    elementId: string;
+    poiType: PoiType | null;
+}
+/**
+ * A spot picked on the model for a new tag.
+ *
+ * Both vectors are in the model's own coordinate space, which is what POI.coordinate stores. Scene
+ * coordinates deliberately never leave this service: the model is scaled to a fixed size on load, so
+ * a scene-space position would silently mean somewhere else the moment the .glb is re-exported.
+ */
+export interface ThreeJsTagPlacement {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Surface normal at the picked point - Matterport stores the same thing in POI.metadata. */
+    normal: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+/** One tag seen in both spaces: where it is stored, and where it really sits on the model. */
+export interface ThreeJsAlignmentPair {
+    source: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    target: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+/**
+ * Solves the transform that maps stored tag coordinates onto the loaded model.
+ *
+ * Takes exactly the correspondences a person can produce by hand: three tags, each pointed at twice
+ * - once where it currently sits, once where it belongs. That is the minimum that pins down all
+ * three parts of the answer. One pair fixes only translation; two leave the rotation about the line
+ * between them free; three resolve it.
+ *
+ * Returns null when the points are collinear or degenerate, because a wrong alignment applied
+ * silently is worse than none.
+ */
+export declare function solveThreeJsAlignment(pairs: ThreeJsAlignmentPair[]): ThreeJsAlignment | null;
+export interface ObjAdded {
+    id: string;
+    name: string;
+    file: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+export declare class ThreeJsService {
+    private ngZone;
+    private scene;
+    private camera;
+    private renderer;
+    private controls;
+    private animationFrameId;
+    private raycaster;
+    private mouse;
+    private isDraggingCamera;
+    private isDraggingTimer;
+    private clickableObjects;
+    objectHovered$: Subject<{
+        id: string;
+        event: MouseEvent;
+    }>;
+    objectClicked$: Subject<string>;
+    /** Emits when the user clicks a tag, mirroring Matterport's tag click. */
+    tagClicked$: Subject<ThreeJsTagClick>;
+    private tagGroup;
+    private tagSprites;
+    private canvasResizeObserver?;
+    /** Aborts the in-flight model download. Parsing cannot be interrupted, only not started. */
+    private loadAbortController?;
+    private modelRoot?;
+    /** True while the next click on the model places a tag instead of orbiting. */
+    private placingTag;
+    /** Position and normal of the last placed tag, in model space, awaiting commit to a POI. */
+    private pendingTagPlacement;
+    /** Emits once a tag is dropped on the model, so the UI can confirm and persist it. */
+    tagPlaced$: Subject<ThreeJsTagPlacement>;
+    /** Translucent marker shown under the cursor while placing. */
+    private placementPreview?;
+    private aligning;
+    private alignmentPairs;
+    private alignmentSource;
+    /** Drives the alignment walkthrough's UI: how many pairs are done and what it wants next. */
+    alignmentProgress$: Subject<{
+        pairs: number;
+        awaiting: 'tag' | 'point' | null;
+        tagId?: string;
+    }>;
+    /** In-flight camera move started by goToTag, advanced by the render loop. */
+    private cameraTween;
+    /** Emits true while a heavy OBJ file is being parsed (in a worker, when available), false once done. */
+    modelLoading$: Subject<boolean>;
+    /**
+     * Download progress for GLB models, as a 0-1 fraction, or null when the total size is unknown.
+     *
+     * A null means the server did not send Content-Length (chunked responses, some proxies) and no
+     * percentage can be derived; show an indeterminate indicator rather than guessing at one.
+     */
+    modelLoadProgress$: Subject<number>;
+    /**
+     * Emits when a load actually stopped short, which is not the same as asking it to.
+     *
+     * cancelModelLoad() can arrive after parse() has taken the main thread, and parse cannot be
+     * interrupted - the model finishes loading regardless. Only this tells the UI which of the two
+     * happened, so it does not offer to reload something that is already on screen.
+     */
+    modelLoadCancelled$: Subject<void>;
+    private objParserWorker?;
+    private objParserPendingRequests;
+    constructor(ngZone: NgZone);
+    /**
+     * Registers a Web Worker used to parse heavy .obj files off the main thread.
+     * Must be instantiated by the consuming app (e.g. `new Worker(new URL('./obj-parser.worker', import.meta.url))`),
+     * since a library packaged with ng-packagr cannot bundle worker files itself.
+     * When no worker is provided, loadObjModel falls back to parsing on the main thread.
+     */
+    setObjParserWorker(worker: Worker): void;
+    private requestObjParseInWorker;
+    /** Rebuilds a THREE.Mesh from the raw typed arrays sent back by the parser worker. */
+    private meshFromParsedData;
+    init(canvas: HTMLCanvasElement): void;
+    /**
+     * Path (served by the app) holding basis_transcoder.js/.wasm, which KTX2Loader needs to turn
+     * Basis Universal textures into whatever compressed format the local GPU actually supports.
+     */
+    private ktx2TranscoderPath;
+    /** Overrides where the Basis transcoder files are served from. */
+    setKtx2TranscoderPath(path: string): void;
+    /**
+     * Loads a base 3D model in GLTF/GLB format - the preferred format for large models.
+     * Unlike .obj, geometry arrives as binary typed arrays (no text parsing to offload to a worker)
+     * and stays indexed, so far less data reaches the GPU. KTX2 textures are supported too: they
+     * stay compressed in VRAM instead of being decoded to raw pixels like JPEG/PNG.
+     */
+    loadGLTFModel(url: string, cameraPosition?: {
+        x: number;
+        y: number;
+        z: number;
+    }, rotation?: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    /**
+     * Stops the model download in progress, if any.
+     *
+     * Only the download can be interrupted: parse() runs synchronously and holds the main thread until
+     * it finishes, so once it has begun there is nothing to cancel. In practice the download is the
+     * long part, which is where someone reaches for this.
+     */
+    cancelModelLoad(): void;
+    /**
+     * Abandons the load in progress without reporting it as cancelled.
+     *
+     * Dropping the controller is what makes the difference: onError treats an abort as user-initiated
+     * only while the controller that aborted is still the current one. Tearing down or rebuilding the
+     * scene is not something the person asked for, so it must not surface as "loading cancelled".
+     */
+    private discardCurrentLoad;
+    /**
+     * Resolves once the browser has painted at least one frame.
+     *
+     * A requestAnimationFrame callback runs *before* that frame is painted, so a single one is not
+     * enough to guarantee pending DOM changes are on screen; the second fires after the first frame
+     * has gone out. Falls back to a timeout where rAF isn't available (SSR, tests).
+     */
+    private afterNextPaint;
+    /**
+     * Downloads a file, reporting progress on modelLoadProgress$ as it arrives.
+     *
+     * GLTFLoader.load() would report progress through XHR, but this path deliberately uses fetch() +
+     * parse() instead (see loadGLTFModel for why), so progress is read off the response stream here.
+     * That is also the more useful number: on a model of this size the download dominates, and the
+     * stream reports it as it happens rather than in one jump at the end.
+     */
+    private fetchWithProgress;
+    /**
+     * Fits the camera's clipping planes to how big the model actually is.
+     *
+     * Depth precision depends on the far/near ratio, and the fixed 0.1 / 10000 the camera starts with
+     * is a ratio of 100000 for a model only ~10 units across. That wastes most of the depth buffer on
+     * empty space and lets nearly coincident surfaces - which captured meshes have everywhere -
+     * flicker against each other.
+     */
+    private adjustClippingPlanes;
+    /**
+     * Swaps the PBR materials GLTFLoader builds for the plain Phong ones the .obj path produces.
+     *
+     * MeshStandardMaterial keeps a specular reflection even at metalness 0, since every dielectric
+     * reflects some light, and Fresnel drives that reflection towards white as a surface turns away
+     * from the viewer. On an aerial view of a facade most surfaces sit at exactly those grazing
+     * angles, which paints white highlights over window frames and roof edges - the same model
+     * loaded as .obj never shows them, because MTLLoader builds Phong materials and OBJLoader zeroes
+     * their specular when the .mtl declares Ns 0.
+     *
+     * Captured models carry their lighting in the texture and want no specular response at all, so
+     * matching the .obj path here is both the fix and the more faithful choice.
+     */
+    private convertToPhongMaterials;
+    /**
+     * Renders every material double-sided.
+     *
+     * Reality capture meshes routinely contain triangles with reversed winding - an artefact of the
+     * reconstruction, not of the file. With the default FrontSide those triangles are culled, leaving
+     * scattered holes that show the scene background through the model. Against a light background
+     * they read as white specks with no discernible pattern.
+     *
+     * Drawing both sides costs a little fill rate but is what makes captured geometry render as
+     * solid; other viewers of this kind of content do the same unconditionally.
+     */
+    private forceDoubleSidedMaterials;
+    /**
+     * Computes real vertex normals for any geometry that arrived without them.
+     *
+     * A glTF without a NORMAL attribute is spec-compliant, and GLTFLoader handles it by switching the
+     * material to flatShading, which makes the shader derive the normal per pixel from screen-space
+     * derivatives. That derivation collapses on the degenerate, needle-thin triangles that reality
+     * capture meshes are full of: the face has almost no area, the derived normal is meaningless, and
+     * lighting blows those fragments out to white specks - densest exactly where fine detail is.
+     *
+     * Computing normals from the geometry instead is robust to those triangles, since a degenerate
+     * face contributes almost nothing to the average and its neighbours dominate.
+     */
+    private ensureVertexNormals;
+    /**
+     * Configures how every texture in a model is sampled: maximum anisotropy, and no mipmapping.
+     *
+     * Photogrammetry atlases pack their UV islands with unused gutter pixels between them. Mipmapping
+     * averages neighbouring pixels at each level, so those gutters bleed further into the islands the
+     * smaller the level gets - and viewing the whole model at once uses the smallest levels, painting
+     * bright gutter pixels over the edges of fine detail. Sampling the full-resolution image avoids
+     * that, at the cost of some shimmer on minified surfaces.
+     *
+     * Note that anisotropy only takes effect while mipmapping is on, so with the settings below it is
+     * inert; it is set anyway so the sampling stays correct for anyone who re-enables mipmaps here.
+     */
+    private tuneTextureSampling;
+    /**
+     * Loads an OBJ model with MTL.
+     * The heavy text-parsing step runs in a Web Worker when one has been registered via
+     * setObjParserWorker (see there for why the app, not this library, provides it); this keeps
+     * the main thread free while large architecture models (millions of vertices) are parsed.
+     * Falls back to parsing on the main thread otherwise.
+     */
+    loadObjModel(mtlUrl: string, objUrl: string, cameraPosition?: {
+        x: number;
+        y: number;
+        z: number;
+    }, rotation?: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    /** Centers, scales and adds a loaded object to the scene, then frames the camera on it. */
+    private placeLoadedObjectInScene;
+    /**
+     * Keeps the drawing buffer and camera matched to the canvas as it is resized.
+     *
+     * renderer.setSize() writes explicit pixel width/height into the canvas's style, overriding the
+     * 100%/100% it starts with. Without this, the canvas keeps whatever size it had at startup: hiding
+     * the top menu grows the container, the canvas does not follow, and the strip that opens up shows
+     * the page behind it instead of the scene.
+     *
+     * The parent is observed rather than the canvas, because resizing the canvas is what this reacts
+     * to - watching the element we resize would retrigger the observer.
+     */
+    private observeCanvasResize;
+    /**
+     * Starts the alignment walkthrough: pick a tag, then click where it really is, three times.
+     *
+     * Existing tags are the correspondences - they already carry the stored coordinate, so the person
+     * only has to supply the matching spot on the model. No new records are written; nothing is
+     * applied until solveAlignmentFromPairs() succeeds.
+     */
+    startTagAlignment(): void;
+    cancelTagAlignment(): void;
+    isAligningTags(): boolean;
+    /**
+     * Solves and applies the alignment collected so far, returning it so the caller can persist it.
+     *
+     * Returns null when the three tags turn out to be collinear, in which case nothing is applied and
+     * the walkthrough stays open for the person to pick a better third point.
+     */
+    solveAlignmentFromPairs(): ThreeJsAlignment | null;
+    /** Handles a click while the alignment walkthrough is running. */
+    private handleAlignmentClick;
+    /** Arms tag placement: the next click on the model drops a tag instead of being ignored. */
+    startTagPlacement(): void;
+    /** Leaves placement mode without placing anything. */
+    cancelTagPlacement(): void;
+    /**
+     * Shows a translucent tag under the cursor while placing, so the spot is visible before commiting.
+     *
+     * Matterport does this with a tag that follows the pointer; the equivalent here is a preview
+     * sprite that gets removed the moment the real tag takes its place.
+     */
+    private updatePlacementPreview;
+    private removePlacementPreview;
+    /** Shows or hides one tag, leaving it registered so it can be brought back without reloading. */
+    setTagVisibility(elementId: string, visible: boolean): void;
+    /**
+     * Shows only tags of the given types, hiding the rest.
+     *
+     * Passing null shows everything - the "no filter" state, distinct from an empty array, which is a
+     * filter that happens to match nothing.
+     */
+    setVisibleTagTypes(types: PoiType[] | null): void;
+    /**
+     * Moves the camera to look at a tag, mirroring Matterport's goToTag.
+     *
+     * Animated rather than teleported: jumping the camera loses the viewer's sense of where they were
+     * relative to the model. The approach distance follows the model's size so it frames sensibly
+     * whatever the units are.
+     */
+    goToTag(elementId: string): void;
+    /** Advances the camera animation started by goToTag, if one is running. */
+    private stepCameraTween;
+    isPlacingTag(): boolean;
+    /** The spot picked by the last placement, for whoever commits it to a POI. */
+    getPendingTagPlacement(): ThreeJsTagPlacement | null;
+    /**
+     * Turns a click into a point on the model, in model space.
+     *
+     * Returns null when the click missed the geometry, which is a normal outcome - the user clicked
+     * the sky - and leaves placement mode armed so they can simply try again.
+     */
+    private pickPlacementOnModel;
+    /**
+     * Sets the transform mapping captured tag coordinates onto this model's space.
+     *
+     * Every tag comes from the same source space, so this is one transform on the group rather than
+     * per-tag maths - which also means it applies retroactively to tags already placed, and can be
+     * adjusted live while someone dials the numbers in.
+     *
+     * Passing null resets to identity, i.e. tag coordinates are already in model space.
+     */
+    setTagAlignment(alignment: ThreeJsAlignment | null): void;
+    /**
+     * Adds a tag, or moves/restyles the one already registered for this element.
+     *
+     * Upsert rather than a declarative "here is the full list" call, because tags arrive per type
+     * (equipment, then tickets, then measurements...) from separate subscriptions - replacing the set
+     * on each of those would wipe the types that came before.
+     */
+    upsertTag(tag: ThreeJsTag): void;
+    /** Removes the tag registered for an element, if there is one. */
+    removeTag(elementId: string): void;
+    /** Removes every tag from the scene. */
+    clearTags(): void;
+    /** Loads an icon into an existing tag, leaving the fallback disc in place if it fails. */
+    private applyTagIcon;
+    /** Draws the default tag marker: a filled disc with a white ring, so it reads on any background. */
+    private createTagTexture;
+    /**
+     * Sizes a tag relative to the model.
+     *
+     * A sprite inherits the model's scale and the alignment's, so a fixed size would come out tiny on
+     * a large model and huge on a small one. Dividing by the group's world scale keeps tags the same
+     * size on screen whatever the model's units are.
+     */
+    private scaleTagForModel;
+    /**
+     * Adds secondary interactive objects (e.g., POIs, sensors) to the scene.
+     */
+    updateObjsToScene(objsAdded: ObjAdded[]): void;
+    private onMouseMove;
+    private onMouseClick;
+    private animate;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThreeJsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThreeJsService>;
+}

package/lib/services/viewer.service.d.ts

@@ -1,5 +1,6 @@
 import { Subject } from 'rxjs';
 import { MatterportService } from './matterport.service';
+import { ThreeJsService } from './threejs.service';
 import { BaseTagService } from './tag.service';
 import { DbObjectType, POI, PoiType, Comment, Equipment, Ticket, Feature, SpModule } from '../types.service';
 import { PoiService } from './models/poi.service';
@@ -8,6 +9,7 @@ export declare class ViewerService {
     private readonly sdkKey;
     private poiService;
     private matterportService;
+    private threeJsService;
     private viewerMode;
     currentModel3D: string;
     private tourUrl;
@@ -50,7 +52,7 @@ export declare class ViewerService {
         };
     };
     private isObjectLoaded;
-    constructor(sdkKey: string, poiService: PoiService, matterportService: MatterportService);
+    constructor(sdkKey: string, poiService: PoiService, matterportService: MatterportService, threeJsService: ThreeJsService);
     checkMode(indexMode: string): boolean;
     setMode(indexMode: string): void;
     setTourUrl(options: {
@@ -82,7 +84,55 @@ export declare class ViewerService {
      */
     addObjectTagsToViewer(objects: DbObjectType[]): Promise<void>;
     actionAddObjectFromPOI(object: DbObjectType, poi: POI): Promise<any>;
+    /**
+     * Draws a POI as a tag in the Three.js scene.
+     *
+     * Both viewers are fed by the same subscriptions on the same POI records, so a tag created in
+     * either one shows up in the other without any syncing of its own - this is just the Three.js end
+     * of the pipeline that already drives Matterport.
+     */
+    private addThreeJsTagFromPOI;
+    /** Moves the Three.js camera to frame a tag, mirroring Matterport's goToTag. */
+    goToThreeJsTag(elementId: string): void;
+    /** Shows only tags of the given POI types; null clears the filter. */
+    setVisibleThreeJsTagTypes(types: PoiType[] | null): void;
+    /**
+     * Alignment walkthrough: pick a tag, then click where it really sits, three times over.
+     *
+     * Uses tags that already exist, so nothing is created and nothing is written until the caller
+     * saves the result. See threeJsAlignmentProgress$ for what the UI should be asking for.
+     */
+    startThreeJsTagAlignment(): void;
+    cancelThreeJsTagAlignment(): void;
+    get threeJsAlignmentProgress$(): Subject<{
+        pairs: number;
+        awaiting: "tag" | "point";
+        tagId?: string;
+    }>;
+    /**
+     * Solves the alignment and applies it to the scene, returning it as the JSON to store in the
+     * capture's metadata. Null means the three tags were collinear and nothing was applied.
+     */
+    solveThreeJsTagAlignment(existingMetadata?: string): {
+        alignment: any;
+        metadata: string;
+    } | null;
+    /** Shows or hides a single Three.js tag. */
+    setThreeJsTagVisibility(elementId: string, visible: boolean): void;
     action_delete_element(element: DbObjectType): Promise<void>;
+    /** Emits when a Three.js model load actually stopped short, rather than merely being asked to. */
+    get threeJsModelLoadCancelled$(): Subject<void>;
+    /** Stops the Three.js model download in progress. */
+    cancelThreeJsModelLoad(): void;
+    /** Emits the element id of a tag clicked in the Three.js scene. */
+    get threeJsTagClicked$(): Subject<import("./threejs.service").ThreeJsTagClick>;
+    /**
+     * Applies the visit's stored tag alignment, mapping captured tag coordinates onto this model.
+     *
+     * Safe to call before the model or any tag exists: it is a transform on the group both end up
+     * under, so it applies to whatever arrives later.
+     */
+    setThreeJsTagAlignmentFromMetadata(metadata: string): void;
     /**
      * Enable tag placement menu to add a new element depending on its type (TICKET, DATA, EQUIPMENT etc)
      */
@@ -104,6 +154,17 @@ export declare class ViewerService {
     action_toolbox_mesure(): void;
     action_toolbox_cancel_mesure(): void;
     action_update_poi(poi: POI, isValid: boolean, element: DbObjectType): Promise<POI>;
+    /**
+     * Writes the spot picked in the Three.js scene into the POI, mirroring the Matterport branch.
+     *
+     * The coordinate goes in the same field and the same space Matterport writes, which is what makes
+     * a tag created here show up in the right place there - and the other way round.
+     */
+    private commitThreeJsTagPlacement;
+    /** Emits when a tag is dropped on the model in the Three.js scene. */
+    get threeJsTagPlaced$(): Subject<import("./threejs.service").ThreeJsTagPlacement>;
+    /** Leaves Three.js tag placement mode without placing anything. */
+    cancelThreeJsTagPlacement(): void;
     editOnlyTagStyleForPoi(poi: POI, object: DbObjectType): void;
     addIconAndSetForPoi(poi: POI, iconPath: string): void;
     changeToRegistredIconForPoi(poi: POI, iconName: string): void;
@@ -114,6 +175,58 @@ export declare class ViewerService {
      * @param element
      */
     action_move_poi_visually(poi: POI, element: Ticket | Feature | Equipment | Comment): Promise<void>;
+    initThreeJs(canvas: HTMLCanvasElement): void;
+    /**
+     * Loads a 3D model into the Three.js scene (GLTF).
+     * Only works when the viewer is in 'threejs' mode.
+     */
+    loadGLTFModel(url: string, cameraPosition?: {
+        x: number;
+        y: number;
+        z: number;
+    }, rotation?: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    /**
+     * Loads a GLB stored in S3, given its key (e.g. `visits/<id>/model.glb`).
+     *
+     * Resolves the key to a signed URL first, then loads it like any other. The signed URL only
+     * covers authentication - the bucket still needs a CORS rule allowing GET from the app's origin,
+     * or the browser blocks the download before it starts.
+     *
+     * `placementMetadata` is the capture's stored placement; when absent or unusable the viewer falls
+     * back to framing the model automatically.
+     */
+    loadGLTFModelFromS3(key: string, placementMetadata?: string): Promise<void>;
+    /**
+     * Loads a 3D model into the Three.js scene (OBJ).
+     */
+    loadObjModel(mtlUrl: string, objUrl: string, cameraPosition?: {
+        x: number;
+        y: number;
+        z: number;
+    }, rotation?: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    get threeJsObjectHovered$(): Subject<{
+        id: string;
+        event: MouseEvent;
+    }>;
+    get threeJsObjectClicked$(): Subject<string>;
+    /** Emits true while a heavy .obj file is being parsed (in a worker, when available), false once done. */
+    get threeJsModelLoading$(): Subject<boolean>;
+    /** Download progress for GLB models as a 0-1 fraction, or null when the size isn't known upfront. */
+    get threeJsModelLoadProgress$(): Subject<number>;
+    /**
+     * Registers the Web Worker used to parse heavy .obj files off the main thread.
+     * Must be created by the app (see obj-parser.worker.ts), since this library can't bundle worker files.
+     */
+    setObjParserWorker(worker: Worker): void;
+    addThreeJsObjects(objs: any[]): void;
     initMatterportSdk(spaceID: string, model3D: string, tagService: BaseTagService, module?: SpModule): Promise<void>;
     removeForbiddenSweeps(forbiddenSweeps: string[]): void;
     setObject3DLoadedInPosition(objectLoaded: boolean): void;

package/lib/types.service.d.ts

@@ -127,7 +127,8 @@ export declare enum EmailStatus {
 export declare enum CaptureViewer {
     CUPIX = "CUPIX",
     MATTERPORT = "MATTERPORT",
-    SMARTERPLAN_V1 = "SMARTERPLAN_V1"
+    SMARTERPLAN_V1 = "SMARTERPLAN_V1",
+    THREEJS = "THREEJS"
 }
 export declare enum InventoryStatus {
     SUCCESS = "SUCCESS",
@@ -595,6 +596,11 @@ export type Visit = {
     node: Node;
     name?: string | null;
     nmbImagesImported: number;
+    /**
+     * Free-form metadata from the capture. Named after its source to keep it distinct from `name`,
+     * which comes from node.metadata. Three.js visits store their initial placement here.
+     */
+    captureMetadata?: string | null;
 };
 export type Hashtag = {
     name?: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smarterplan/ngx-smarterplan-core",
-  "version": "1.4.14",
+  "version": "1.4.16",
   "dependencies": {
     "tslib": "^2.5.0"
   },

package/public-api.d.ts

@@ -6,6 +6,7 @@ export * from './lib/services/tag.service';
 export * from './lib/services/baseVisibility.service';
 export * from './lib/services/content.service';
 export * from './lib/services/viewer.service';
+export * from './lib/services/threejs.service';
 export * from './lib/services/navigator.service';
 export * from './lib/services/zoneChange.service';
 export * from './lib/config';
@@ -18,6 +19,7 @@ export * from './lib/services/filter.service';
 export * from './lib/services/search.service';
 export * from './lib/services/zone-drawer.service';
 export * from './lib/services/matterport-import.service';
+export * from './lib/services/threejs-import.service';
 export * from './lib/services/matterport-tag-copy.service';
 export * from './lib/mattertagData';
 export * from './lib/services/utils/matterport-transform.util';