@smarterplan/ngx-smarterplan-core 1.4.11 → 1.4.13

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

@@ -57,6 +57,31 @@ export declare class MatterportNavigationService {
      * Disable forbidden sweeps. Resolves each sweep ID to sid before calling SDK.
      */
     removeForbiddenSweeps(sdk: any, forbiddenSweeps: string[]): Promise<void>;
+    /**
+     * Move to a position
+     * @param sdk
+     * @param position
+     * @param rotation
+     * @param options
+     */
+    move_to_position(sdk: any, position: {
+        x: number;
+        y: number;
+        z: number;
+    }, rotation: {
+        yaw: number;
+        pitch?: number;
+        roll?: number;
+    } | null, options?: {
+        transition?: 'FLY' | 'INSTANT' | 'IMMEDIATE';
+        durationMs?: number;
+        anglesInDegrees?: boolean;
+        offset?: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }): Promise<void>;
     /**
      * Returns the current sweep as a **uuid** (for database matching).
      * The SDK's poseCamera.sweep is a sid; we translate it.

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

@@ -0,0 +1,129 @@
+import { BehaviorSubject } from 'rxjs';
+import { TranslateService } from '@ngx-translate/core';
+import { NavigationService } from './models/navigation.service';
+import { PoiService } from './models/poi.service';
+import { TicketsService } from './models/ticket.service';
+import { EquipmentService } from './models/equipment.service';
+import { Object3DService } from './models/object3D.service';
+import { FeatureService } from './models/feature.service';
+import { MeasurementService } from './models/measurement.service';
+import { CommentService } from './models/comment.service';
+import { BaseUserService } from './user.service';
+import { Vec3 } from './utils/matterport-transform.util';
+import * as i0 from "@angular/core";
+/** Progress snapshot emitted during copyTagsFromVisit(), so the UI can show a live status. */
+export interface CopyProgress {
+    phase: 'collecting' | 'tickets' | 'equipments' | 'pois' | 'objects3d' | 'features' | 'measurements' | 'done';
+    processedInPhase: number;
+    totalInPhase: number;
+    processedOverall: number;
+    totalOverall: number;
+    percent: number;
+    errorCount: number;
+}
+/** A single line in the copy log — either a step status (updated in place) or an error (appended once). */
+export interface CopyLogEntry {
+    id: string;
+    type: 'step' | 'error';
+    text: string;
+}
+export declare class MatterportTagCopyService {
+    private navigationService;
+    private userService;
+    private poiService;
+    private ticketService;
+    private equipmentService;
+    private object3DService;
+    private featureService;
+    private measurementService;
+    private commentService;
+    private translate;
+    copyProgress$: BehaviorSubject<CopyProgress | null>;
+    copyLog$: BehaviorSubject<CopyLogEntry[]>;
+    private spModule;
+    private log;
+    private errorSeq;
+    constructor(navigationService: NavigationService, userService: BaseUserService, poiService: PoiService, ticketService: TicketsService, equipmentService: EquipmentService, object3DService: Object3DService, featureService: FeatureService, measurementService: MeasurementService, commentService: CommentService, translate: TranslateService);
+    copyTagsFromVisit(sourceSpaceId: string, targetSpaceId: string, landmarkSourceA: Vec3, landmarkTargetA: Vec3, landmarkSourceB: Vec3, landmarkTargetB: Vec3): Promise<boolean>;
+    /** Adds or updates a step line (identified by stepId) with new text, then republishes the log. */
+    private setStepLog;
+    /** Appends a new, permanent log line (never overwritten), then republishes the log. */
+    private appendErrorLog;
+    /** Resets the log for a new run. */
+    private resetLog;
+    /** Builds and sets a step's log line as "<translated label>: <percent>%", no step numbering. */
+    private setStepProgress;
+    /** Logs a translated, parameterized error line for a single failed item. */
+    private logItemError;
+    /** Logs an item-level error, using a specific "missing file / orphaned reference"
+     *  translation key when the cause is a MissingS3FileError, and the generic per-type
+     *  key otherwise. Keeps the copy log readable: a missing file is not a bug to
+     *  investigate the same way a network/permission error is. */
+    private logCopyItemError;
+    /**
+     * Heuristic duplicate-detection: compares title AND description together instead of
+     * title alone, to reduce false positives when several source items happen to share
+     * the same title. Not a perfect guarantee, but meaningfully more robust.
+     */
+    private matchesExisting;
+    /**
+     * Fetches the position of every sweep in a space and returns it as a Map for O(1) lookup.
+     * Uses allSettled so a single failing sweep lookup doesn't abort the whole map —
+     * that sweep is simply absent from the resulting map (and skipped later).
+     */
+    private buildNavigationPositionMap;
+    /** Applies the rigid transform to a POI coordinate (position + orientation). */
+    private getAdjustedCoordinates;
+    /**
+     * Applies the rigid transform's translation+rotation to a plain {x,y,z} position,
+     * WITHOUT adding xRotation/yRotation keys. Used for measurements, whose stored
+     * coordinate is a bare position (no orientation), unlike other POI types.
+     */
+    private getAdjustedPositionOnly;
+    /**
+     * Finds the closest target sweep, comparing positions in the SAME coordinate frame.
+     * Pure in-memory lookup — no network call, thanks to the pre-built position maps.
+     */
+    private findClosestTargetSweepId;
+    /** Generates a short random id, used to give each copied S3 file a fresh, collision-safe key. */
+    private generateShortId;
+    /**
+     * Builds a new S3 key for a copied attachment and sanitizes the filename
+     * to prevent AWS Amplify SignatureDoesNotMatch errors.
+     */
+    private buildCopiedAttachmentKey;
+    /**
+     * Duplicates an S3 object if a key is present.
+     * - If the source file is genuinely missing from S3 (NoSuchKey / orphaned DB reference),
+     *   throws a MissingS3FileError so the caller can log a clear, specific message and
+     *   skip the whole item entirely, rather than creating a record with a broken file link.
+     * - Any other kind of failure (permissions, network, etc.) still throws a generic Error.
+     */
+    private copyS3KeyIfPresent;
+    /**
+     * Duplicates the file referenced by a POI's tagIcon (a JSON string shaped like
+     * { src, opacity }, per form-feature.component.ts). If the JSON can't be parsed or
+     * has no `src`, the value is returned unchanged rather than risk corrupting it.
+     */
+    private duplicateTagIcon;
+    /**
+     * Duplicates tagImageID if it looks like a reference to a file (contains a path
+     * separator, whether raw key or pre-signed URL). UNCONFIRMED ASSUMPTION: this
+     * field's exact semantics weren't verified — if it's actually an opaque reference
+     * to another DB record rather than a file, this heuristic may incorrectly attempt
+     * a copy. Confirm the real structure to tighten this if it causes issues.
+     */
+    private duplicateTagImageID;
+    /**
+     * Extracts and normalizes the raw S3 key from a stored value (which may be a full URL
+     * or already a raw key).
+     * IMPORTANT: this must return the RAW (decoded, non URL-encoded) key. Amplify's
+     * Storage.copy() already builds and encodes the 'x-amz-copy-source' header internally
+     * from the key we give it. Pre-encoding it here caused a double-encoding bug (e.g. a
+     * space became "%2520" instead of "%20"), so Storage.copy() looked for a key that never
+     * existed on S3, resulting in a NoSuchKey error.
+     */
+    private extractS3KeyFromValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatterportTagCopyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatterportTagCopyService>;
+}

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

@@ -6,6 +6,8 @@ import { BaseTagService } from './tag.service';
 import * as i0 from "@angular/core";
 export declare class MatterportTagService {
     private navigationService;
+    /** Name of the common layer every Smarterplan tag is created in. */
+    private static readonly SHARED_TAG_LAYER_NAME;
     dictionnaryTags: Map<string, MattertagData>;
     tagAddQueue: Promise<any>;
     mattertagToFollow: string | null;
@@ -16,10 +18,61 @@ export declare class MatterportTagService {
     tagService: BaseTagService | null;
     private tagsCurrentOpacity;
     private tagsCurrentEnabled;
+    /**
+     * Single layer holding every Smarterplan tag, added to every view of the space so a
+     * tag stays in place — same sid, same content — when the user switches between the
+     * furnished and the Defurnished view. Tags added to the global sdk.Tag (or to a
+     * view's own layer) belong to that view only, which is what made them pop in and out
+     * on every view change.
+     *
+     * Deliberately NOT created with `{ common: true }`: in SDK 26.7.5 a common layer is
+     * pushed into `getOrderedModelViews()` at creation time, and that call defaults to
+     * `includeDefurnish: false`, so the Defurnished view never receives it — while
+     * `View.addLayer()` refuses to repair it ("Layer is common. No need to add."). A
+     * plain layer we attach to each view ourselves reaches every view, Defurnished
+     * included. See attachSharedTagLayerToViews().
+     */
+    private sharedTagLayer;
+    private sharedTagLayerPromise;
     constructor(navigationService: MatterportNavigationService);
     setTagService(service: BaseTagService): void;
     /** Opens a specific tag in the Matterport viewer by its ID. */
     goToTag(sdk: any, sid: string): Promise<any>;
+    /**
+     * Returns the SDK Tag module to use for an operation addressing an existing tag by ID
+     * (icon, opacity, position, attachments, removal...): always the global sdk.Tag.
+     *
+     * A layer-scoped Tag module only exposes the *replayable* mutations, meant to build
+     * the layer's own content; applying them to an already-created tag silently does
+     * nothing — which is what left every pin white instead of carrying its icon. Only
+     * `add` has to go through the layer, see getTagCreationModule().
+     */
+    getTagModule(sdk: any, tagId: string): any;
+    /**
+     * Returns the Tag module every new tag must be created through: the shared layer
+     * when the View API is available, the global sdk.Tag otherwise.
+     */
+    getTagCreationModule(sdk: any): Promise<any>;
+    /**
+     * Creates (once per SDK session) and returns the shared tag layer.
+     * Resolves to null when the View API is unavailable, so callers transparently fall
+     * back to the global sdk.Tag.
+     */
+    ensureSharedTagLayer(sdk: any): Promise<any>;
+    /**
+     * Makes sure the shared layer is part of every view of the space, Defurnished
+     * included. This is what actually shares the tags across views, and the reason the
+     * layer must not be a common one: the SDK only performs the attachment for
+     * non-common layers. Idempotent, so it can run on every view collection update.
+     */
+    attachSharedTagLayerToViews(sdk: any, views: Iterable<any>): Promise<void>;
+    /**
+     * Adds a tag through the shared layer so it exists in every view. Falls back
+     * to the global sdk.Tag when the View API is unavailable; that call is raced against
+     * a timeout as a safety net, since it never resolves while a Defurnished view is
+     * active.
+     */
+    private addTagToSdk;
     /** Opens the most recently created tag in the viewer. */
     goToLastTag(sdk: any): Promise<any>;
     /**
@@ -38,12 +91,6 @@ export declare class MatterportTagService {
      * If there are no active rooms (e.g., hallway), falls back to returning true.
      */
     isTagInRooms(mattertagData: MattertagData, rooms: any[]): boolean;
-    /**
-     * Computes the final context-aware opacity for a single tag.
-     * @param currentFloorSequence  Authoritative current floor sequence from sdk.Floor.current
-     *                              (null = single-floor model or unknown).
-     * @param currentRooms          Array of active rooms the camera is in.
-     */
     /** Returns the ID of the most recently added tag. */
     getLastTag(): string | null;
     /**
@@ -64,6 +111,13 @@ export declare class MatterportTagService {
      * @param mattertagToFollow  ID of the cursor tag (never touched).
      */
     updateTagsVisibilityForContext(sdk: any, sweepCollection: any, currentCameraMode: CameraMode, mattertagToFollow: string | null, currentFloorSequence?: number | null, currentRooms?: any[]): Promise<void>;
+    /**
+     * Drops the memoized opacity/enabled state so the next visibility pass re-applies it
+     * to every tag. Needed after a view switch (furnished <-> defurnished): the SDK
+     * re-renders the shared layer's tags and the cached values would otherwise make
+     * updateTagsVisibilityForContext() skip them, leaving tags stuck invisible.
+     */
+    resetVisibilityCache(): void;
     /** Removes a specific tag from the viewer and local dictionaries. */
     deleteMattertagFromId(sdk: any, mattertagID: string): Promise<void>;
     /** Removes the last added tag from the viewer. */
@@ -74,7 +128,7 @@ export declare class MatterportTagService {
      * Creates and configures a Mattertag from a POI, handling coordinates, normals, and sweep ID.
      * Skips creation if a tag for the object already exists.
      */
-    createMattertagFromPOI(sdk: any, tagType: PoiType, object: DbObjectType, poi: POI, poseCamera: any, getTagFromElementId: (id: string) => {
+    createMattertagFromPOI(sdk: any, tagType: PoiType, object: DbObjectType, poi: POI, getTagFromElementId: (id: string) => {
         tag: string;
         sweep: string;
     }, setTagIconAndOpacity: (sid: string, mt: MattertagData) => Promise<void>, injectHtmlInTag: (type: PoiType, obj: DbObjectType, sid: string) => Promise<void>): Promise<any>;

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

@@ -2,7 +2,7 @@ import { NgZone } from '@angular/core';
 import { ActivatedRoute, Router } from '@angular/router';
 import { Subject } from 'rxjs';
 import { MattertagData } from '../mattertagData';
-import { DbObjectType, IObject3D, MattertagActionMode, POI, PoiType, SpModule } from '../types.service';
+import { DbObjectType, IObject3D, MattertagActionMode, MatterportView, POI, PoiType, SpModule } from '../types.service';
 import { BaseTagService } from './tag.service';
 import { BaseVisibilityService } from './baseVisibility.service';
 import { Config } from '../config';
@@ -104,6 +104,15 @@ export declare class MatterportService {
         action: string;
         data: string;
     }>;
+    /** Views (furnished, defurnished...) exposed by the SDK for the current space. */
+    private viewsByType;
+    private currentView;
+    private viewSubscriptions;
+    /** Emits the active view every time the user switches between furnished/defurnished. */
+    onViewChanged: Subject<MatterportView | null>;
+    /** Delay left to the SDK to rebuild the layer's tags after a view switch. */
+    private static readonly VIEW_SWITCH_REFRESH_DELAY_MS;
+    private viewSwitchRestoreTimer;
     get mattertagToFollow(): string | null;
     set mattertagToFollow(value: string | null);
     get inTransitionMode(): boolean;
@@ -186,10 +195,40 @@ export declare class MatterportService {
     setRegistredIconForTag(mattertagID: string, iconName: string): Promise<void>;
     /** Sets the appropriate icon and opacity for a tag based on its type and POI metadata. */
     setTagIconAndOpacity(mattertagID: string, mattertagData: MattertagData): Promise<void>;
+    /**
+     * Applies an icon to a tag. The call is awaited and its rejection reported: a
+     * silently dropped promise here leaves the pin with its default white look.
+     */
+    private editTagIcon;
     /** Navigates the camera to the most recently created tag. */
     goToLastTag(): Promise<void>;
     /** Navigates the camera to a specific Mattertag by its ID. */
     goToTag(mattertagID: string): Promise<void>;
+    /**
+     * Move the viewer camera to a specific 3D position and apply a rotation.
+     * Delegates the heavy lifting to MatterportNavigationService.move_to_position.
+     * - position: { x, y, z }
+     * - rotation: { yaw, pitch?, roll? } in degrees by default
+     * - options: optional transition and conversion settings (see navigation service)
+     */
+    goToPosition(position: {
+        x: number;
+        y: number;
+        z: number;
+    }, rotation?: {
+        yaw: number;
+        pitch?: number;
+        roll?: number;
+    } | null, options?: {
+        transition?: 'FLY' | 'INSTANT' | 'IMMEDIATE';
+        durationMs?: number;
+        anglesInDegrees?: boolean;
+        offset?: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }): Promise<void>;
     /**
       * Computes the context-aware opacity for a single tag at the moment it is rendered.
       * - Cursor tag: always use provided defaultOpacity.
@@ -300,6 +339,47 @@ export declare class MatterportService {
      * @returns MattertagData
      */
     getMatterTagDataForMattertag(mattertagID: string): MattertagData | null;
+    /**
+     * Subscribes to the SDK View API to keep track of the views available for the space
+     * and of the active one. Tags live in a shared common layer, so a view change only
+     * requires re-applying their visibility, never re-creating them.
+     */
+    private initViews;
+    /**
+     * Forces the opacity/enabled state to be pushed again to every tag. The SDK
+     * re-renders the shared layer's tags on a view swap, and the memoized values would
+     * otherwise make updateTagsVisibilityForContext() skip them, leaving tags invisible.
+     */
+    private reapplyTagsVisibility;
+    /**
+     * Puts the tags back in shape in the view that just became active.
+     *
+     * Activating a view re-materializes the shared layer's tags from the descriptors
+     * recorded when they were added, so everything applied to a tag *afterwards* through
+     * the global Tag module is dropped along the way: the custom icon (the pin falls back
+     * to the descriptor's white) and the sandbox carrying the hover content. They have to
+     * be applied again on the freshly rebuilt tags.
+     *
+     * Visibility is refreshed straight away so the tags show up without waiting, then
+     * content is re-applied once the transition is over — re-applying it too early would
+     * target tags the SDK has not rebuilt yet.
+     */
+    private restoreTagsForActiveView;
+    /**
+     * Re-applies the icon and the injected HTML of every tag we own. Used after a view
+     * switch, see restoreTagsForActiveView().
+     */
+    private refreshTagsContent;
+    private clearViewSubscriptions;
+    /** True when the space provides a defurnished view. */
+    get hasDefurnishView(): boolean;
+    /** True when the defurnished view is the active one. */
+    get isDefurnishedView(): boolean;
+    /**
+     * Switches between the defurnished view and the furnished one.
+     * @param returnToStart Move the camera back to the view's start location.
+     */
+    toggleDefurnishView(returnToStart?: boolean): Promise<void>;
     action_toolbox_floorplan(): Promise<void>;
     action_toolbox_inside_view(): void;
     actionShowAllFloors(): void;

package/lib/services/models/equipment.service.d.ts

@@ -63,6 +63,14 @@ export declare class EquipmentService extends BaseObjectService {
         nextToken: string | null;
     }>;
     uploadImageForAllEquipments(equipments: Equipment[], imageFile: File): Promise<Equipment[]>;
+    /**
+     * Creates a Note attached to an equipment from an S3 key that ALREADY exists
+     * (as opposed to uploadDoc/uploadImage, which upload a fresh browser File).
+     * Used when duplicating equipment attachments during a cross-visit copy: the
+     * S3 object itself has already been physically copied by the caller beforehand,
+     * so this only needs to record the Note pointing at that new key.
+     */
+    createNoteWithExistingAttachment(equipmentID: string, attachmentKey: string, type: TypeNote, ownerMissionID: string | null): Promise<Note>;
     uploadImage(equipment: Equipment, imageFile: File): Promise<Note>;
     updateEquipment(equip: any, file?: File, noteType?: TypeNote): Promise<Equipment>;
     getPrefixDoc(type: TypeNote): any;

package/lib/services/models/poi.service.d.ts

@@ -19,6 +19,20 @@ export declare class PoiService {
     updatePoi(poi: {}): Promise<POI>;
     deletePoi(poiID: string): Promise<POI>;
     getPoisByMatterportSweepByType(sweep: string, type: PoiType): Promise<POI[]>;
+    /**
+    * Optimized version: fetches POIs for MANY sweeps in as few GraphQL calls as possible,
+    * using an `or: [{ matterportSweepID: { eq } }, ...]` filter instead of looping one
+    * request per sweep. This is a DynamoDB Scan with a server-side filter (not a GSI
+    * hash-key query), so `or` composition works and collapses N sweep-by-sweep calls
+    * into a handful of paginated calls total.
+    *
+    * NOTE: `in` is NOT supported on this schema's ModelStringInput (older Amplify codegen),
+    * hence the `or` composition instead — functionally equivalent for this use case.
+    *
+    * Chunked because DynamoDB/AppSync filter expressions have a practical size ceiling —
+    * splitting keeps each request well within safe limits regardless of space size.
+    */
+    getPoisByMatterportSweeps(sweeps: string[]): Promise<POI[]>;
     unsubscribe(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<PoiService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PoiService>;

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

@@ -12,3 +12,11 @@ export declare const getSignedFile: (path: any) => Promise<string | null>;
 export declare const downloadFileAsObject: (path: any) => Promise<Object | void>;
 export declare const getBufferForFileFromS3: (path: any) => Promise<ArrayBuffer>;
 export declare const uploadJsonToS3: (path: string, json: string, filename: string) => Promise<string>;
+/**
+ * Physically duplicates an S3 object to a new key. Used when copying attachments
+ * between features/tickets/etc. so the copy is fully independent: deleting the
+ * original file later must not affect the copy.
+ * IMPORTANT: does NOT swallow errors — callers need the real error (e.g. NoSuchKey)
+ * to distinguish an orphaned DB reference from a genuine copy failure.
+ */
+export declare const copyFileInS3: (sourceKey: string, destKey: string) => Promise<string>;

package/lib/services/utils/matterport-transform.util.d.ts

@@ -0,0 +1,21 @@
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface RigidTransform {
+    rotationYRad: number;
+    refSource: Vec3;
+    refTarget: Vec3;
+}
+/**
+ * Computes the rigid transform (Y-axis rotation + translation) between two
+ * coordinate frames, from 2 pairs of points representing the same physical spot.
+ */
+export declare function computeRigidTransform(sourceA: Vec3, targetA: Vec3, sourceB: Vec3, targetB: Vec3): RigidTransform;
+/** Applies the rigid transform to a 3D position (x, y, z). */
+export declare function applyRigidTransformToPoint(p: Vec3, t: RigidTransform): Vec3;
+/** Applies the Y rotation (in degrees) to an orientation angle (a pose's yRotation). */
+export declare function applyRigidTransformToYRotationDeg(yRotationDeg: number, t: RigidTransform): number;
+/** Euclidean distance between two points, useful to validate landmark quality. */
+export declare function distance(a: Vec3, b: Vec3): number;

package/lib/types.service.d.ts

@@ -842,3 +842,21 @@ export type Object3D = {
         items: POI[];
     };
 } & AWSType;
+export declare enum MatterportViewType {
+    BASE = "viewtype.base",
+    DEFURNISH = "viewtype.defurnish",
+    LAYERED_BASE = "viewtype.layeredbase",
+    OTHER = "viewtype.other",
+    USER = "viewtype.user"
+}
+export interface MatterportView {
+    id: string;
+    name: string;
+    active: boolean;
+    type: MatterportViewType;
+    setActive(returnToStart?: boolean): Promise<void>;
+}
+export type MatterportViewCollection = Record<string, MatterportView>;
+export interface MatterportSubscription {
+    cancel(): void;
+}

package/package.json

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

package/public-api.d.ts

@@ -18,7 +18,9 @@ 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/matterport-tag-copy.service';
 export * from './lib/mattertagData';
+export * from './lib/services/utils/matterport-transform.util';
 export * from './lib/services/models/profile.service';
 export * from './lib/services/models/zone.service';
 export * from './lib/services/models/mission.service';