@smarterplan/ngx-smarterplan-core 1.4.20 → 1.4.22

package/lib/components/splat-viewer/splat-viewer.component.d.ts

@@ -0,0 +1,98 @@
+import { ElementRef, EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
+import { TranslateService } from '@ngx-translate/core';
+import { ThreeJsModelUp } from '../../helpers.service';
+import { ViewerService } from '../../services/viewer.service';
+import * as i0 from "@angular/core";
+/** How the splat viewer is moved through: around the model, or inside it. */
+export type SplatViewerMode = 'orbit' | 'walk';
+/**
+ * Gaussian splats, drawn by SuperSplat's viewer (PlayCanvas) in an iframe, as Matterport's showcase
+ * is: the page built from projects/splat-viewer, which each app serves from assets/viewers/splat.
+ *
+ * The visit's Three.js scene stays underneath, unseen, holding the tags, their calibration and the
+ * measurement, as it does for a model it draws itself; this hands the viewer what the scene holds,
+ * and turns what is clicked in it into what a click in the scene does - through ViewerService, so
+ * that whatever drives the scene (the add buttons, the calibration panel, the measuring tool, the
+ * tag lists) drives this as well. Tags clicked come out of ViewerService.threeJsTagClicked$, as
+ * clicks in the scene do.
+ *
+ * What it says of loading is for the app's own loading overlay; see the outputs.
+ */
+export declare class SplatViewerComponent implements OnInit, OnChanges, OnDestroy {
+    private viewerService;
+    private host;
+    private sanitizer;
+    private translate;
+    /** The model: the S3 key - or assets/ path - of a splat file, or of a Streamed SOG's lod-meta.json. */
+    modelKey: string | null;
+    /** Which of the model's axes is up, from its capture's placement; null for the viewer's own idea. */
+    up: ThreeJsModelUp | null;
+    /** How far loading has got, from 0 to 1, or null when the size is not known. 0 when it starts. */
+    loadProgress: EventEmitter<number>;
+    loaded: EventEmitter<void>;
+    loadFailed: EventEmitter<string>;
+    /** Said whenever the mode changes, the viewer's own buttons included. */
+    modeChange: EventEmitter<SplatViewerMode>;
+    frame: ElementRef<HTMLIFrameElement>;
+    /**
+     * The viewer's page, made once, in ngOnInit: a new object, even for the same address, would make
+     * Angular set the iframe's src again, which loads the viewer afresh with nothing in it.
+     */
+    page: SafeResourceUrl;
+    /** Whether the page has said it is ready; it says so again each time it starts over. */
+    private ready;
+    /** The model handed to the page, so the same one is not downloaded twice. */
+    private loadedKey;
+    /** Set by cancelLoad: the page, starting over empty, waits to be asked again (reload). */
+    private cancelled;
+    /** Whether the page was last asked to take a click for a calibration. */
+    private pickingForCalibration;
+    /** The calibration under way, as ViewerService last said. */
+    private alignment;
+    /** Each segment's length of the measurement on the model, as ViewerService last said. */
+    private measureDistances;
+    /** The last lod-meta.json handed to the page, as a link of this page's own. */
+    private streamedMeta;
+    /** Pictures asked of the page, by the number they were asked with, until it answers. */
+    private snapshots;
+    private snapshotCount;
+    private destroyed$;
+    constructor(viewerService: ViewerService, host: ElementRef<HTMLElement>, sanitizer: DomSanitizer, translate: TranslateService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /** Stops the model loading; nothing is loaded again until reload(). */
+    cancelLoad(): void;
+    /** Loads the model again, after cancelLoad. */
+    reload(): void;
+    setMode(mode: SplatViewerMode): void;
+    /**
+     * The scene as it is on screen, with the measurement drawn on it and no tags, as a JPEG data URL;
+     * null when there is no scene to take, or the page does not answer within ten seconds.
+     */
+    snapshot(): Promise<string | null>;
+    /** What the page says: that it is ready, how loading goes, what was clicked in it. */
+    onMessage(event: MessageEvent): void;
+    private load;
+    /**
+     * The lod-meta.json of a Streamed SOG, with its pieces named so that the page asks for each of
+     * them when it needs it ('sign').
+     *
+     * The pieces sit beside lod-meta.json in S3 and are named relative to it, which a signed link -
+     * its signature in the query - does not survive. And they are fetched while the visit lasts, as the
+     * camera reaches them, long after any link signed up front has run out.
+     */
+    private streamedEntry;
+    private postTags;
+    /**
+     * The calibration under way, for the page to draw - the pins dropped, the tag being matched - and,
+     * while the place of a tag is asked for, to take the click on the model that says where ('picked').
+     */
+    private postCalibration;
+    /** The measurement for the page to draw - its points, each segment's length - or nothing. */
+    private postMeasurement;
+    private post;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SplatViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SplatViewerComponent, "lib-splat-viewer", never, { "modelKey": { "alias": "modelKey"; "required": false; }; "up": { "alias": "up"; "required": false; }; }, { "loadProgress": "loadProgress"; "loaded": "loaded"; "loadFailed": "loadFailed"; "modeChange": "modeChange"; }, never, never, false, never>;
+}

package/lib/ngx-smarterplan-core.module.d.ts

@@ -15,14 +15,15 @@ import * as i11 from "./components/menu-bar/navigation-bar/navigation-bar.compon
 import * as i12 from "./components/loader/loader.component";
 import * as i13 from "./components/support-modal/support-modal.component";
 import * as i14 from "./pipes/format-date-number-to-digits.pipe";
-import * as i15 from "@angular/forms";
-import * as i16 from "@angular/common";
-import * as i17 from "@angular/router";
-import * as i18 from "@ng-bootstrap/ng-bootstrap";
-import * as i19 from "@ngx-translate/core";
+import * as i15 from "./components/splat-viewer/splat-viewer.component";
+import * as i16 from "@angular/forms";
+import * as i17 from "@angular/common";
+import * as i18 from "@angular/router";
+import * as i19 from "@ng-bootstrap/ng-bootstrap";
+import * as i20 from "@ngx-translate/core";
 export declare class NgxSmarterplanCoreModule {
     static forRoot(config: Config): ModuleWithProviders<NgxSmarterplanCoreModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgxSmarterplanCoreModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxSmarterplanCoreModule, [typeof i1.TimeDateToLocalStringPipe, typeof i2.SafeUrlPipe, typeof i3.HashtagFromIdPipe, typeof i4.DurationToStringPipe, typeof i5.CsvExportComponent, typeof i6.SearchBarComponent, typeof i7.UsernameFromIdPipe, typeof i8.ModalSwitchVisitComponent, typeof i9.MenuBarComponent, typeof i10.AvatarComponent, typeof i11.NavigationBarComponent, typeof i12.LoaderComponent, typeof i13.SupportModalComponent, typeof i14.FormatDateNumberToDigitsPipe], [typeof i15.FormsModule, typeof i15.ReactiveFormsModule, typeof i16.CommonModule, typeof i17.RouterModule, typeof i18.NgbModule, typeof i19.TranslateModule], [typeof i5.CsvExportComponent, typeof i6.SearchBarComponent, typeof i1.TimeDateToLocalStringPipe, typeof i2.SafeUrlPipe, typeof i3.HashtagFromIdPipe, typeof i4.DurationToStringPipe, typeof i7.UsernameFromIdPipe, typeof i9.MenuBarComponent, typeof i12.LoaderComponent, typeof i13.SupportModalComponent, typeof i10.AvatarComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxSmarterplanCoreModule, [typeof i1.TimeDateToLocalStringPipe, typeof i2.SafeUrlPipe, typeof i3.HashtagFromIdPipe, typeof i4.DurationToStringPipe, typeof i5.CsvExportComponent, typeof i6.SearchBarComponent, typeof i7.UsernameFromIdPipe, typeof i8.ModalSwitchVisitComponent, typeof i9.MenuBarComponent, typeof i10.AvatarComponent, typeof i11.NavigationBarComponent, typeof i12.LoaderComponent, typeof i13.SupportModalComponent, typeof i14.FormatDateNumberToDigitsPipe, typeof i15.SplatViewerComponent], [typeof i16.FormsModule, typeof i16.ReactiveFormsModule, typeof i17.CommonModule, typeof i18.RouterModule, typeof i19.NgbModule, typeof i20.TranslateModule], [typeof i5.CsvExportComponent, typeof i6.SearchBarComponent, typeof i1.TimeDateToLocalStringPipe, typeof i2.SafeUrlPipe, typeof i3.HashtagFromIdPipe, typeof i4.DurationToStringPipe, typeof i7.UsernameFromIdPipe, typeof i9.MenuBarComponent, typeof i12.LoaderComponent, typeof i13.SupportModalComponent, typeof i10.AvatarComponent, typeof i15.SplatViewerComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<NgxSmarterplanCoreModule>;
 }

package/lib/services/matterport-object3d.service.d.ts

@@ -1,4 +1,5 @@
-import { IObject3D, PoiType, POI, DbObjectType } from '../types.service';
+import { Subject } from 'rxjs';
+import { IObject3D, PoiType, POI, DbObjectType, GizmoMode, GizmoSnap, Object3DBoundingBox, Object3DTransform, Object3DTransformChange, Point3D } from '../types.service';
 import * as i0 from "@angular/core";
 export declare class MatterportObject3DService {
     dictionnaryObjects3D: Map<string, any>;
@@ -9,22 +10,141 @@ export declare class MatterportObject3DService {
     azimuthalCrown: any;
     threeJSScene: any;
     noLightForObjects: boolean;
+    /** Max time (ms) to wait for a model to be loaded by the SDK */
+    loadTimeoutMs: number;
+    /** Max distance (m) an object can travel from where a translate drag started */
+    maxDragDistance: number;
+    /** Max vertical travel (m, up and down) during a translate drag, so an object cannot jump to another floor */
+    maxDragHeight: number;
+    /** Emits on every gizmo change and on setObject3DTransform */
+    readonly object3DTransformChanged$: Subject<Object3DTransformChange>;
+    /** Security camera animators by object uuid (`securityCameraAnimator` stays the last loaded one) */
+    securityCameraAnimators: Map<string, any>;
+    private viewFrustumVisible;
+    private lastSecurityCameraUuid;
+    /** Loader component of each model (outputs.objectRoot is set once loaded) */
+    private loaderComponents;
+    private gizmos;
+    private activeGizmoUuid;
+    private gizmoSnap;
+    /** Sweeps disabled by setNavigationLocked(true), re-enabled on unlock */
+    private sweepsDisabledByLock;
+    /** Sweeps re-enabled by the last unlock (the SDK may still report them disabled for a moment) */
+    private sweepsEnabledByUnlock;
+    private readonly tmpBox;
     constructor();
     init3DObjectViewer(sdk: any): Promise<void>;
-    add3DObject(sdk: any, obj: IObject3D, mode?: 'translate' | 'rotate'): Promise<any>;
+    /** SDK loader component name for a model format, null when the format is not supported */
+    private getLoaderComponentName;
+    /** Resolves once the loader component has produced its objectRoot, rejects after `timeoutMs` */
+    private waitForModelLoaded;
+    /**
+     * Adds a 3D model to the scene.
+     * The promise resolves with the three.js object once the model is actually loaded, and rejects
+     * (after cleaning the scene) when the format is unknown or the load times out.
+     * The position / rotation / scale of `obj` are applied to the model origin, as stored in DB.
+     */
+    add3DObject(sdk: any, obj: IObject3D, mode?: GizmoMode): Promise<any>;
+    /**
+     * Removes a 3D object for good: detaches its gizmo, stops its scene object and forgets it.
+     */
     deleteObject3D(uuid: string): Promise<void>;
     getObject3DModelNodeFromDictionnary(uuid: string): any;
     toggleObjectVisibility(objectId: any): void;
     isObjectVisible(objectId: any): boolean;
+    /** Shows / hides a model (used by the placement preview) */
+    setObject3DVisible(uuid: string, visible: boolean): void;
+    /** Enables / disables the pointer collider of a model (disabled while it follows the cursor) */
+    setObject3DColliderEnabled(uuid: string, enabled: boolean): void;
+    /**
+     * Moves the camera next to a 3D object by creating a temporary tag on the object centre.
+     * @returns false when the object is unknown or no tag could be reached
+     */
     pointCameraTo3DObject(sdk: any, objectId: any, createTagCallback: (tagType: PoiType, object: DbObjectType, poi: POI) => Promise<any>, goToTagCallback: (sid: string) => Promise<any>, deleteLastTagCallback: () => void, getTagFromElementId: (id: string) => {
         tag: string;
         sweep: string;
-    }): Promise<void>;
+    }): Promise<boolean>;
     getSceneNodeFromObject3DId(uuid: string): any;
     displayAzimutalCrown(poseCamera: any): Promise<void>;
-    attachGizmoControlTo3DObject(sdk: any, modelNode: any, sceneObject: any, mode: 'translate' | 'rotate' | 'scale', visible: boolean, isNewObject: boolean): Promise<any>;
+    private toPoint;
+    /**
+     * Geometry of the model itself (the loader output): the node also holds the helpers added by other
+     * components, like the view frustum of a security camera, which must not count in its size.
+     */
+    private modelRoot;
+    /** World-space bounding box of the model, null when unknown or when nothing is loaded yet */
+    getObject3DBoundingBox(uuid: string): Object3DBoundingBox | null;
+    /**
+     * Real dimensions of the model in meters (width x, height y, depth z), scale included but not
+     * its rotation: the world bounding box of a rotated object is larger than the object itself.
+     */
+    getObject3DDimensions(uuid: string): Point3D | null;
+    /**
+     * Uniform scale so that the largest bounding box dimension equals `targetSizeMeters`.
+     * The node position is untouched, so call placeObject3DOnSurface afterwards.
+     * @returns the new scale, null when the object is unknown / not loaded / `targetSizeMeters` invalid
+     */
+    normalizeObject3DSize(uuid: string, targetSizeMeters: number): Point3D | null;
+    /**
+     * Places the model on a surface point without touching its pivot: the node position is
+     * adjusted so that the bounding box bottom-center lies on `point`.
+     * - floor (normal pointing up, or no normal): bottom-center on the point
+     * - wall (mostly horizontal normal): model turned around Y so its +Z faces away from the wall,
+     *   and pushed along the normal by half its depth so it does not cut the wall
+     * - ceiling (normal pointing down): the model hangs, top-center on the point
+     * @returns the new transform, null when the object is unknown or not loaded
+     */
+    /**
+     * @param frontYawOffset rotation (radians, around Y) that turns the front of the model toward its +Z
+     *                       axis, for models whose front is another axis (e.g. -PI/2 when it is +X)
+     */
+    placeObject3DOnSurface(uuid: string, point: Point3D, normal?: Point3D, frontYawOffset?: number): Object3DTransform | null;
+    getObject3DTransform(uuid: string): Object3DTransform | null;
+    /** Applies a (partial) transform. Rotation is in radians. */
+    setObject3DTransform(uuid: string, transform: Partial<Object3DTransform>): boolean;
+    private emitTransformChanged;
+    /** Creates the mp.transformControls node of a model and wires it (events, snap) */
+    private createGizmo;
+    /** Keeps a translate drag within maxDragDistance / maxDragHeight of where it started, then notifies */
+    private onGizmoObjectChange;
+    private applySnap;
+    /**
+     * Shows the transform gizmo on an object (any previous gizmo is detached first).
+     * Re-attaching to the object that already has the gizmo only changes its mode.
+     */
+    attachGizmo(uuid: string, mode: GizmoMode, sdk?: any): Promise<boolean>;
+    /** Switches the active gizmo between translate / rotate / scale without re-attaching it */
+    setGizmoMode(mode: GizmoMode): void;
+    /** Really removes the gizmo from the scene (default: the active one) */
+    detachGizmo(uuid?: string): void;
+    isGizmoAttached(uuid?: string): boolean;
+    /** Snap steps for all gizmos (null / missing value = no snap) */
+    setGizmoSnap(snap: GizmoSnap | null): void;
+    setGizmoMaxDragDistance(maxDistance: number, maxHeight?: number): void;
+    /**
+     * Prevents camera navigation to other sweeps while a gizmo is edited.
+     * The SDK has no "freeze camera" switch, so every enabled sweep except the current one is
+     * disabled (Sweep.disable); exactly those sweeps are re-enabled on unlock. Sweeps already
+     * disabled (forbidden sweeps, edit mode) are never touched, and `keepDisabled` lists sweeps
+     * that must stay disabled on unlock.
+     * @returns false when the lock could not be applied (SDK without Sweep.disable, unknown current sweep)
+     */
+    setNavigationLocked(sdk: any, locked: boolean, sweepCollection?: Record<string, any> | null, currentSweepId?: string | null, keepDisabled?: string[]): Promise<boolean>;
+    isNavigationLocked(): boolean;
+    /** Sweeps currently disabled by the navigation lock */
+    getSweepsDisabledByLock(): string[];
+    /**
+     * Legacy API: attaches a gizmo to a model node. Prefer attachGizmo(uuid, mode).
+     */
+    attachGizmoControlTo3DObject(sdk: any, modelNode: any, sceneObject: any, mode: GizmoMode, visible: boolean, isNewObject: boolean): Promise<any>;
+    /** Removes the gizmo of the last added / edited object */
     removeGizmoFromLastObject(): void;
-    toggleViewFrustum(): void;
+    private applyViewFrustum;
+    /** Shows / hides the view frustum of the security camera `uuid` */
+    setViewFrustum(uuid: string, visible: boolean): boolean;
+    isViewFrustumVisible(uuid: string): boolean;
+    /** Toggles the frustum of `uuid`, or of the last loaded security camera when omitted */
+    toggleViewFrustum(uuid?: string): void;
     clear(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<MatterportObject3DService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MatterportObject3DService>;

package/lib/services/matterport-tag.service.d.ts

@@ -121,11 +121,11 @@ export declare class MatterportTagService {
      * floor and room context. Must be called after each sweep, floor or mode change.
      *
      * Rules:
-     *  - DOLLHOUSE / FLOORPLAN → all tags hidden (opacity 0).
-     *  - INSIDE → only tags whose sweep belongs to the current floor are shown;
-     *    proximity-based opacity is applied via computeTagOpacity().
-     *    Tags on other floors are hidden (opacity 0).
-     *  - TRANSITIONING → no change (skip update to avoid flickering).
+     *  - A tag shows when its sweep is on the floor being displayed, in every mode. Tags on
+     *    other floors are hidden (opacity 0) and cannot be opened.
+     *  - While all floors are displayed - the usual state of DOLLHOUSE and FLOORPLAN - every
+     *    tag shows.
+     *  - A tag with no sweep belongs to no floor and always shows.
      *
      * @param sdk          Matterport SDK instance.
      * @param poseCamera   Current camera pose.

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

@@ -1,8 +1,8 @@
-import { NgZone } from '@angular/core';
+import { NgZone, OnDestroy } from '@angular/core';
 import { ActivatedRoute, Router } from '@angular/router';
 import { Subject } from 'rxjs';
 import { MattertagData } from '../mattertagData';
-import { DbObjectType, IObject3D, MattertagActionMode, MatterportView, POI, PoiType, SpModule } from '../types.service';
+import { DbObjectType, GizmoMode, GizmoSnap, IObject3D, MattertagActionMode, MatterportView, Object3DBoundingBox, Object3DPlacementResult, Object3DTransform, Object3DTransformChange, POI, PoiType, Point3D, SpModule } from '../types.service';
 import { BaseTagService } from './tag.service';
 import { BaseVisibilityService } from './baseVisibility.service';
 import { Config } from '../config';
@@ -42,7 +42,7 @@ declare global {
         };
     }
 }
-export declare class MatterportService {
+export declare class MatterportService implements OnDestroy {
     private readonly sdkKey;
     private router;
     private activeRoute;
@@ -65,6 +65,18 @@ export declare class MatterportService {
     private isMeasureModeOn;
     private interactionMode;
     private cameraMode;
+    /** Emitted when a placement (tag following the cursor, or 3D object preview) is cancelled by right click or Escape */
+    readonly placementCancelled$: Subject<void>;
+    /** Pending interactive placement of a 3D object (see startObject3DPlacement) */
+    private object3DPlacement;
+    /** Sweeps snapshot taken when navigation is locked (disabled sweeps vanish from Sweep.data) */
+    private lockedSweepsSnapshot;
+    /**
+     * Every sweep seen in Sweep.data. After an unlock the SDK re-emits the re-enabled sweeps little by
+     * little: a lock asked meanwhile must still know all of them (it found nothing to disable).
+     */
+    private knownSweeps;
+    private keydownTargets;
     get mattertagIDs(): Array<string>;
     set mattertagIDs(value: Array<string>);
     get dictionnaryTags(): Map<string, MattertagData>;
@@ -414,15 +426,102 @@ export declare class MatterportService {
     clearAll(): Promise<void>;
     removeForbiddenSweeps(forbiddenSweeps: string[]): Promise<void>;
     init3DObjectViewer(): Promise<void>;
-    add3DObject(obj: IObject3D, mode?: 'translate' | 'rotate'): Promise<any>;
+    /**
+     * Adds a 3D model; resolves once it is loaded, rejects on unknown format or load timeout (~15 s).
+     */
+    add3DObject(obj: IObject3D, mode?: GizmoMode): Promise<any>;
     toggleObjectVisibility(objectId: any): void;
     isObjectVisible(objectId: any): boolean;
-    pointCameraTo3DObject(objectId: any): Promise<void>;
+    /** Moves the camera to the object (centered on its bounding box). Resolves false when the object is unknown. */
+    /**
+     * Moves the camera to the sweep closest to a 3D object and turns it toward the object.
+     * @param visibleArea client X bounds of the part of the viewer not covered by other panels
+     *                    (the lateral menu covers the right of the viewer): the object is centered there.
+     * Falls back to the temporary tag navigation when no sweep can be used.
+     */
+    pointCameraTo3DObject(objectId: any, visibleArea?: {
+        left: number;
+        right: number;
+    }): Promise<boolean>;
     getSceneNodeFromObject3DId(uuid: string): any;
     displayAzimutalCrown(): Promise<void>;
-    attachGizmoControlTo3DObject(modelNode: any, sceneObject: any, mode: 'translate' | 'rotate' | 'scale', visible: boolean, isNewObject: boolean): Promise<any>;
+    attachGizmoControlTo3DObject(modelNode: any, sceneObject: any, mode: GizmoMode, visible: boolean, isNewObject: boolean): Promise<any>;
     removeGizmoFromLastObject(): void;
-    toggleViewFrustum(): void;
+    /** Toggles the frustum of the security camera `uuid` (default: the last loaded one) */
+    toggleViewFrustum(uuid?: string): void;
+    setViewFrustum(uuid: string, visible: boolean): boolean;
+    isViewFrustumVisible(uuid: string): boolean;
+    /** Emits on gizmo changes and on setObject3DTransform / placeObject3DOnSurface / normalizeObject3DSize */
+    get object3DTransformChanged$(): Subject<Object3DTransformChange>;
+    /** World-space bounding box, null when the object is unknown or not loaded */
+    getObject3DBoundingBox(uuid: string): Object3DBoundingBox | null;
+    /** Dimensions of the model in meters, without its rotation */
+    getObject3DDimensions(uuid: string): Point3D | null;
+    /** Uniform scale so the largest dimension equals `targetSizeMeters`; returns the new scale or null */
+    normalizeObject3DSize(uuid: string, targetSizeMeters: number): Point3D | null;
+    /** Moves the object so its bounding box bottom-center (top-center on a ceiling) lies on `point` */
+    placeObject3DOnSurface(uuid: string, point: Point3D, normal?: Point3D, frontYawOffset?: number): Object3DTransform | null;
+    getObject3DTransform(uuid: string): Object3DTransform | null;
+    /** Rotation in radians */
+    setObject3DTransform(uuid: string, transform: Partial<Object3DTransform>): boolean;
+    attachGizmo(uuid: string, mode: GizmoMode): Promise<boolean>;
+    setGizmoMode(mode: GizmoMode): void;
+    detachGizmo(uuid?: string): void;
+    isGizmoAttached(uuid?: string): boolean;
+    /** null disables snapping (default) */
+    setGizmoSnap(snap: GizmoSnap | null): void;
+    /** Limits of a translate drag from its start (default 2 m, +/- 1.5 m vertically) */
+    setGizmoMaxDragDistance(maxDistance: number, maxHeight?: number): void;
+    /**
+     * Locks / unlocks camera navigation to other sweeps while a gizmo is edited: every enabled sweep
+     * except the current one is disabled, and exactly those are re-enabled on unlock.
+     * @returns false when the lock could not be applied (SDK not ready, current sweep unknown)
+     */
+    setNavigationLocked(locked: boolean): Promise<boolean>;
+    isNavigationLocked(): boolean;
+    /**
+     * Makes an already loaded model follow the cursor on the surfaces of the visit.
+     * Left click resolves with the surface point / normal under the cursor (read the object origin
+     * with getObject3DTransform); right click or Escape hides the model and resolves null
+     * (deleting it is up to the caller). Resolves null right away if another interaction is running.
+     */
+    startObject3DPlacement(uuid: string, options?: {
+        frontYawOffset?: number;
+    }): Promise<Object3DPlacementResult | null>;
+    isPlacingObject3D(): boolean;
+    /** Cancels the running object placement (model hidden, promise resolves null) */
+    cancelObject3DPlacement(): void;
+    /**
+     * Drops the object where it is previewed (same as a left click). Touch screens have no hover: each
+     * tap moves the preview, and the app confirms with a button.
+     * @returns false when no surface was pointed yet
+     */
+    confirmObject3DPlacement(): boolean;
+    /** True once the preview stands on a surface (the placement can be confirmed) */
+    hasObject3DPlacementPoint(): boolean;
+    private validateObject3DPlacement;
+    private endObject3DPlacement;
+    private updateObject3DPlacementPreview;
+    /** Token for the pointer trick: truthy while something follows the cursor (tag or 3D object) */
+    private getFollowTarget;
+    /**
+     * Cancels whatever follows the cursor (right click / Escape): the 3D object preview, or the tag.
+     * Emits placementCancelled$ when something was actually running.
+     */
+    private cancelCurrentPlacement;
+    /** Escape cancels any placement. Listens on the page and on the (same-origin) Showcase iframe, which takes the focus on click. */
+    private registerEscapeListener;
+    private removeEscapeListener;
+    ngOnDestroy(): void;
+    /**
+     * Closest enabled sweep to a world position (for instance to re-assign the zone of a moved object).
+     * `sweepId` is the DB-format id (like currentSweep), `sid` the SDK id. null when no sweep is known.
+     */
+    findNearestSweep(position: Point3D): {
+        sweepId: string;
+        sid: string;
+        floorSequence: number | null;
+    } | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<MatterportService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MatterportService>;
 }

package/lib/services/obj-to-glb.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Converts an .obj model, with its .mtl and textures, into the .glb the Three.js viewer loads - in
+ * the browser, as the model is added, with nothing to install.
+ *
+ * It does what obj2gltf did in converte-modelo.sh, and the reason is the same. An .obj lists every
+ * corner of every triangle; loaded as it is, a captured model's 2.6 million distinct vertices become
+ * 12.6 million, one per corner. Here each position and texture coordinate pair becomes one vertex,
+ * shared by every triangle that uses it, so what reaches the graphics card is the 2.6 million.
+ *
+ * Textures go in as they are, their bytes untouched: a JPEG re-encoded would lose quality and gain
+ * nothing. Normals are only written when the .obj has them; without, the viewer works them out as
+ * it loads the model. The axes are left as the .obj has them - the viewer finds which way is up.
+ *
+ * The .obj is read as a stream, so a file of hundreds of megabytes is never held whole.
+ */
+export interface ConvertedModel {
+    /** The model as a .glb. */
+    file: File;
+    vertices: number;
+    triangles: number;
+    materials: number;
+    /** Textures the .mtl names that were not among the files given; those materials go untextured. */
+    missingTextures: string[];
+}
+export interface ObjConversionOptions {
+    /** Called as the conversion goes, with the share done so far. */
+    onProgress?: (fraction: number) => void;
+    /** Stops the conversion; it then rejects with an AbortError. */
+    signal?: AbortSignal;
+}
+/** Whether a set of files holds an .obj model to convert. */
+export declare function hasObjModel(files: {
+    name: string;
+}[]): boolean;
+/**
+ * Converts the .obj among `files` into a .glb, using the .mtl and the images found with it.
+ */
+export declare function convertObjToGlb(files: File[], options?: ObjConversionOptions): Promise<ConvertedModel>;
+/** A growable typed array: an .obj does not say up front how many of anything it holds. */
+declare class Growable<T extends Float64Array | Float32Array | Int32Array> {
+    data: T;
+    length: number;
+    constructor(data: T);
+    push(value: number): void;
+    view(): T;
+}
+/** The triangles that use one material, as corners: position, texture and normal index each. */
+interface FaceGroup {
+    material: string | null;
+    corners: Growable<Int32Array>;
+}
+export interface ParsedObj {
+    positions: Float64Array;
+    uvs: Float64Array;
+    normals: Float64Array;
+    groups: FaceGroup[];
+    materialLibraries: string[];
+    triangleCount: number;
+}
+/**
+ * Reads an .obj from a stream of its bytes: positions, texture coordinates, normals, and triangles
+ * grouped by material. Polygons are split into triangles; negative indices, counting back from the
+ * end, are resolved; anything else (objects, groups, smoothing) is skipped.
+ */
+export declare function readObj(stream: ReadableStream<Uint8Array>, size: number, options?: ObjConversionOptions): Promise<ParsedObj>;
+export {};

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

@@ -7,6 +7,13 @@ export declare const uploadFileToS3: (path: string, file: File, objectId: string
  * uploadFileToS3 above swallows progress, which is fine for a photo and unusable for a 3D model:
  * these run to hundreds of megabytes, and an upload with no feedback is indistinguishable from a
  * frozen page. Returns the stored key, which is what gets saved on the record.
+ *
+ * A large file is sent in parts, each signed when it is sent. Left to itself, Storage.put signs
+ * them all with whatever credentials Amplify last handed the S3 provider, for any call - credentials
+ * that last an hour at most, and an upload of a few gigabytes takes longer: every part after they
+ * expire is refused with "The provided token has expired", and fetching new ones does not help, the
+ * upload never asks for them. Passing no credentials at all makes it ask Amplify for them part by
+ * part, and Amplify renews them as they age. Should they run out anyway, it starts once more.
  */
 export declare const uploadFileToS3WithProgress: (path: string, file: File, onProgress?: (fraction: number) => void) => Promise<string>;
 export declare const getSignedImageUrlForEquipment: (equip: Equipment) => Promise<string | null>;