@smarterplan/ngx-smarterplan-core 1.4.5 → 1.4.7

package/esm2022/lib/services/matterport-tag.service.mjs

@@ -0,0 +1,458 @@
+import { isDevMode, Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { MattertagData } from '../mattertagData';
+import { TagAction, CameraMode } from '../types.service';
+import { wait } from '../helpers.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./matterport-navigation.service";
+export class MatterportTagService {
+    navigationService;
+    dictionnaryTags = new Map();
+    tagAddQueue = Promise.resolve();
+    mattertagToFollow = null;
+    onGoToTag = new Subject();
+    mattertagIDs = [];
+    tagsAttachments = {};
+    tagMessengerOn = false;
+    tagService = null;
+    tagsCurrentOpacity = new Map();
+    tagsCurrentEnabled = new Map();
+    constructor(navigationService) {
+        this.navigationService = navigationService;
+    }
+    setTagService(service) {
+        this.tagService = service;
+    }
+    /** Opens a specific tag in the Matterport viewer by its ID. */
+    async goToTag(sdk, sid) {
+        if (!sdk)
+            return;
+        try {
+            this.onGoToTag.next(sid);
+            await sdk.Tag.open(sid);
+        }
+        catch (e) {
+            if (isDevMode())
+                console.warn('Cannot open tag', sid, e);
+        }
+    }
+    /** Opens the most recently created tag in the viewer. */
+    async goToLastTag(sdk) {
+        if (!sdk || this.mattertagIDs.length === 0)
+            return;
+        const lastSid = this.mattertagIDs[this.mattertagIDs.length - 1];
+        return this.goToTag(sdk, lastSid);
+    }
+    /**
+     * Adds a Mattertag to the viewer, serializing calls to prevent SDK race conditions.
+     * Reuses existing IDs if the tag is already present in the session.
+     */
+    async addMattertagToViewer(sdk, mattertagData) {
+        if (!sdk)
+            return null;
+        this.tagAddQueue = this.tagAddQueue.then(async () => {
+            const data = mattertagData.getData();
+            const existingId = data?.id || null;
+            try {
+                const sidList = await sdk.Tag.add(data);
+                if (sidList && sidList.length > 0) {
+                    const mattertagID = sidList[0];
+                    this.mattertagIDs.push(mattertagID);
+                    this.dictionnaryTags.set(mattertagID, mattertagData);
+                    return mattertagID;
+                }
+            }
+            catch (error) {
+                if (error?.message?.includes('already in use') && existingId) {
+                    if (!this.dictionnaryTags.has(existingId)) {
+                        this.mattertagIDs.push(existingId);
+                        this.dictionnaryTags.set(existingId, mattertagData);
+                    }
+                    return existingId;
+                }
+                if (isDevMode())
+                    console.warn('Failed to add tag to viewer', error);
+            }
+            return null;
+        });
+        return this.tagAddQueue;
+    }
+    /**
+     * Internal method to add and configure a Mattertag with icon, opacity, and HTML content.
+     * Handles existing tags gracefully and queues operations to avoid SDK conflicts.
+     */
+    async _doAddMattertag(sdk, mattertagData, setTagIconAndOpacity, injectHtmlInTag) {
+        const descriptor = mattertagData.getMattertagDescriptor();
+        //console.log('descriptor', descriptor);
+        const sid = descriptor[0]['id'];
+        if (sid && this.dictionnaryTags.has(sid)) {
+            await setTagIconAndOpacity(sid, mattertagData);
+            await injectHtmlInTag(mattertagData.getType(), mattertagData.getObject(), sid);
+            return sid;
+        }
+        this.tagAddQueue = this.tagAddQueue.then(async () => {
+            try {
+                const [createdSid] = await sdk.Tag.add(...descriptor);
+                this.mattertagIDs.push(createdSid);
+                this.dictionnaryTags.set(createdSid, mattertagData);
+                await wait(100);
+                await setTagIconAndOpacity(createdSid, mattertagData);
+                injectHtmlInTag(mattertagData.getType(), mattertagData.getObject(), createdSid).catch(err => {
+                    if (isDevMode())
+                        console.warn('HTML injection failed for', createdSid, err);
+                });
+                return createdSid;
+            }
+            catch (e) {
+                if (e?.message?.includes('already in use') && sid) {
+                    if (!this.dictionnaryTags.has(sid)) {
+                        this.mattertagIDs.push(sid);
+                        this.dictionnaryTags.set(sid, mattertagData);
+                    }
+                    await setTagIconAndOpacity(sid, mattertagData);
+                    await injectHtmlInTag(mattertagData.getType(), mattertagData.getObject(), sid);
+                    return sid;
+                }
+                throw e;
+            }
+        });
+        return this.tagAddQueue;
+    }
+    getDistance(p1, p2) {
+        return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2) + Math.pow(p2.z - p1.z, 2));
+    }
+    /**
+     * Checks if a tag is within the bounding box of any active room (adding a slight margin to account for wall-mounted tags).
+     * If there are no active rooms (e.g., hallway), falls back to returning true.
+     */
+    isTagInRooms(mattertagData, rooms) {
+        if (!rooms || rooms.length === 0)
+            return false;
+        const tagPos = mattertagData.getPosition();
+        const margin = 1.5;
+        return rooms.some((room) => {
+            if (!room.bounds)
+                return false;
+            const { min, max } = room.bounds;
+            return (tagPos.x >= min.x - margin && tagPos.x <= max.x + margin &&
+                tagPos.y >= min.y - margin && tagPos.y <= max.y + margin &&
+                tagPos.z >= min.z - margin && tagPos.z <= max.z + margin);
+        });
+    }
+    /**
+     * 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.
+     */
+    /*computeSingleTagContextOpacity(
+      mattertagData: MattertagData,
+      poseCamera: any,
+      sweepCollection: any,
+      currentFloorSequence: number | null,
+      currentRooms: any[]
+    ): number {
+      const mode = this.navigationService.currentCameraMode;
+  
+      // 1. Check Floor
+      const tagFloorId = this.getFloorIdForTag(mattertagData, sweepCollection);
+      const currentFloorId = currentFloorSequence?.toString();
+      if (tagFloorId && currentFloorId && tagFloorId !== currentFloorId) {
+        return 0;
+      }
+  
+      // 2. Si Dollhouse -> Pleine opacité
+      //if (mode !== CameraMode.INSIDE) return 1;
+  
+      // 3. Si Inside -> Check pièce + Distance progressive
+      //if (!this.isTagInRooms(mattertagData, currentRooms)) return 0;
+  
+      return 1;
+    }*/
+    /** Returns the ID of the most recently added tag. */
+    getLastTag() {
+        if (this.mattertagIDs.length === 0)
+            return null;
+        return this.mattertagIDs[this.mattertagIDs.length - 1];
+    }
+    /**
+     * Updates the visibility (opacity) of all tags based on the current camera mode,
+     * floor and room context. Must be called after each sweep, floor or mode change.
+     *
+     * Rules:
+     *  - DOLLHOUSE / FLOORPLAN → all tags hidden (opacity 0).
+     *  - INSIDE → only tags whose sweep belongs to the current floor are shown;
+     *    proximity-based opacity is applied via computeTagOpacity().
+     *    Tags on other floors are hidden (opacity 0).
+     *  - TRANSITIONING → no change (skip update to avoid flickering).
+     *
+     * @param sdk          Matterport SDK instance.
+     * @param poseCamera   Current camera pose.
+     * @param sweepCollection  Full collection of sweeps.
+     * @param currentCameraMode  Current camera mode.
+     * @param mattertagToFollow  ID of the cursor tag (never touched).
+     */
+    async updateTagsVisibilityForContext(sdk, sweepCollection, currentCameraMode, mattertagToFollow, currentFloorSequence = null, currentRooms = []) {
+        if (!sdk || this.dictionnaryTags.size === 0)
+            return;
+        const isInteriorMode = currentCameraMode === CameraMode.INSIDE;
+        const currentFloorId = currentFloorSequence !== null ? currentFloorSequence.toString() : null;
+        const promises = [];
+        for (const [tagId, mattertagData] of this.dictionnaryTags) {
+            if (tagId === mattertagToFollow)
+                continue;
+            const tagFloorId = this.getFloorIdForTag(mattertagData, sweepCollection);
+            const isOnCurrentFloor = !tagFloorId || !currentFloorId || tagFloorId === currentFloorId;
+            let targetOpacity = 0;
+            let shouldBeEnabled = false;
+            // Calculation of opacity and enable status
+            if (isOnCurrentFloor) {
+                if (!isInteriorMode) {
+                    targetOpacity = 1;
+                    shouldBeEnabled = true;
+                }
+                else {
+                    targetOpacity = 0.9;
+                    shouldBeEnabled = true;
+                }
+            }
+            // Apply changes
+            // Tooltip and click management
+            const lastEnabled = this.tagsCurrentEnabled.get(tagId);
+            if (lastEnabled !== shouldBeEnabled) {
+                this.tagsCurrentEnabled.set(tagId, shouldBeEnabled);
+                promises.push(sdk.Tag.allowAction(tagId, {
+                    opening: shouldBeEnabled,
+                    navigating: shouldBeEnabled,
+                    docking: false
+                }).catch(() => { }));
+            }
+            // Opacity management
+            const lastOpacity = this.tagsCurrentOpacity.get(tagId) ?? -1;
+            if (Math.abs(lastOpacity - targetOpacity) > 0.05) {
+                this.tagsCurrentOpacity.set(tagId, targetOpacity);
+                promises.push(sdk.Tag.editOpacity(tagId, targetOpacity).catch(() => { }));
+            }
+        }
+        await Promise.all(promises);
+    }
+    /** Removes a specific tag from the viewer and local dictionaries. */
+    async deleteMattertagFromId(sdk, mattertagID) {
+        try {
+            if (sdk)
+                await sdk.Tag.remove(mattertagID);
+            this.dictionnaryTags.delete(mattertagID);
+            const index = this.mattertagIDs.indexOf(mattertagID);
+            if (index > -1)
+                this.mattertagIDs.splice(index, 1);
+        }
+        catch (e) {
+            if (isDevMode())
+                console.warn('Cannot delete tag', mattertagID, e);
+        }
+    }
+    /** Removes the last added tag from the viewer. */
+    async deleteLastMattertag(sdk) {
+        const lastSid = this.getLastTag();
+        if (lastSid)
+            await this.deleteMattertagFromId(sdk, lastSid);
+    }
+    /** Clears all tags from the viewer and resets local state. */
+    async action_delete_all_mattertags(sdk) {
+        if (sdk) {
+            const sidsToRemove = [...this.mattertagIDs];
+            for (const sid of sidsToRemove) {
+                try {
+                    await sdk.Tag.remove(sid);
+                }
+                catch (e) { }
+            }
+        }
+        this.clear();
+    }
+    /**
+     * Creates and configures a Mattertag from a POI, handling coordinates, normals, and sweep ID.
+     * Skips creation if a tag for the object already exists.
+     */
+    async createMattertagFromPOI(sdk, tagType, object, poi, poseCamera, getTagFromElementId, setTagIconAndOpacity, injectHtmlInTag) {
+        const { tag } = getTagFromElementId(object.id);
+        if (tag)
+            return;
+        const mattertagData = new MattertagData(tagType);
+        mattertagData.setObject(object, tagType);
+        if (poi.coordinate) {
+            try {
+                mattertagData.setPosition(JSON.parse(poi.coordinate));
+            }
+            catch (e) {
+                if (isDevMode())
+                    console.warn('Error parsing POI coordinates', poi.coordinate);
+            }
+        }
+        if (poi.metadata) {
+            try {
+                const tagMetadata = JSON.parse(poi.metadata);
+                mattertagData.setNormal(tagMetadata.normal || { x: 0, y: -0.15, z: 0 });
+            }
+            catch (e) {
+                mattertagData.setNormal({ x: 0, y: -0.15, z: 0 });
+            }
+        }
+        if (poi.matterportSweepID) {
+            mattertagData.setSweepID(poi.matterportSweepID);
+        }
+        mattertagData.setPoi(poi);
+        const createdTagID = await this.addMattertagToViewer(sdk, mattertagData);
+        if (createdTagID && sdk) {
+            await wait(100);
+            await setTagIconAndOpacity(createdTagID, mattertagData);
+            injectHtmlInTag(tagType, object, createdTagID).catch(err => {
+                if (isDevMode())
+                    console.warn('HTML injection failed for', createdTagID, err);
+            });
+        }
+        return createdTagID;
+    }
+    /** Updates the icon, opacity, and HTML content of an existing tag. */
+    async updateMatterTagContentForTagID(sdk, mattertagID, object, poiType, setTagIconAndOpacity, injectHtmlInTag) {
+        const mattertagData = this.dictionnaryTags.get(mattertagID);
+        if (!mattertagData)
+            return;
+        if (object) {
+            mattertagData.setObject(object, poiType);
+        }
+        await setTagIconAndOpacity(mattertagID, mattertagData);
+        await injectHtmlInTag(poiType, object, mattertagID);
+    }
+    /** Registers a custom texture and applies it to a tag, optionally adjusting opacity. */
+    async addNewIconAndSetForTag(sdk, mattertagID, iconPath, applyOpacity, opacity) {
+        if (!sdk)
+            return;
+        try {
+            const iconName = `custom-icon-${mattertagID}`;
+            await sdk.Asset.registerTexture(iconName, iconPath);
+            await sdk.Tag.editIcon(mattertagID, iconName);
+            if (applyOpacity) {
+                await sdk.Tag.editOpacity(mattertagID, opacity);
+            }
+        }
+        catch (error) {
+            if (isDevMode())
+                console.warn('Error setting custom icon or opacity', error);
+        }
+    }
+    /** Finds the tag ID and sweep ID associated with a specific element ID. */
+    getTagFromElementId(elementID, sweeps) {
+        let tagID = null;
+        let sweepID = null;
+        for (let [mattertagID, mattertagData] of this.dictionnaryTags) {
+            if (mattertagData.elementID === elementID) {
+                tagID = mattertagID;
+                const sweep = mattertagData.getSweepID();
+                if (sweep && sweeps && sweeps.includes(sweep)) {
+                    sweepID = sweep;
+                }
+            }
+        }
+        return { tag: tagID, sweep: sweepID };
+    }
+    /** Retrieves the floor identifier associated with a tag based on its sweep data.
+     *  Handles both the object form ({ floorInfo: { id, sequence }, floor: { id } })
+     *  and the primitive form (floor: number) used by Matterport SDK v3.
+     */
+    getFloorIdForTag(mattertagData, sweepCollection) {
+        const sweepId = mattertagData.getSweepID();
+        if (!sweepId || !sweepCollection)
+            return null;
+        const sweepData = sweepCollection[sweepId];
+        if (!sweepData)
+            return null;
+        // SDK v3: sweep.floor is a primitive number (the sequence index)
+        if (typeof sweepData.floor === 'number') {
+            return sweepData.floor.toString();
+        }
+        // Older / extended formats
+        return sweepData?.floorInfo?.id
+            ?? sweepData?.floorInfo?.sequence?.toString()
+            ?? sweepData?.floorId
+            ?? sweepData?.floor?.id
+            ?? sweepData?.floor?.sequence?.toString()
+            ?? null;
+    }
+    /**
+     * Injects custom HTML or fallback billboard media into a Mattertag sandbox.
+     * Attaches event listeners for interactive elements within the tag.
+     */
+    async injectHtmlInTag(sdk, tagType, object, tagID) {
+        if (!this.tagService) {
+            console.error('[MatterportTagService] tagService is not initialized.');
+            return;
+        }
+        try {
+            let html = await this.tagService.getHtmlToInject(tagType, object);
+            if (html && html.trim().length > 0 && sdk) {
+                const scriptTag = this.tagService.getScriptForTag(object, tagType);
+                html += `${scriptTag}`;
+                const [sandboxId, messenger] = await sdk.Tag.registerSandbox(html);
+                const attachmentID = this.tagsAttachments[tagID];
+                if (attachmentID) {
+                    try {
+                        await sdk.Tag.detach(tagID, attachmentID);
+                    }
+                    catch (e) { }
+                }
+                this.tagsAttachments[tagID] = sandboxId;
+                await sdk.Tag.attach(tagID, sandboxId);
+                // Attach the "View informations" handler in tooltip
+                messenger.on(TagAction.DETAIL_CLICK, this.tagService.onActionDetailClick.bind(this.tagService));
+                messenger.on(TagAction.TICKET_CLICK, this.tagService.onActionDetailClick.bind(this.tagService));
+                messenger.on(TagAction.AUDIO_CLICK, (audioCommentID) => this.tagService.onActionAudioClick(audioCommentID));
+                messenger.on(TagAction.VIDEO_CLICK, (videoUrl) => this.tagService.onActionVideoClick(videoUrl));
+                messenger.on(TagAction.IMAGE_CLICK, (imageCommentID) => this.tagService.onActionImageClick(imageCommentID));
+                messenger.on(TagAction.DOC_CLICK, (docUrl) => this.tagService.onActionDocClick(docUrl));
+                messenger.on(TagAction.YOUTUBE_CLICK, (youtubeUrl) => this.tagService.onActionYoutubeClick(youtubeUrl));
+            }
+            else if (sdk) {
+                const { comment, tagDescription } = this.tagService.getBillboardMediaToEmbed(object);
+                if (comment) {
+                    const attachmentID = await sdk.Tag.registerAttachment({
+                        type: 'media',
+                        data: {
+                            url: comment.externalLink,
+                            label: object.title || 'Media',
+                        },
+                    });
+                    await sdk.Tag.attach(tagID, attachmentID);
+                    const billboardAttachmentID = await sdk.Tag.registerAttachment({
+                        type: 'billboard',
+                        data: {
+                            title: object.title,
+                            description: tagDescription,
+                        },
+                    });
+                    await sdk.Tag.attach(tagID, billboardAttachmentID);
+                    this.tagsAttachments[tagID] = billboardAttachmentID;
+                }
+            }
+        }
+        catch (error) {
+            console.error('[MatterportTagService] Error in injectHtmlInTag:', error);
+        }
+    }
+    /** Clears all local tag data and resets the addition queue. */
+    clear() {
+        this.dictionnaryTags.clear();
+        this.tagAddQueue = Promise.resolve();
+        this.mattertagToFollow = null;
+        this.mattertagIDs = [];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagService, deps: [{ token: i1.MatterportNavigationService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.MatterportNavigationService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matterport-tag.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/matterport-tag.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { isDevMode, Injectable } from '@angular/core';\r\nimport { Subject } from 'rxjs';\r\nimport { MattertagData } from '../mattertagData';\r\nimport { PoiType, DbObjectType, POI, ViewerInteractions, TagAction, CameraMode } from '../types.service';\r\nimport { MatterportNavigationService } from './matterport-navigation.service';\r\nimport { wait } from '../helpers.service';\r\nimport { BaseTagService } from './tag.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class MatterportTagService {\r\n  public dictionnaryTags: Map<string, MattertagData> = new Map();\r\n  public tagAddQueue: Promise<any> = Promise.resolve();\r\n  public mattertagToFollow: string | null = null;\r\n  public onGoToTag = new Subject<string>();\r\n  public mattertagIDs: Array<string> = [];\r\n  public tagsAttachments: Object = {};\r\n  public tagMessengerOn: boolean = false;\r\n  public tagService: BaseTagService | null = null;\r\n  private tagsCurrentOpacity: Map<string, number> = new Map();\r\n  private tagsCurrentEnabled: Map<string, boolean> = new Map();\r\n\r\n  constructor(\r\n    private navigationService: MatterportNavigationService\r\n  ) { }\r\n\r\n  setTagService(service: BaseTagService): void {\r\n    this.tagService = service;\r\n  }\r\n\r\n  /** Opens a specific tag in the Matterport viewer by its ID. */\r\n  async goToTag(sdk: any, sid: string): Promise<any> {\r\n    if (!sdk) return;\r\n    try {\r\n      this.onGoToTag.next(sid);\r\n      await sdk.Tag.open(sid);\r\n    } catch (e) {\r\n      if (isDevMode()) console.warn('Cannot open tag', sid, e);\r\n    }\r\n  }\r\n\r\n  /** Opens the most recently created tag in the viewer. */\r\n  async goToLastTag(sdk: any): Promise<any> {\r\n    if (!sdk || this.mattertagIDs.length === 0) return;\r\n    const lastSid = this.mattertagIDs[this.mattertagIDs.length - 1];\r\n    return this.goToTag(sdk, lastSid);\r\n  }\r\n\r\n  /**\r\n   * Adds a Mattertag to the viewer, serializing calls to prevent SDK race conditions.\r\n   * Reuses existing IDs if the tag is already present in the session.\r\n   */\r\n  async addMattertagToViewer(sdk: any, mattertagData: MattertagData): Promise<string | null> {\r\n    if (!sdk) return null;\r\n\r\n    this.tagAddQueue = this.tagAddQueue.then(async () => {\r\n      const data = mattertagData.getData() as any;\r\n      const existingId = data?.id || null;\r\n\r\n      try {\r\n        const sidList = await sdk.Tag.add(data);\r\n        if (sidList && sidList.length > 0) {\r\n          const mattertagID = sidList[0];\r\n          this.mattertagIDs.push(mattertagID);\r\n          this.dictionnaryTags.set(mattertagID, mattertagData);\r\n          return mattertagID;\r\n        }\r\n      } catch (error: any) {\r\n        if (error?.message?.includes('already in use') && existingId) {\r\n          if (!this.dictionnaryTags.has(existingId)) {\r\n            this.mattertagIDs.push(existingId);\r\n            this.dictionnaryTags.set(existingId, mattertagData);\r\n          }\r\n          return existingId;\r\n        }\r\n        if (isDevMode()) console.warn('Failed to add tag to viewer', error);\r\n      }\r\n      return null;\r\n    });\r\n\r\n    return this.tagAddQueue;\r\n  }\r\n\r\n  /**\r\n   * Internal method to add and configure a Mattertag with icon, opacity, and HTML content.\r\n   * Handles existing tags gracefully and queues operations to avoid SDK conflicts.\r\n   */\r\n  async _doAddMattertag(\r\n    sdk: any,\r\n    mattertagData: MattertagData,\r\n    setTagIconAndOpacity: (sid: string, mt: MattertagData) => Promise<void>,\r\n    injectHtmlInTag: (type: PoiType, obj: DbObjectType, sid: string) => Promise<void>\r\n  ): Promise<string> {\r\n    const descriptor = mattertagData.getMattertagDescriptor();\r\n    //console.log('descriptor', descriptor);\r\n    const sid = descriptor[0]['id'];\r\n\r\n    if (sid && this.dictionnaryTags.has(sid)) {\r\n      await setTagIconAndOpacity(sid, mattertagData);\r\n      await injectHtmlInTag(mattertagData.getType(), mattertagData.getObject(), sid);\r\n      return sid;\r\n    }\r\n\r\n    this.tagAddQueue = this.tagAddQueue.then(async () => {\r\n      try {\r\n        const [createdSid] = await sdk.Tag.add(...descriptor);\r\n        this.mattertagIDs.push(createdSid);\r\n        this.dictionnaryTags.set(createdSid, mattertagData);\r\n\r\n        await wait(100);\r\n        await setTagIconAndOpacity(createdSid, mattertagData);\r\n\r\n        injectHtmlInTag(mattertagData.getType(), mattertagData.getObject(), createdSid).catch(err => {\r\n          if (isDevMode()) console.warn('HTML injection failed for', createdSid, err);\r\n        });\r\n\r\n        return createdSid;\r\n      } catch (e: any) {\r\n        if (e?.message?.includes('already in use') && sid) {\r\n          if (!this.dictionnaryTags.has(sid)) {\r\n            this.mattertagIDs.push(sid);\r\n            this.dictionnaryTags.set(sid, mattertagData);\r\n          }\r\n          await setTagIconAndOpacity(sid, mattertagData);\r\n          await injectHtmlInTag(mattertagData.getType(), mattertagData.getObject(), sid);\r\n          return sid;\r\n        }\r\n        throw e;\r\n      }\r\n    });\r\n\r\n    return this.tagAddQueue;\r\n  }\r\n\r\n  getDistance(p1: any, p2: any): number {\r\n    return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2) + Math.pow(p2.z - p1.z, 2));\r\n  }\r\n\r\n  /**\r\n   * Checks if a tag is within the bounding box of any active room (adding a slight margin to account for wall-mounted tags).\r\n   * If there are no active rooms (e.g., hallway), falls back to returning true.\r\n   */\r\n  isTagInRooms(mattertagData: MattertagData, rooms: any[]): boolean {\r\n    if (!rooms || rooms.length === 0) return false;\r\n\r\n    const tagPos = mattertagData.getPosition();\r\n    const margin = 1.5;\r\n\r\n    return rooms.some((room) => {\r\n      if (!room.bounds) return false;\r\n      const { min, max } = room.bounds;\r\n\r\n      return (\r\n        tagPos.x >= min.x - margin && tagPos.x <= max.x + margin &&\r\n        tagPos.y >= min.y - margin && tagPos.y <= max.y + margin &&\r\n        tagPos.z >= min.z - margin && tagPos.z <= max.z + margin\r\n      );\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Computes the final context-aware opacity for a single tag.\r\n   * @param currentFloorSequence  Authoritative current floor sequence from sdk.Floor.current\r\n   *                              (null = single-floor model or unknown).\r\n   * @param currentRooms          Array of active rooms the camera is in.\r\n   */\r\n  /*computeSingleTagContextOpacity(\r\n    mattertagData: MattertagData,\r\n    poseCamera: any,\r\n    sweepCollection: any,\r\n    currentFloorSequence: number | null,\r\n    currentRooms: any[]\r\n  ): number {\r\n    const mode = this.navigationService.currentCameraMode;\r\n\r\n    // 1. Check Floor\r\n    const tagFloorId = this.getFloorIdForTag(mattertagData, sweepCollection);\r\n    const currentFloorId = currentFloorSequence?.toString();\r\n    if (tagFloorId && currentFloorId && tagFloorId !== currentFloorId) {\r\n      return 0;\r\n    }\r\n\r\n    // 2. Si Dollhouse -> Pleine opacité\r\n    //if (mode !== CameraMode.INSIDE) return 1;\r\n\r\n    // 3. Si Inside -> Check pièce + Distance progressive\r\n    //if (!this.isTagInRooms(mattertagData, currentRooms)) return 0;\r\n\r\n    return 1;\r\n  }*/\r\n\r\n  /** Returns the ID of the most recently added tag. */\r\n  getLastTag(): string | null {\r\n    if (this.mattertagIDs.length === 0) return null;\r\n    return this.mattertagIDs[this.mattertagIDs.length - 1];\r\n  }\r\n\r\n  /**\r\n   * Updates the visibility (opacity) of all tags based on the current camera mode,\r\n   * floor and room context. Must be called after each sweep, floor or mode change.\r\n   *\r\n   * Rules:\r\n   *  - DOLLHOUSE / FLOORPLAN → all tags hidden (opacity 0).\r\n   *  - INSIDE → only tags whose sweep belongs to the current floor are shown;\r\n   *    proximity-based opacity is applied via computeTagOpacity().\r\n   *    Tags on other floors are hidden (opacity 0).\r\n   *  - TRANSITIONING → no change (skip update to avoid flickering).\r\n   *\r\n   * @param sdk          Matterport SDK instance.\r\n   * @param poseCamera   Current camera pose.\r\n   * @param sweepCollection  Full collection of sweeps.\r\n   * @param currentCameraMode  Current camera mode.\r\n   * @param mattertagToFollow  ID of the cursor tag (never touched).\r\n   */\r\n  async updateTagsVisibilityForContext(\r\n    sdk: any,\r\n    sweepCollection: any,\r\n    currentCameraMode: CameraMode,\r\n    mattertagToFollow: string | null,\r\n    currentFloorSequence: number | null = null,\r\n    currentRooms: any[] = []\r\n  ): Promise<void> {\r\n    if (!sdk || this.dictionnaryTags.size === 0) return;\r\n\r\n    const isInteriorMode = currentCameraMode === CameraMode.INSIDE;\r\n    const currentFloorId = currentFloorSequence !== null ? currentFloorSequence.toString() : null;\r\n    const promises = [];\r\n\r\n    for (const [tagId, mattertagData] of this.dictionnaryTags) {\r\n      if (tagId === mattertagToFollow) continue;\r\n\r\n      const tagFloorId = this.getFloorIdForTag(mattertagData, sweepCollection);\r\n      const isOnCurrentFloor = !tagFloorId || !currentFloorId || tagFloorId === currentFloorId;\r\n\r\n      let targetOpacity = 0;\r\n      let shouldBeEnabled = false;\r\n\r\n      // Calculation of opacity and enable status\r\n      if (isOnCurrentFloor) {\r\n        if (!isInteriorMode) {\r\n          targetOpacity = 1;\r\n          shouldBeEnabled = true;\r\n        } else {\r\n          targetOpacity = 0.9;\r\n          shouldBeEnabled = true;\r\n        }\r\n      }\r\n      // Apply changes\r\n\r\n      // Tooltip and click management\r\n      const lastEnabled = this.tagsCurrentEnabled.get(tagId);\r\n      if (lastEnabled !== shouldBeEnabled) {\r\n        this.tagsCurrentEnabled.set(tagId, shouldBeEnabled);\r\n        promises.push(sdk.Tag.allowAction(tagId, {\r\n          opening: shouldBeEnabled,\r\n          navigating: shouldBeEnabled,\r\n          docking: false\r\n        }).catch(() => { }));\r\n      }\r\n      // Opacity management\r\n      const lastOpacity = this.tagsCurrentOpacity.get(tagId) ?? -1;\r\n      if (Math.abs(lastOpacity - targetOpacity) > 0.05) {\r\n        this.tagsCurrentOpacity.set(tagId, targetOpacity);\r\n        promises.push(sdk.Tag.editOpacity(tagId, targetOpacity).catch(() => { }));\r\n      }\r\n    }\r\n\r\n    await Promise.all(promises);\r\n  }\r\n\r\n  /** Removes a specific tag from the viewer and local dictionaries. */\r\n  async deleteMattertagFromId(sdk: any, mattertagID: string): Promise<void> {\r\n    try {\r\n      if (sdk) await sdk.Tag.remove(mattertagID);\r\n      this.dictionnaryTags.delete(mattertagID);\r\n      const index = this.mattertagIDs.indexOf(mattertagID);\r\n      if (index > -1) this.mattertagIDs.splice(index, 1);\r\n    } catch (e: any) {\r\n      if (isDevMode()) console.warn('Cannot delete tag', mattertagID, e);\r\n    }\r\n  }\r\n\r\n  /** Removes the last added tag from the viewer. */\r\n  async deleteLastMattertag(sdk: any): Promise<void> {\r\n    const lastSid = this.getLastTag();\r\n    if (lastSid) await this.deleteMattertagFromId(sdk, lastSid);\r\n  }\r\n\r\n  /** Clears all tags from the viewer and resets local state. */\r\n  async action_delete_all_mattertags(sdk: any): Promise<void> {\r\n    if (sdk) {\r\n      const sidsToRemove = [...this.mattertagIDs];\r\n      for (const sid of sidsToRemove) {\r\n        try {\r\n          await sdk.Tag.remove(sid);\r\n        } catch (e) { }\r\n      }\r\n    }\r\n    this.clear();\r\n  }\r\n\r\n  /**\r\n   * Creates and configures a Mattertag from a POI, handling coordinates, normals, and sweep ID.\r\n   * Skips creation if a tag for the object already exists.\r\n   */\r\n  async createMattertagFromPOI(\r\n    sdk: any,\r\n    tagType: PoiType,\r\n    object: DbObjectType,\r\n    poi: POI,\r\n    poseCamera: any,\r\n    getTagFromElementId: (id: string) => { tag: string; sweep: string },\r\n    setTagIconAndOpacity: (sid: string, mt: MattertagData) => Promise<void>,\r\n    injectHtmlInTag: (type: PoiType, obj: DbObjectType, sid: string) => Promise<void>\r\n  ): Promise<any> {\r\n    const { tag } = getTagFromElementId(object.id);\r\n    if (tag) return;\r\n\r\n    const mattertagData: MattertagData = new MattertagData(tagType);\r\n    mattertagData.setObject(object, tagType);\r\n\r\n    if (poi.coordinate) {\r\n      try {\r\n        mattertagData.setPosition(JSON.parse(poi.coordinate));\r\n      } catch (e) {\r\n        if (isDevMode()) console.warn('Error parsing POI coordinates', poi.coordinate);\r\n      }\r\n    }\r\n\r\n    if (poi.metadata) {\r\n      try {\r\n        const tagMetadata = JSON.parse(poi.metadata);\r\n        mattertagData.setNormal(tagMetadata.normal || { x: 0, y: -0.15, z: 0 });\r\n      } catch (e) {\r\n        mattertagData.setNormal({ x: 0, y: -0.15, z: 0 });\r\n      }\r\n    }\r\n\r\n    if (poi.matterportSweepID) {\r\n      mattertagData.setSweepID(poi.matterportSweepID);\r\n    }\r\n    mattertagData.setPoi(poi);\r\n\r\n    const createdTagID = await this.addMattertagToViewer(sdk, mattertagData);\r\n\r\n    if (createdTagID && sdk) {\r\n      await wait(100);\r\n      await setTagIconAndOpacity(createdTagID, mattertagData);\r\n      injectHtmlInTag(tagType, object, createdTagID).catch(err => {\r\n        if (isDevMode()) console.warn('HTML injection failed for', createdTagID, err);\r\n      });\r\n    }\r\n\r\n    return createdTagID;\r\n  }\r\n\r\n  /** Updates the icon, opacity, and HTML content of an existing tag. */\r\n  async updateMatterTagContentForTagID(\r\n    sdk: any,\r\n    mattertagID: string,\r\n    object: DbObjectType,\r\n    poiType: PoiType,\r\n    setTagIconAndOpacity: (sid: string, mt: MattertagData) => Promise<void>,\r\n    injectHtmlInTag: (type: PoiType, obj: DbObjectType, sid: string) => Promise<void>\r\n  ): Promise<any> {\r\n    const mattertagData = this.dictionnaryTags.get(mattertagID);\r\n    if (!mattertagData) return;\r\n\r\n    if (object) {\r\n      mattertagData.setObject(object, poiType);\r\n    }\r\n\r\n    await setTagIconAndOpacity(mattertagID, mattertagData);\r\n    await injectHtmlInTag(poiType, object, mattertagID);\r\n  }\r\n\r\n  /** Registers a custom texture and applies it to a tag, optionally adjusting opacity. */\r\n  async addNewIconAndSetForTag(\r\n    sdk: any,\r\n    mattertagID: string,\r\n    iconPath: string,\r\n    applyOpacity: boolean,\r\n    opacity: number\r\n  ) {\r\n    if (!sdk) return;\r\n    try {\r\n      const iconName = `custom-icon-${mattertagID}`;\r\n      await sdk.Asset.registerTexture(iconName, iconPath);\r\n      await sdk.Tag.editIcon(mattertagID, iconName);\r\n\r\n      if (applyOpacity) {\r\n        await sdk.Tag.editOpacity(mattertagID, opacity);\r\n      }\r\n    } catch (error) {\r\n      if (isDevMode()) console.warn('Error setting custom icon or opacity', error);\r\n    }\r\n  }\r\n\r\n  /** Finds the tag ID and sweep ID associated with a specific element ID. */\r\n  getTagFromElementId(elementID: string, sweeps: string[] | null): { tag: string | null; sweep: string | null } {\r\n    let tagID = null;\r\n    let sweepID = null;\r\n    for (let [mattertagID, mattertagData] of this.dictionnaryTags) {\r\n      if (mattertagData.elementID === elementID) {\r\n        tagID = mattertagID;\r\n        const sweep = mattertagData.getSweepID();\r\n        if (sweep && sweeps && sweeps.includes(sweep)) {\r\n          sweepID = sweep;\r\n        }\r\n      }\r\n    }\r\n    return { tag: tagID, sweep: sweepID };\r\n  }\r\n\r\n  /** Retrieves the floor identifier associated with a tag based on its sweep data.\r\n   *  Handles both the object form ({ floorInfo: { id, sequence }, floor: { id } })\r\n   *  and the primitive form (floor: number) used by Matterport SDK v3.\r\n   */\r\n  getFloorIdForTag(mattertagData: MattertagData, sweepCollection: any): string | null {\r\n    const sweepId = mattertagData.getSweepID();\r\n    if (!sweepId || !sweepCollection) return null;\r\n\r\n    const sweepData = sweepCollection[sweepId];\r\n    if (!sweepData) return null;\r\n\r\n    // SDK v3: sweep.floor is a primitive number (the sequence index)\r\n    if (typeof sweepData.floor === 'number') {\r\n      return sweepData.floor.toString();\r\n    }\r\n\r\n    // Older / extended formats\r\n    return sweepData?.floorInfo?.id\r\n      ?? sweepData?.floorInfo?.sequence?.toString()\r\n      ?? sweepData?.floorId\r\n      ?? sweepData?.floor?.id\r\n      ?? sweepData?.floor?.sequence?.toString()\r\n      ?? null;\r\n  }\r\n\r\n  /**\r\n   * Injects custom HTML or fallback billboard media into a Mattertag sandbox.\r\n   * Attaches event listeners for interactive elements within the tag.\r\n   */\r\n  async injectHtmlInTag(sdk: any, tagType: PoiType, object: DbObjectType, tagID: string) {\r\n    if (!this.tagService) {\r\n      console.error('[MatterportTagService] tagService is not initialized.');\r\n      return;\r\n    }\r\n    try {\r\n      let html = await this.tagService.getHtmlToInject(tagType, object);\r\n\r\n      if (html && html.trim().length > 0 && sdk) {\r\n        const scriptTag = this.tagService.getScriptForTag(object, tagType);\r\n        html += `${scriptTag}`;\r\n\r\n        const [sandboxId, messenger] = await sdk.Tag.registerSandbox(html);\r\n\r\n        const attachmentID = this.tagsAttachments[tagID];\r\n        if (attachmentID) {\r\n          try {\r\n            await sdk.Tag.detach(tagID, attachmentID);\r\n          } catch (e) { }\r\n        }\r\n\r\n        this.tagsAttachments[tagID] = sandboxId;\r\n        await sdk.Tag.attach(tagID, sandboxId);\r\n\r\n        // Attach the \"View informations\" handler in tooltip\r\n        messenger.on(TagAction.DETAIL_CLICK, this.tagService.onActionDetailClick.bind(this.tagService));\r\n        messenger.on(TagAction.TICKET_CLICK, this.tagService.onActionDetailClick.bind(this.tagService));\r\n        messenger.on(TagAction.AUDIO_CLICK, (audioCommentID: string) => this.tagService.onActionAudioClick(audioCommentID));\r\n        messenger.on(TagAction.VIDEO_CLICK, (videoUrl: string) => this.tagService.onActionVideoClick(videoUrl));\r\n        messenger.on(TagAction.IMAGE_CLICK, (imageCommentID: string) => this.tagService.onActionImageClick(imageCommentID));\r\n        messenger.on(TagAction.DOC_CLICK, (docUrl: string) => this.tagService.onActionDocClick(docUrl));\r\n        messenger.on(TagAction.YOUTUBE_CLICK, (youtubeUrl: string) => this.tagService.onActionYoutubeClick(youtubeUrl));\r\n      } else if (sdk) {\r\n        const { comment, tagDescription } = this.tagService.getBillboardMediaToEmbed(object);\r\n\r\n        if (comment) {\r\n          const attachmentID = await sdk.Tag.registerAttachment({\r\n            type: 'media',\r\n            data: {\r\n              url: comment.externalLink,\r\n              label: object.title || 'Media',\r\n            },\r\n          });\r\n\r\n          await sdk.Tag.attach(tagID, attachmentID);\r\n\r\n          const billboardAttachmentID = await sdk.Tag.registerAttachment({\r\n            type: 'billboard',\r\n            data: {\r\n              title: object.title,\r\n              description: tagDescription,\r\n            },\r\n          });\r\n\r\n          await sdk.Tag.attach(tagID, billboardAttachmentID);\r\n          this.tagsAttachments[tagID] = billboardAttachmentID;\r\n        }\r\n      }\r\n    } catch (error) {\r\n      console.error('[MatterportTagService] Error in injectHtmlInTag:', error);\r\n    }\r\n  }\r\n\r\n  /** Clears all local tag data and resets the addition queue. */\r\n  clear() {\r\n    this.dictionnaryTags.clear();\r\n    this.tagAddQueue = Promise.resolve();\r\n    this.mattertagToFollow = null;\r\n    this.mattertagIDs = [];\r\n  }\r\n}\r\n"]}