@smarterplan/ngx-smarterplan-core 1.4.13 → 1.4.15

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,10 @@ 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 { MissionService } from './models/mission.service';
+import { OperationService } from './models/operation.service';
+import { DomainService } from './models/domain.service';
 import { BaseUserService } from './user.service';
 import { Vec3 } from './utils/matterport-transform.util';
 import * as i0 from "@angular/core";
@@ -20,11 +24,16 @@ export interface CopyProgress {
     totalOverall: number;
     percent: number;
     errorCount: number;
+    /** Items that already existed in the target space and had missing identity fields
+     *  filled in, rather than being newly created — see healEquipmentIdentity() and its
+     *  ticket/feature equivalents. */
+    healedCount: number;
 }
-/** A single line in the copy log — either a step status (updated in place) or an error (appended once). */
+/** A single line in the copy log — a step status (updated in place), or an error / healed
+ *  item notice (appended once, permanent). */
 export interface CopyLogEntry {
     id: string;
-    type: 'step' | 'error';
+    type: 'step' | 'error' | 'healed';
     text: string;
 }
 export declare class MatterportTagCopyService {
@@ -37,35 +46,314 @@ export declare class MatterportTagCopyService {
     private featureService;
     private measurementService;
     private commentService;
+    private hashtagService;
+    private missionService;
+    private operationService;
+    private domainService;
     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);
+    /** Unique-id sequence shared by every permanent (non-step) log line — errors and healed-item notices alike. */
+    private logSeq;
+    /** 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;
+    /** source Mission id -> its userID. */
+    private sourceMissionUserIds;
+    /** userID -> that user's Mission id in the TARGET space (only set when they have one). */
+    private targetMissionIdsByUserId;
+    /** id -> Domain, for every domain visible from EITHER space's operator mission (its
+     *  organisationID, its orderedOrganisationID, or generic/no-organisation domains) — a
+     *  superset covering whatever a source object's domainID could point at. */
+    private domainsById;
+    /** organisationIDs the TARGET operator's mission can see domains from. A domain whose
+     *  own organisationID is in this set (or has none at all) is already directly
+     *  selectable in the target space's own dropdown, so its id is reused unchanged. */
+    private targetVisibleDomainOrgIds;
+    /** `${type}::${normalised name}` -> that domain's id, among domains visible to the
+     *  TARGET operator — used to find an equivalent when the exact id isn't reusable. */
+    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);
     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
+     * healed-item notice) to a plain-text file and triggers a browser download — wired to a
+     * "download log" button in the copy UI, so an operator can keep or share the full report
+     * of a run rather than only the ~200px scrollable panel showing it.
+     */
+    downloadLog(filename?: string): void;
     /** 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;
+    /** Appends a permanent log line for an item that was repaired rather than newly
+     *  created — see healEquipmentIdentity() and its ticket/feature equivalents. */
+    private appendHealedLog;
     /** 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. */
     private logItemError;
