@smarterplan/ngx-smarterplan-core 1.4.21 → 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-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/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>;