@smarterplan/ngx-smarterplan-core 1.4.12 → 1.4.14

package/lib/pipes/hashtag-from-id.pipe.d.ts

@@ -4,6 +4,15 @@ import * as i0 from "@angular/core";
 export declare class HashtagFromIdPipe implements PipeTransform {
     private hashtagService;
     constructor(hashtagService: HashtagService);
+    /**
+     * Resolves a hashtag id to its display name.
+     *
+     * The cache is consulted for THIS id, and the network answers whenever the id is not
+     * in it.
+     *
+     * Hashtag ids are globally unique, so a cache holding entries from several spaces can
+     * only ever produce a correct hit or a miss, never a wrong name.
+     */
     transform(hashtagID: string): Promise<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<HashtagFromIdPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<HashtagFromIdPipe, "hashtagFromID", false>;

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

@@ -8,6 +8,8 @@ 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 { HashtagService } from './models/hashtag.service';
+import { SpaceService } from './models/space.service';
 import { BaseUserService } from './user.service';
 import { Vec3 } from './utils/matterport-transform.util';
 import * as i0 from "@angular/core";
@@ -37,13 +39,37 @@ export declare class MatterportTagCopyService {
     private featureService;
     private measurementService;
     private commentService;
+    private hashtagService;
+    private spaceService;
     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);
+    /** source element id -> id of its copy in the target space. */
+    private elementIds;
+    /** source Comment id -> id of its copy. Needed to remap POI.tagImageID, which is a
+     *  reference to a Comment record (see the schema: "connection to comment.id"). */
+    private commentIds;
+    /** source Hashtag id -> its name. */
+    private sourceHashtagNames;
+    /** normalised hashtag name -> its id in the TARGET space (pre-existing or just created). */
+    private targetHashtagIdsByName;
+    /** ids of the hashtags this run created in the target space. */
+    private createdHashtagIds;
+    /** ids of the hashtags actually persisted on a successfully created feature. Anything in
+     *  createdHashtagIds but absent here is an orphan and is deleted at the end of the run. */
+    private usedHashtagIds;
+    /** source ids of the elements whose POIs were already created by an element phase.
+     *  Guards the standalone POI phase against creating a second, impoverished copy. */
+    private handledElementIds;
+    /** true when source and target spaces belong to the same organisation. Domains are
+     *  organisation-scoped (no spaceID), so domainID survives the copy only in that case. */
+    private sameOrganisation;
+    /** 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, spaceService: SpaceService, 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;
@@ -51,6 +77,10 @@ export declare class MatterportTagCopyService {
     private appendErrorLog;
     /** Resets the log for a new run. */
     private resetLog;
+    /** Clears every id map carried over from a previous run. The service is a root-level
+     *  singleton, so leftover mappings would silently link a new copy to records created
+     *  during the previous one. */
+    private resetRunState;
     /** 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. */
@@ -58,14 +88,152 @@ export declare class MatterportTagCopyService {
     /** 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. */
+     *  investigate the same way a network/permission error is.
+     *  `extraParams` carries the placeholders a few keys need on top of {{name}}/{{error}}
+     *  (e.g. errorFeatureAttachment's {{feature}}, errorPoi's {{sweep}}), which used to be
+     *  rendered as raw "{{feature}}" text in the log. */
     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.
+     * Null-safe equivalent of FeatureService.isArchived(): true when the operator has archived
+     * this feature on that space. "No mission on the space" answers false (nothing archived)
+     * instead of throwing, which is what made a copy from a space the operator is not a member
+     * of fail outright.
+     */
+    private isArchivedForOperator;
+    /**
+     * True when both spaces belong to the same organisation.
+     * Domains (POI/Feature categories) are organisation-scoped records with no spaceID, so
+     * a domainID stays meaningful inside one organisation and only becomes a dangling
+     * reference across two. A failed lookup answers "no": dropping a category is recoverable,
+     * pointing at another organisation's domain is not.
+     */
+    private spacesShareOrganisation;
+    /** Normalised lookup key for a hashtag name, so "Moyen Âge" and "moyen âge " match. */
+    private hashtagKey;
+    /**
+     * READ-ONLY indexing of both spaces' hashtags. Creates nothing.
+     *
+     * `Feature.hashtags` stores Hashtag *ids*, and a Hashtag is a per-space record, so the
+     * ids have to be translated by name. The translation table is built here; the missing
+     * keywords are created later, one at a time, only when a POI that actually uses them is
+     * about to be written (see resolveHashtagIds()).
+     */
+    private loadHashtagIndex;
+    /**
+     * Translates one feature's hashtag ids into target-space ids, creating on the fly the
+     * keywords the target space does not have yet.
+     *
+     * Creation is LAZY on purpose. Doing it up front, for the whole source vocabulary, meant
+     * that a copy which failed or was closed halfway left behind keywords no POI referenced —
+     * pollution the operator had to clean up by hand. Here a keyword is only ever written
+     * when a POI that carries it is about to be created, so an interrupted copy stops
+     * creating keywords at the same POI it stops creating content.
+     *
+     * The residual window (keyword created, then createFeature fails) is closed by
+     * markHashtagsUsed() + cleanupUnusedCreatedHashtags().
+     *
+     * A keyword that can neither be found nor created is dropped rather than left as a
+     * dangling id.
+     */
+    private resolveHashtagIds;
+    /** Records that these hashtags are now referenced by a feature that really exists, so
+     *  the end-of-run cleanup leaves them alone. */
+    private markHashtagsUsed;
+    /**
+     * Deletes the hashtags this run created that no copied POI ended up referencing.
+     *
+     * Runs on every exit path — success, general failure, or exception — so the target space
+     * never keeps keywords that came from an aborted copy. Only ids created by THIS run are
+     * ever considered: a pre-existing keyword of the target space is never touched, even if
+     * no copied POI uses it.
+     */
+    private cleanupUnusedCreatedHashtags;
+    /**
+     * Orders a feature's media set exactly the way the UI will read it back, and repairs
+     * the ordering key when the source data cannot express the user's intended order.
+     *
+     * The viewer sorts each media family on its own (`setImages`, `setVideos`, `setAudio`,
+     * `setDocuments`, ... all do `.sort((a, b) => a.index - b.index)`), so `index` only has
+     * to be consistent WITHIN a CommentType. The attachment form however defaults `index`
+     * to 1 for every new attachment, so a multi-image POI very often holds several images
+     * all sharing index 1 — or null. Sorting those is left to DynamoDB's arbitrary scan
+     * order, which is why the copy came out in a different order than the original.
+     *
+     * Strategy: sort deterministically (index, then creation date, then id — i.e. the
+     * upload order the user actually saw), and only rewrite the indices of a family when
+     * they are ambiguous (null or duplicated). A family whose indices are already unique
+     * is copied untouched, so a deliberate ordering is never overwritten.
+     */
+    private orderCommentsForCopy;
+    /** Sort key for a comment's position; a missing index sorts last, not first. */
+    private orderingIndexOf;
+    /** Creation timestamp of a comment, used as the tie-breaker: it reflects the order in
+     *  which the user uploaded the media, which is the order they saw. */
+    private creationTimeOf;
+    /**
+     * Copies ONE media item (image, video, audio, document, text, link, embed, iframe...)
+     * of a feature, duplicating its file in S3 first when it has one.
+     *
+     * Every column of the Comment model is carried over. `description` and `metadata` were
+     * previously dropped, which emptied the captions of images/videos, the body of TEXT
+     * items — where the whole content lives, since a TEXT comment has no file — and any
+     * per-media settings stored in metadata.
+     */
+    private copyCommentForFeature;
+    /** Same, for an attachment carried by a ticket rather than by a feature. */
+    private copyCommentForTicket;
+    /** Shared body of the two above: `owner` carries whichever foreign key links the copy back
+     *  to its new parent, everything else is identical. */
+    private copyComment;
+    /**
+     * Creates the target-space copy of a source POI, with EVERY column of the POI model.
+     *
+     * Single entry point for all phases: the element phases (ticket, equipment, 3D object,
+     * feature, measurement) used to build their POI inline with only 5 fields — coordinate,
+     * type, elementID, metadata, sweep — which is precisely how museum POIs lost their
+     * pastille: `tagDescription` (the popup text), `tagIcon` (the custom icon) and
+     * `tagImageID` (the pastille's image) never left the source space.
+     */
+    private createCopiedPoi;
+    /**
+     * Adapts a POI's `metadata` (see MattertagData.getMetadataString(): { icon, normal, sid })
+     * to the target space.
+     *
+     *  - `sid` is the id of the Mattertag inside the SOURCE Matterport model. Carried over,
+     *    the viewer tries to re-create the target's tag with an id belonging to another
+     *    model ("already in use"), so the pastille fails to attach. It is dropped: the
+     *    viewer then allocates a fresh sid on first render.
+     *  - `normal` is the stem direction. It is a direction, so only the rotation applies
+     *    (never the translation); without it, a copied pastille points into the wall
+     *    whenever the two models are not aligned on the same axis.
+     *  - `icon` and anything else is kept as-is.
+     */
+    private getAdjustedPoiMetadata;
+    /**
+     * Resolves a POI's `tagImageID` — which the schema documents as a "connection to
+     * comment.id", i.e. the id of the Comment holding the image shown in the pastille.
+     *
+     * It is NOT an S3 key, so the previous "does it contain a slash?" heuristic never
+     * matched and the value travelled unchanged, leaving every copied pastille pointing at
+     * a Comment of the source space. It is now translated through the comment id map built
+     * while duplicating the media, and dropped when it cannot be resolved (the pastille
+     * then falls back to the feature's cover image instead of a broken reference).
+     */
+    private resolveTagImageID;
+    /**
+     * Heuristic duplicate-detection: compares several identifying fields together rather than
+     * a single label, to reduce false positives when items share one of them.
+     *
+     * The fields are supplied by the caller because the models do not agree on them. The
+     * previous version hard-coded `title`/`description`, which do not exist on Equipment at
+     * all: both sides read `undefined`, every equipment therefore "matched" every other one,
+     * and a target space holding a single equipment silently caused the whole equipment phase
+     * to copy nothing.
      */
     private matchesExisting;
+    /** Serialises the identifying fields unambiguously, so that ["a", "b"] and ["ab", ""]
+     *  can never produce the same key. */
+    private identityKey;
     /**
      * 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 —
@@ -90,6 +258,8 @@ export declare class MatterportTagCopyService {
     /**
      * Builds a new S3 key for a copied attachment and sanitizes the filename
      * to prevent AWS Amplify SignatureDoesNotMatch errors.
+     * `folderOverride` re-homes the copy into another prefix — used for tag icons, which
+     * are stored per space (`icons-tags/<spaceId>/`) and must follow the target space.
      */
     private buildCopiedAttachmentKey;
     /**
@@ -100,20 +270,31 @@ export declare class MatterportTagCopyService {
      * - Any other kind of failure (permissions, network, etc.) still throws a generic Error.
      */
     private copyS3KeyIfPresent;
+    /** True when the failure means the source object simply is not on S3 (orphaned reference). */
+    private isMissingS3File;
+    /** True when AppSync refused the operation for lack of permission, as opposed to failing it.
+     *  Nothing can be retried or worked around client-side: the account simply is not allowed
+     *  to write that model, which is a backend authorisation rule (@auth) to change. */
+    private isUnauthorized;
+    /** True for the SigV4 mismatch Storage.copy() raises on keys with special characters. */
+    private isSignatureMismatch;
     /**
      * 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.
+     * { src, opacity }, per form-feature.component.ts).
+     *
+     * Two behaviours matter here:
+     *  - the copy is re-homed under the TARGET space's icon folder
+     *    (`icons-tags/<targetSpaceId>/`, the layout form-feature.component.ts uploads to).
+     *    Keeping the source folder produced a target space whose icons all lived under
+     *    another space's prefix, so cleaning up the source space broke the copy's icons.
+     *  - a missing icon file is NOT fatal. It used to bubble up as a MissingS3FileError and
+     *    abort the whole POI — losing the pastille, its text and its media because of a
+     *    decorative file. The POI is now created with the icon reference dropped, which
+     *    renders the module's default icon, and a log line reports 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;
+    /** Icon folder of the space being copied into, matching what the feature form uploads to. */
+    private buildTargetIconFolder;
     /**
      * Extracts and normalizes the raw S3 key from a stored value (which may be a full URL
      * or already a raw key).

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,6 +195,11 @@ 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. */
@@ -325,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/comment.service.d.ts

@@ -15,6 +15,22 @@ export declare class CommentService {
     getComment(commentID: string): Promise<Comment>;
     deleteComment(commentID: string): Promise<Comment>;
     createComment(comment: Comment): Promise<Comment>;
+    /**
+     * Returns EVERY comment attached to a feature, following `nextToken` until the
+     * connection is exhausted.
+     *
+     * The `comments` connection nested inside FeaturesBySpace/GetFeature is capped by
+     * the AppSync resolver (`$util.defaultIfNull($context.args.limit, 100)`) and exposes
+     * a `nextToken` that nobody follows, so a media-rich POI silently loses every
+     * attachment past the first page. Anything that must see the complete media set of
+     * a feature (duplication, export, audit) has to use this method rather than
+     * `feature.comments.items`.
+     */
+    getAllCommentsForFeature(featureID: string): Promise<Comment[]>;
+    /** Same as getAllCommentsForFeature(), for the attachments of a ticket. */
+    getAllCommentsForTicket(ticketID: string): Promise<Comment[]>;
+    /** Drains a paginated comment query until its nextToken is exhausted. */
+    private getAllCommentsPaginated;
     updateComment(input: any): Promise<Comment>;
     uploadFileForComment(file: File, id?: string): Promise<string>;
     /** Create a new comment with an existing Annexe */

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

@@ -70,7 +70,10 @@ export declare class EquipmentService extends BaseObjectService {
      * 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>;
+    createNoteWithExistingAttachment(equipmentID: string, attachmentKey: string, type: TypeNote, ownerMissionID: string | null, dates?: {
+        signDate?: number | null;
+        expirationDate?: number | 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/feature.service.d.ts

@@ -48,6 +48,17 @@ export declare class FeatureService extends BaseObjectService {
     initFeatures(): Promise<void>;
     getFeaturesForSpace(spaceID: string, keepArchived?: boolean): Promise<Feature[]>;
     getFeaturesBySpaceWithoutFiltering(spaceID: string): Promise<Feature[]>;
+    /**
+     * Returns EVERY feature of a space, following `nextToken` until the index is
+     * exhausted, with no user/archive filtering at all.
+     *
+     * `getFeaturesBySpaceWithoutFiltering()` reads a single page (the AppSync default
+     * caps it at 100 items) and calls `isArchived()`, which dereferences the current
+     * user's mission ON THAT SPACE — so it both truncates large spaces and throws for a
+     * space the operator has no mission on. Duplication has to see the raw, complete
+     * list, hence this separate accessor rather than a change of the existing one.
+     */
+    getAllFeaturesBySpaceRaw(spaceID: string): Promise<Feature[]>;
     isBookingPlace(feature: Feature): void;
     setCoverImage(feature: Feature): void;
     updateFeatureLocation(feature: Feature, tagData: MattertagData, spaceID: string): Promise<POI>;

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

@@ -6,6 +6,12 @@ export declare class HashtagService {
     API: any;
     constructor(apiInjected: any);
     getHashtag(hashtagID: string): Promise<Hashtag>;
+    /** Reads a space's keywords without touching the shared cache. */
+    listHashtagsForSpace(spaceID: string): Promise<Hashtag[]>;
+    /** Creates a keyword in a space without adding it to the shared cache. */
+    createHashtagForSpace(name: string, spaceID: string): Promise<Hashtag>;
+    /** Deletes a keyword without touching the shared cache. */
+    deleteHashtagById(hashtagID: string): Promise<Hashtag>;
     createHashtag(hashtag: Hashtag): Promise<Hashtag>;
     getHashtagsForSpace(spaceID?: string): Promise<Hashtag[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<HashtagService, never>;

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

@@ -20,3 +20,17 @@ export declare const uploadJsonToS3: (path: string, json: string, filename: stri
  * to distinguish an orphaned DB reference from a genuine copy failure.
  */
 export declare const copyFileInS3: (sourceKey: string, destKey: string) => Promise<string>;
+/**
+ * Fallback duplication: downloads the object and re-uploads it under the new key.
+ *
+ * Storage.copy() builds the S3 `x-amz-copy-source` header by plain string concatenation
+ * (see @aws-amplify/storage AWSS3Provider.copy: `${bucket}/${srcPrefix}${srcKey}`), with no
+ * URL-encoding of the key. A key holding a space, an accent or a parenthesis therefore
+ * yields a header that does not match the signed canonical request, and S3 answers
+ * "The request signature we calculated does not match the signature you provided".
+ *
+ * Round-tripping the bytes avoids that header entirely and works for any key, at the cost
+ * of transferring the file through the browser — hence its use as a fallback only.
+ * IMPORTANT: like copyFileInS3, this must NOT swallow errors.
+ */
+export declare const copyFileInS3ViaDownload: (sourceKey: string, destKey: string) => Promise<string>;

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

@@ -15,7 +15,22 @@ export interface RigidTransform {
 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). */
+/**
+ * Applies the Y rotation (in degrees) to an orientation angle (a pose's yRotation).
+ * A null/undefined/non-numeric angle is returned untouched: "no orientation stored"
+ * must stay "no orientation stored", not become the raw rotation delta.
+ */
 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;
+/**
+ * Applies ONLY the rotation part of the transform to a direction vector
+ * (a normal, a stem vector, ...).
+ *
+ * A direction has no origin, so the translation must NOT be applied to it —
+ * doing so would turn a unit normal into a point somewhere in the target model.
+ * Used for a POI's `metadata.normal`, which drives the orientation of the tag's
+ * stem: without this rotation, a pastille copied into a space whose model is
+ * rotated relative to the source ends up pointing into the wall it is stuck on.
+ */
+export declare function applyRigidTransformToDirection(v: Vec3, t: RigidTransform): Vec3;

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.12",
+  "version": "1.4.14",
   "dependencies": {
     "tslib": "^2.5.0"
   },