+    /** Logs a translated line for an item that already existed in the target space and had
+     *  its missing identity fields filled in, so the operator can tell it apart from a
+     *  freshly created item in the copy report. */
+    private logHealedItem;
     /** 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;
+    /** Normalised lookup key for a domain: type disambiguates same-named domains used for
+     *  different purposes (equipment vs. ticket vs. feature categories, ...). */
+    private domainKey;
+    /**
+     * READ-ONLY indexing of every domain either operator's Mission can see. Creates
+     * nothing — unlike hashtags, a domain is a business taxonomy entry an operator manages
+     * deliberately; this tool only ever reuses an EXISTING equivalent, it never invents one.
+     *
+     * Visibility is keyed to `currentMission(spaceId).organisationID` /
+     * `.orderedOrganisationID` for EACH space — exactly what
+     * `DomainService.getDomainsForOrgForType()` uses to populate the category dropdown on
+     * the equipment/ticket/feature edit forms (see form-equipment.component.ts,
+     * batch-edit-equipment.component.ts, form-feature.component.ts). Comparing the spaces'
+     * OWN `organisationID` instead — the previous approach — missed every domain reachable
+     * only through the operator's `orderedOrganisationID` (set when a mission is created "on
+     * behalf of" another organisation — see form-mission.component.ts), which is exactly how
+     * a domain ends up visible on two spaces that belong to different organisations.
+     */
+    private loadDomainIndex;
+    /**
+     * Resolves a source domainID (equipment/ticket/feature/POI category) for use in the
+     * target space.
+     *
+     *  - generic domain (no organisationID of its own — a shared taxonomy entry, e.g. a
+     *    standard category created by the platform): reused unchanged, valid everywhere.
+     *  - the domain's own organisationID is already one the TARGET operator's mission can
+     *    see (its organisationID, or its orderedOrganisationID): reused unchanged too — the
+     *    id is directly selectable in the target space's own dropdown as-is.
+     *  - otherwise: matched by (type, name) against the domains visible to the TARGET
+     *    operator (loadDomainIndex()); dropped when no equivalent exists there.
+     */
+    private resolveDomainID;
+    /** 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;
+    /**
+     * READ-ONLY indexing of both spaces' missions.
+     *
+     * A Mission is scoped to one space (it pairs a userID with a spaceID), so the id a
+     * source comment's `ownerID` points at never designates anyone in the target space.
+     * This builds the two lookup tables resolveCommentOwnerID() needs to translate it:
+     * which user a source Mission id belongs to, and which Mission (if any) that same
+     * user already holds in the target space.
+     */
+    private loadMissionIndex;
+    /**
+     * Translates a source comment's `ownerID` (a per-space Mission id) into the Mission of
+     * the SAME user in the target space, so the copy keeps crediting its real author.
+     *
+     * Substituting the current operator's mission — the way `ownerMissionID` legitimately
+     * does for tickets/equipment/features, which really do change owner on a copy — would
+     * misattribute every comment to whoever ran the copy instead of who actually wrote it.
+     *
+     * When the original author has no mission in the target space (never granted access
+     * there), the comment is left with no owner rather than a wrong one: an absent author
+     * is honest, a misattributed one is not.
+     */
+    private resolveCommentOwnerID;
+    /** 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 matchesExisting;
+    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. Returns the
+     * matched target item (or undefined) rather than a boolean, so the caller can act on the
+     * existing record — heal its missing fields — instead of only skipping it.
+     *
+     * 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 findExisting;
+    /**
+     * Builds a patch of whichever fields in `fields` the existing target record is missing
+     * (`null`/`undefined`/empty array) but the source has, plus `domainID` when requested —
+     * domains are organisation-scoped everywhere in this file, so that one is only ever
+     * healed across the SAME organisation, exactly like at creation time.
+     *
+     * Never overwrites a field the target already carries a value for: a value entered by
+     * hand in the target space since an earlier, incomplete copy must not be clobbered by
+     * an older or different source value.
+     *
+     * Returns both the patch to send and the list of healed field names, so the caller can
+     * both perform the update and describe it in the copy log.
+     */
+    private buildHealPatch;
+    /**
+     * Fills in whichever identity field a PRE-EXISTING target equipment is missing but the
+     * source has — see the call site in the EQUIPMENTS phase for why re-running the copy
+     * has to be able to repair a previously-copied equipment, not just skip it again.
+     *
+     * A failed update is left to bubble up to the caller's existing per-item try/catch, the
+     * same as a failed creation — it gets the same visible error line, rather than a silent
+     * console warning.
+     *
+     * Returns the list of fields that were actually healed (empty if nothing was missing).
+     */
+    private healEquipmentIdentity;
+    /**
+     * Same idea as healEquipmentIdentity(), for a pre-existing ticket. `title`/`description`
+     * are the pair findExisting() matched on to find this ticket in the first place, so they
+     * are never part of the heal — by construction, they already agree with the source.
+     */
+    private healTicketIdentity;
+    /** Same idea, for a pre-existing feature. Keywords, media and POIs are not healed here
+     *  for the same reason notes/POIs are not healed on equipment — see healEquipmentIdentity(). */
+    private healFeatureIdentity;
+    /** 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 +378,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 +390,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/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/domain.service.d.ts

@@ -4,6 +4,14 @@ export declare class DomainService {
     API: any;
     constructor(apiInjected: any);
     getGenericDomainsAndForOrganisation(organisationID: string): Promise<any | void>;
+    /**
+     * Same as getGenericDomainsAndForOrganisation(), but drains every page instead of only
+     * the first. `ListDomains` has no per-organisation index — every call already scans the
+     * WHOLE table across every organisation before filtering client-side — so a catalogue
+     * past the first page was silently invisible to callers that need the complete list
+     * (e.g. matching an organisation-specific domain by name across a space-to-space copy).
+     */
+    getAllGenericDomainsAndForOrganisation(organisationID: string): Promise<Domain[]>;
     getGenericDomainsAndForOrgAndOrderedOrg(orgID: string, orderedOrgID?: string): Promise<Domain[]>;
     getDomainsForOrgExcludingTypes(types: DomainType[], organisationID: string): Promise<Domain[]>;
     getDomain(id: string): Promise<Domain>;

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,11 @@ 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.
+     */
+    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/models/mission.service.d.ts

@@ -21,6 +21,11 @@ export declare class MissionService {
     getActivatedMissions(missions: Mission[]): Mission[];
     getMissionsForZone(zoneID: string): Promise<Mission[]>;
     getMissionsForSpace(spaceID: string): Promise<Mission[]>;
+    /**
+     * Same as getMissionsForSpace(), but follows `nextToken` until the connection is
+     * exhausted instead of returning only the first page.
+     */
+    getAllMissionsForSpace(spaceID: string): Promise<Mission[]>;
     activateMission(mis: Mission): void;
     getMissionsByTemplate(templateID: string): Promise<Mission[]>;
     getMission(missionID: string): Promise<Mission>;

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/package.json

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