@smarterplan/ngx-smarterplan-core 1.4.17 → 1.4.18

package/lib/mattertagData.d.ts

@@ -52,6 +52,10 @@ export declare class MattertagData {
             b: number;
         };
     };
+    /**
+     * Safely retrieves the display name depending on object properties (name, title)
+     */
+    getDisplayName(): string;
     /**
      * Get the descriptor for sdk.Tag.add(...descriptor)
      * Format : [{ label, description, anchorPosition, stemVector, color, id? }]

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

@@ -1,5 +1,6 @@
 import { BehaviorSubject } from 'rxjs';
 import { TranslateService } from '@ngx-translate/core';
+import { POI } from '../types.service';
 import { NavigationService } from './models/navigation.service';
 import { PoiService } from './models/poi.service';
 import { TicketsService } from './models/ticket.service';
@@ -12,12 +13,13 @@ import { HashtagService } from './models/hashtag.service';
 import { MissionService } from './models/mission.service';
 import { OperationService } from './models/operation.service';
 import { DomainService } from './models/domain.service';
+import { ZoneService } from './models/zone.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';
+    phase: 'collecting' | 'tickets' | 'equipments' | 'pois' | 'objects3d' | 'features' | 'measurements' | 'recalibrating' | 'done';
     processedInPhase: number;
     totalInPhase: number;
     processedOverall: number;
@@ -36,6 +38,44 @@ export interface CopyLogEntry {
     type: 'step' | 'error' | 'healed';
     text: string;
 }
+/** A tag listed for recalibration, with what the UI needs to identify it. */
+export type RecalibrationTag = POI & {
+    elementName: string;
+    elementDescription?: string;
+    /** pass to getTagImageUrl() to get a displayable (signed) URL */
+    elementImageKey?: string;
+    /** floor zone (layer FLOOR) of the tag's sweep in the target space */
+    floorName?: string;
+    /** most specific other zone of the tag's sweep in the target space */
+    zoneName?: string;
+};
+/**
+ * Which tags of a space (location) a recalibration lists. A tag belongs to a location (the
+ * space of the element it points at; a standalone tag belongs to every location showing it)
+ * and is displayed in one or several virtual visits of that location. Tags of another
+ * location are never listed, even when both locations use the same visit.
+ *  - SPACE: every tag of the location, whichever of its visits it sits in;
+ *  - VISIT: the tags of the location placed on the sweeps of the selected visit.
+ */
+export type RecalibrationTagScope = 'SPACE' | 'VISIT';
+/** Both lists getRecalibrationTagSets() offers, see there. */
+export interface RecalibrationTagSets {
+    space: RecalibrationTag[];
+    visit: RecalibrationTag[];
+}
+export interface RecalibrationTagOptions {
+    /** Node of the selected target visit (visit.node.id): drives the VISIT list. */
+    targetNodeId?: string | null;
+    /** Only keep the tags that also exist in the source location (ignored when source = target). */
+    onlyTagsInSource?: boolean;
+}
+/** Outcome of recalibrateTagsFromVisit(): how many of the selected tags were moved. */
+export interface RecalibrationResult {
+    updated: number;
+    /** selected tags not found anymore, or without a position to move */
+    skipped: number;
+    failed: number;
+}
 export declare class MatterportTagCopyService {
     private navigationService;
     private userService;
@@ -51,6 +91,7 @@ export declare class MatterportTagCopyService {
     private operationService;
     private domainService;
     private translate;
+    private zoneService;
     copyProgress$: BehaviorSubject<CopyProgress | null>;
     copyLog$: BehaviorSubject<CopyLogEntry[]>;
     private spModule;
@@ -91,7 +132,7 @@ export declare class MatterportTagCopyService {
     private targetDomainIdsByTypeAndName;
     /** Target space id of the run in progress — used to re-home copied tag icons. */
     private targetSpaceId;
-    constructor(navigationService: NavigationService, userService: BaseUserService, poiService: PoiService, ticketService: TicketsService, equipmentService: EquipmentService, object3DService: Object3DService, featureService: FeatureService, measurementService: MeasurementService, commentService: CommentService, hashtagService: HashtagService, missionService: MissionService, operationService: OperationService, domainService: DomainService, translate: TranslateService);
+    constructor(navigationService: NavigationService, userService: BaseUserService, poiService: PoiService, ticketService: TicketsService, equipmentService: EquipmentService, object3DService: Object3DService, featureService: FeatureService, measurementService: MeasurementService, commentService: CommentService, hashtagService: HashtagService, missionService: MissionService, operationService: OperationService, domainService: DomainService, translate: TranslateService, zoneService: ZoneService);
     copyTagsFromVisit(sourceSpaceId: string, targetSpaceId: string, landmarkSourceA: Vec3, landmarkTargetA: Vec3, landmarkSourceB: Vec3, landmarkTargetB: Vec3): Promise<boolean>;
     /**
      * Serialises the current copy log (step lines as last emitted, plus every error and
@@ -362,6 +403,13 @@ export declare class MatterportTagCopyService {
     private buildNavigationPositionMap;
     /** Applies the rigid transform to a POI coordinate (position + orientation). */
     private getAdjustedCoordinates;
+    /**
+     * Reads a stored coordinate (JSON string or object, whatever its spacing) as a position.
+     * Null for a virtual POI or an unreadable value.
+     */
+    private parseCoordinate;
+    /** Two positions within 1 cm are the same (two virtual POIs, both null, are too). */
+    private isSamePosition;
     /**
      * Applies the rigid transform's translation+rotation to a plain {x,y,z} position,
      * WITHOUT adding xRotation/yRotation keys. Used for measurements, whose stored
@@ -425,6 +473,84 @@ export declare class MatterportTagCopyService {
      * existed on S3, resulting in a NoSuchKey error.
      */
     private extractS3KeyFromValue;
+    /**
+     * Both tag lists a recalibration can offer for a target space, computed in one pass. Only
+     * the target location's own tags are ever listed (see RecalibrationTagScope); tags whose
+     * element was deleted — orphan POIs — never are.
+     *  - `space`: every tag of the location, in any of its visits;
+     *  - `visit`: the tags of the location sitting on the sweeps of the selected target visit
+     *    (`options.targetNodeId`); empty when no visit is given.
+     * With `options.onlyTagsInSource` and a source other than the target, both lists only keep
+     * the tags that also exist in the source location (same identity as the copy's duplicate
+     * detection): typically the tags an earlier copy brought over.
+     *
+     * A POI carries no name of its own: each tag gets `elementName`, the name of the element
+     * it points at (ticket title, equipment name, ...).
+     */
+    getRecalibrationTagSets(sourceSpaceId: string, targetSpaceId: string, options?: RecalibrationTagOptions): Promise<RecalibrationTagSets>;
+    /**
+     * Signed, displayable URL of a tag's picture (`elementImageKey`). Meant to be called on
+     * demand — when the tag is previewed — rather than for the whole list.
+     */
+    getTagImageUrl(imageKey: string): Promise<string | null>;
+    /**
+     * Loads the POIs placed on the sweeps of a space whose element still exists, each with a
+     * display name, an identity key and whether its element belongs to that space. The key
+     * follows the same rules as the copy's duplicate detection (findExisting), so a tag and its
+     * copy in another space share the same key. With a visit node, `inVisit` tells whether the
+     * tag sits on one of that visit's sweeps.
+     */
+    private loadLiveTagsForSpace;
+    /**
+     * Sweeps of a virtual visit (a Node): those of the space's zones attached to that node,
+     * else — zones not filled in for this visit — the sweeps of the node's navigations.
+     */
+    private getSweepsOfVisit;
+    /**
+     * Maps each sweep of a space to the names of its floor (zone of layer FLOOR) and of its
+     * most specific other zone (the one holding the fewest sweeps, typically a room, else the
+     * visit's BUILDING zone).
+     */
+    private getSweepZones;
+    /**
+     * Indexes, by ID, every element of a space a POI can point at. Each list is fetched
+     * independently: one failing (module not enabled, missing permission) must not hide the
+     * others — their POIs are then resolved one by one by fetchTagElementsById().
+     */
+    private getTagElementsForSpace;
+    /**
+     * Fetches by ID the elements the space-wide lists did not return. The IDs are packed into
+     * a few GraphQL requests using aliases (`e0: getTicket(id: ...) e1: getEquipment(...)`),
+     * instead of one request per element: a space can hold over a thousand orphan POIs.
+     * An element that no longer exists comes back as null and is simply not indexed.
+     */
+    private fetchTagElementsById;
+    /**
+     * Moves a stored coordinate. Only the position and the horizontal orientation change:
+     * every other key is kept as is. A coordinate often carries the tag's orientation next to
+     * its position ({x, y, z, xRotation, yRotation}); rebuilding it from the position alone
+     * silently erased that orientation.
+     */
+    private getRecalibratedCoordinate;
+    /**
+     * Reads POIs by ID, 100 per GraphQL request (aliases). Missing POIs are skipped. Amplify
+     * rejects a request when ANY alias errors, but still hands over the data of the others:
+     * those are kept, so one unreadable POI does not hide the 99 others of its batch.
+     */
+    private fetchPoisById;
+    private tagElementTypeOf;
+    /** Display name + identity fields of an element, per the copy's duplicate-detection rules. */
+    private toTagElement;
+    private stripHtml;
+    /**
+     * Recalibrates a specific list of existing tags in the target space by applying the rigid
+     * transformation calculated from the selected landmark points.
+     *
+     * Each tag is updated on its own: a failing update is logged and counted, it no longer
+     * stops the remaining tags. Progress and log go through copyProgress$ / copyLog$, like a
+     * copy (phase 'recalibrating'). `tagLabels` (tag id -> name) only makes the log readable.
+     */
+    recalibrateTagsFromVisit(targetSpaceId: string, selectedTagIds: string[], landmarkSourceA: Vec3, landmarkTargetA: Vec3, landmarkSourceB: Vec3, landmarkTargetB: Vec3, tagLabels?: Record<string, string>): Promise<RecalibrationResult>;
     static ɵfac: i0.ɵɵFactoryDeclaration<MatterportTagCopyService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MatterportTagCopyService>;
 }

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

@@ -18,6 +18,13 @@ export declare class MatterportTagService {
     tagService: BaseTagService | null;
     private tagsCurrentOpacity;
     private tagsCurrentEnabled;
+    /** tagId -> icon name last applied, so an unchanged icon is not re-applied. */
+    private tagsCurrentIcon;
+    /** Ids of the global SDK Tag collection, and the tags waiting to appear in it, see waitForTagInSdk(). */
+    private sdkTagIds;
+    private sdkTagWaiters;
+    private sdkTagSubscription;
+    private sdkTagSubscriptionSdk;
     /**
      * 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
@@ -45,9 +52,25 @@ export declare class MatterportTagService {
      * 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().
+     * `add` has to go through the layer, see getTagCreationModule(). The global module
+     * only knows a layer-created pin once it is rendered: see waitForTagInSdk().
      */
     getTagModule(sdk: any, tagId: string): any;
+    /** Icon name last applied to a tag, if any. */
+    getCachedTagIcon(tagId: string): string | undefined;
+    /** Applies an icon to a tag through its own module and remembers it on success. */
+    editTagIcon(sdk: any, tagId: string, iconName: string): Promise<void>;
+    /**
+     * Resolves once the global SDK Tag collection — the one edits go through — contains the
+     * tag, so edits do not hit a pin that is not rendered yet ("setPinRenderOverrides on a pin
+     * that doesn't exist"). Gives up after `timeoutMs` and resolves anyway; falls back to a
+     * short wait when the collection cannot be observed. One subscription is shared by every
+     * waiting tag: a space loads hundreds of them.
+     */
+    private waitForTagInSdk;
+    /** Keeps sdkTagIds in sync with the global SDK Tag collection; false when it cannot be observed. */
+    private observeSdkTags;
+    private stopObservingSdkTags;
     /**
      * 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.

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

@@ -106,6 +106,12 @@ export declare class MatterportService {
     }>;
     /** Views (furnished, defurnished...) exposed by the SDK for the current space. */
     private viewsByType;
+    /** Settles once every static icon texture has been registered (or failed). */
+    private iconsRegistered;
+    /** Names of the textures successfully registered in the current SDK session. */
+    private registeredIcons;
+    /** tagId -> signed source last registered as a custom texture, and its texture name. */
+    private customIconCache;
     private currentView;
     private viewSubscriptions;
     /** Emits the active view every time the user switches between furnished/defurnished. */
@@ -193,11 +199,14 @@ export declare class MatterportService {
     addNewIconAndSetForTag(mattertagID: string, iconPath: string): Promise<void>;
     /** Applies a pre-registered icon to a Mattertag. */
     setRegistredIconForTag(mattertagID: string, iconName: string): Promise<void>;
-    /** Sets the appropriate icon and opacity for a tag based on its type and POI metadata. */
+    /** Registers a static texture and remembers its name once the SDK accepted it. */
+    private registerIcon;
+    /** Sets the appropriate icon 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.
+     * Applies an icon to a tag, unless that icon is already the one applied. 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. */

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

@@ -33,6 +33,7 @@ export declare class PoiService {
     * splitting keeps each request well within safe limits regardless of space size.
     */
     getPoisByMatterportSweeps(sweeps: string[]): Promise<POI[]>;
+    private scanPoisForSweepChunk;
     unsubscribe(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<PoiService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PoiService>;

package/package.json

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

package/src/assets/vs-app.json

@@ -1,67 +1,67 @@
-{
-  "version": "1.0",
-  "payload": {
-    "objects": [
-      {
-        "name": "slot_camera",
-        "position": {
-          "x": 2.8,
-          "y": 2.4,
-          "z": 10.71
-        },
-        "rotation": {
-          "x": 0,
-          "y": -22,
-          "z": 0
-        },
-        "scale": {
-          "x": 1,
-          "y": 1,
-          "z": 1
-        },
-        "components": [
-          {
-            "type": "mp.gltfLoader",
-            "inputs": {
-              "url": "https://static.matterport.com/showcase-sdk/examples/assets-1.0-2-g6b74572/assets/models/camera-1/scene.gltf",
-              "localScale": { "x": 0.0008, "y": 0.0008, "z": 0.0008 },
-              "localRotation": { "x": 0, "y": 90, "z": 0 }
-            },
-            "events": {
-              "INTERACTION.CLICK": false,
-              "INTERACTION.HOVER": false,
-              "INTERACTION.DRAG": false
-            }
-          },
-          {
-            "type": "mp.securityCamera",
-            "inputs": {
-              "nearPlane": 0.1,
-              "farPlane": 10,
-              "horizontalFOV": 52,
-              "aspect": 1.7777777777777777,
-              "localPosition": {
-                "x": 0,
-                "y": 0.18,
-                "z": -0.3
-              },
-              "localRotation": {
-                "x": -15,
-                "y": 0,
-                "z": 0
-              },
-              "color": 65280,
-              "panPeriod": 5,
-              "panAngle": -45
-            },
-            "events": {
-              "INTERACTION.CLICK": false,
-              "INTERACTION.HOVER": false,
-              "INTERACTION.DRAG": false
-            }
-          }
-        ]
-      }
-    ]
-  }
-}
+{
+  "version": "1.0",
+  "payload": {
+    "objects": [
+      {
+        "name": "slot_camera",
+        "position": {
+          "x": 2.8,
+          "y": 2.4,
+          "z": 10.71
+        },
+        "rotation": {
+          "x": 0,
+          "y": -22,
+          "z": 0
+        },
+        "scale": {
+          "x": 1,
+          "y": 1,
+          "z": 1
+        },
+        "components": [
+          {
+            "type": "mp.gltfLoader",
+            "inputs": {
+              "url": "https://static.matterport.com/showcase-sdk/examples/assets-1.0-2-g6b74572/assets/models/camera-1/scene.gltf",
+              "localScale": { "x": 0.0008, "y": 0.0008, "z": 0.0008 },
+              "localRotation": { "x": 0, "y": 90, "z": 0 }
+            },
+            "events": {
+              "INTERACTION.CLICK": false,
+              "INTERACTION.HOVER": false,
+              "INTERACTION.DRAG": false
+            }
+          },
+          {
+            "type": "mp.securityCamera",
+            "inputs": {
+              "nearPlane": 0.1,
+              "farPlane": 10,
+              "horizontalFOV": 52,
+              "aspect": 1.7777777777777777,
+              "localPosition": {
+                "x": 0,
+                "y": 0.18,
+                "z": -0.3
+              },
+              "localRotation": {
+                "x": -15,
+                "y": 0,
+                "z": 0
+              },
+              "color": 65280,
+              "panPeriod": 5,
+              "panAngle": -45
+            },
+            "events": {
+              "INTERACTION.CLICK": false,
+              "INTERACTION.HOVER": false,
+              "INTERACTION.DRAG": false
+            }
+          }
+        ]
+      }
+    ]
+  }
+}