@smarterplan/ngx-smarterplan-core 1.2.39 → 1.2.45

package/esm2020/lib/services/navigator.service.mjs

@@ -1,212 +1,212 @@
-import { Injectable } from '@angular/core';
-import { Subject } from 'rxjs';
-import { first } from 'rxjs/operators';
-import * as i0 from "@angular/core";
-import * as i1 from "./matterport.service";
-import * as i2 from "./viewer.service";
-import * as i3 from "./models/zone.service";
-import * as i4 from "./user.service";
-import * as i5 from "./zoneChange.service";
-import * as i6 from "@angular/router";
-export class NavigatorService {
-    constructor(matterportService, viewerService, zoneService, userService, zoneChangeService, router, route) {
-        this.matterportService = matterportService;
-        this.viewerService = viewerService;
-        this.zoneService = zoneService;
-        this.userService = userService;
-        this.zoneChangeService = zoneChangeService;
-        this.router = router;
-        this.route = route;
-        this.visitLastPosition = new Map();
-        this.locationIDChange = new Subject();
-        this.navBarZoneIDChange = new Subject();
-        this.isVisibleChanged = new Subject();
-        this.audioZonesChange = new Subject();
-        this.matterportService.currentSweep
-            .pipe(first()) //  take first in order not to wait 2 sec an first load
-            .subscribe((sweep) => {
-            this.currentSweep = sweep;
-            if (this.zonesForUserForSpace) {
-                this.setZonesForCurrentSweep();
-            }
-        });
-        this.matterportService.currentSweep
-            //.pipe(debounceTime<string>(1500)) //  delays values emitted and return only the latest
-            .subscribe((sweep) => {
-            if (sweep === this.currentSweep) {
-                return;
-            }
-            this.currentSweep = sweep;
-            if (this.zonesForUserForSpace) {
-                this.setZonesForCurrentSweep();
-            }
-        });
-        this.viewerService.viewerIsOn.subscribe((data) => {
-            if (this.currentSpaceID !== data.spaceID) {
-                this.currentSpaceID = data.spaceID;
-            }
-            if (!data.spaceID) {
-                this.zonesForUserForSpace = null;
-                this.zonesSortedForCurrentSweep = null;
-                this.audioZonesForUserForSpace = null;
-                this.currentZone = null;
-                this.zoneChangeService.zoneChange.next(null);
-                this.currentSweep = null;
-                // save last position
-                const lastPose = this.matterportService.poseCamera;
-                if (lastPose && this.currentModel3D && this.userService.cu) {
-                    this.visitLastPosition.set(this.currentModel3D, {
-                        /**Override sweep/rotation if exist */
-                        sweep: this.targetSweep ?? lastPose.sweep,
-                        rotation: this.targetRotation ?? lastPose.rotation,
-                    });
-                }
-                this.currentModel3D = data.model3D;
-            }
-            else {
-                this.currentModel3D = data.model3D;
-                /**Override sweep/rotation if exist. Target is reset after (null)*/
-                this.targetSweep = this.targetSweep ?? data.sweep;
-                this.targetRotation = this.targetRotation ?? data.rotation;
-                this.onViewerLoaded().catch((e) => console.log(e));
-            }
-        });
-        this.userService.isChanged.subscribe((isConnected) => {
-            if (!isConnected) {
-                // user disconnected, clean Map
-                this.visitLastPosition = new Map();
-            }
-        });
-        this.route.queryParams.subscribe(params => {
-            const deepParamsBase64 = params['deepParams'];
-            if (deepParamsBase64) {
-                const deepParams = JSON.parse(atob(deepParamsBase64));
-                this.targetSweep = deepParams.sweepID;
-                this.targetRotation = deepParams.rotation;
-                /**Clear this query params */
-                this.router.navigate([], {
-                    queryParams: { deepParams: null }, queryParamsHandling: "merge"
-                });
-            }
-        });
-    }
-    getDeepLink() {
-        let data = null;
-        if (this.currentSweep) { /**Todo check matterport mod and adapt */
-            data = {
-                sweepID: this.currentSweep,
-                rotation: this.matterportService.getCurrentCameraPosition().rotation
-            };
-            data = btoa(JSON.stringify(data));
-        }
-        const model3D = this.currentModel3D;
-        const url = this.router.createUrlTree([], {
-            relativeTo: this.route,
-            queryParams: { deepParams: data, model3D },
-            queryParamsHandling: "merge"
-        });
-        return `${location.origin}${url.toString()}`;
-    }
-    getLastPositionForModel(model3D) {
-        return this.visitLastPosition.get(model3D);
-    }
-    goToSweepWithRotation(sweep, rotation = null) {
-        this.matterportService.action_go_to_sweep(sweep, rotation);
-    }
-    async goToFloor(floor) {
-        let matterportFloorSequence = null;
-        if (floor.metadata) {
-            const metadata = JSON.parse(floor.metadata);
-            if (metadata.matterportFloorSequence !== undefined) {
-                matterportFloorSequence = metadata.matterportFloorSequence;
-            }
-        }
-        await this.matterportService.action_go_to_floor(floor.name, matterportFloorSequence);
-    }
-    async onViewerLoaded() {
-        let sweepToGo = null;
-        let rotation = null;
-        if (this.targetSweep) {
-            sweepToGo = this.targetSweep;
-            rotation = this.targetRotation
-                ? this.targetRotation
-                : this.checkRotationForSweep(this.targetSweep);
-            /**Reset / Consume target */
-            this.targetRotation = null;
-            this.targetSweep = null;
-        }
-        else {
-            const lastPostion = this.getLastPositionForModel(this.currentModel3D);
-            if (lastPostion) {
-                sweepToGo = lastPostion.sweep;
-                rotation = lastPostion.rotation;
-            }
-        }
-        if (this.targetRotation) {
-            rotation = this.targetRotation;
-        }
-        if (sweepToGo && !this.floorToGo) {
-            // console.log("go to sweep", sweepToGo);
-            this.goToSweepWithRotation(sweepToGo, rotation);
-        }
-        if (this.floorToGo) {
-            this.goToFloor(this.floorToGo);
-            this.floorToGo = null;
-        }
-        // if first load and zones are not set
-        this.zonesForUserForSpace = await this.zoneService.getZonesBySpaceForUser(this.currentSpaceID);
-        this.audioZonesForUserForSpace = this.zonesForUserForSpace.filter((zone) => zone.audioID);
-        this.setZonesForCurrentSweep();
-    }
-    checkRotationForSweep(sweep) {
-        const lastPosition = this.visitLastPosition.get(this.currentModel3D);
-        if (lastPosition && lastPosition.sweep === sweep) {
-            return lastPosition.rotation;
-        }
-        return null;
-    }
-    setZonesForCurrentSweep() {
-        if (!this.currentSweep) {
-            return;
-        }
-        let zonesForSweep = this.zonesForUserForSpace?.filter((zone) => zone.sweepIDs && zone.sweepIDs.includes(this.currentSweep));
-        const audioZones = this.audioZonesForUserForSpace?.filter((zone) => zone.sweepIDs && zone.sweepIDs.includes(this.currentSweep));
-        this.audioZonesChange.next(audioZones);
-        this.currentAudioZones = audioZones;
-        // filter out audio zone (not to show to user it's name)
-        zonesForSweep = zonesForSweep.filter((zone) => !zone.audio);
-        // LINE BELOW IS COMMENTED SINCE CREATES INFINITE SPINNER FOR ZONES WITHOUT AUDIO...
-        // if (zonesForSweep && zonesForSweep.length > 0) {
-        this.zonesSortedForCurrentSweep = zonesForSweep.sort((a, b) => {
-            if (a.sweepIDs.length === b.sweepIDs.length) {
-                // if the same amount of sweeps: floor == the whole space
-                if (a.layer && b.layer) {
-                    // put type BUILDING at the end
-                    return a.layer.name !== 'BUILDING'
-                        ? -1
-                        : b.layer.name !== 'BUILDING'
-                            ? 1
-                            : 0;
-                }
-                return a.parent?.sweepIDs ? -1 : b.parent?.sweepIDs ? 1 : 0;
-            }
-            return a.sweepIDs.length - b.sweepIDs.length;
-        });
-        this.zoneChangeService.zonesForUserChange.next(this.zonesSortedForCurrentSweep);
-        if (this.zonesSortedForCurrentSweep.length > 0 &&
-            this.currentZone !== this.zonesSortedForCurrentSweep[0]) {
-            [this.currentZone] = this.zonesSortedForCurrentSweep;
-            this.zoneChangeService.zoneChange.next(this.currentZone);
-        }
-        // }
-    }
-}
-NavigatorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: NavigatorService, deps: [{ token: i1.MatterportService }, { token: i2.ViewerService }, { token: i3.ZoneService }, { token: i4.BaseUserService }, { token: i5.ZoneChangeService }, { token: i6.Router }, { token: i6.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable });
-NavigatorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: NavigatorService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: NavigatorService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: i1.MatterportService }, { type: i2.ViewerService }, { type: i3.ZoneService }, { type: i4.BaseUserService }, { type: i5.ZoneChangeService }, { type: i6.Router }, { type: i6.ActivatedRoute }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navigator.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/navigator.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Subject } from 'rxjs';\r\nimport { debounceTime, first } from 'rxjs/operators';\r\nimport { Zone } from '../types.service';\r\nimport { MatterportService } from './matterport.service';\r\nimport { ZoneService } from './models/zone.service';\r\nimport { ZoneChangeService } from './zoneChange.service';\r\nimport { BaseUserService } from './user.service';\r\nimport { ViewerService } from './viewer.service';\r\nimport { ActivatedRoute, Router } from '@angular/router';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class NavigatorService {\r\n  currentSweep: string | null;\r\n\r\n  targetSweep: string | null;\r\n\r\n  targetRotation: { x: number; y: number } | null;\r\n\r\n  currentModel3D: string | null;\r\n\r\n  currentSpaceID: string | null;\r\n\r\n  currentZone: Zone | null;\r\n\r\n  visitLastPosition: Map<string, { sweep: string; rotation: any }> = new Map();\r\n\r\n  floorToGo: Zone | null;\r\n\r\n  locationIDChange: Subject<string | null> = new Subject();\r\n\r\n  navBarZoneIDChange: Subject<string | null> = new Subject();\r\n\r\n  isVisibleChanged = new Subject<boolean>();\r\n\r\n  currentNavBarLocationID: string;\r\n\r\n  currentNavBarZoneID: string;\r\n\r\n  zonesSortedForCurrentSweep: Zone[] | null;\r\n\r\n  audioZonesChange: Subject<Zone[]> = new Subject();\r\n\r\n  zonesForUserForSpace: Zone[] | null;\r\n\r\n  currentAudioZones: Zone[];\r\n\r\n  audioZonesForUserForSpace: Zone[];\r\n\r\n\r\n  constructor(\r\n    private matterportService: MatterportService,\r\n    private viewerService: ViewerService,\r\n    private zoneService: ZoneService,\r\n    private userService: BaseUserService,\r\n    private zoneChangeService: ZoneChangeService,\r\n    private router: Router,\r\n    private route: ActivatedRoute,\r\n  ) {\r\n    this.matterportService.currentSweep\r\n      .pipe(first()) //  take first in order not to wait 2 sec an first load\r\n      .subscribe((sweep: string) => {\r\n        this.currentSweep = sweep;\r\n        if (this.zonesForUserForSpace) {\r\n          this.setZonesForCurrentSweep();\r\n        }\r\n      });\r\n    this.matterportService.currentSweep\r\n      //.pipe(debounceTime<string>(1500)) //  delays values emitted and return only the latest\r\n      .subscribe((sweep: string) => {\r\n        if (sweep === this.currentSweep) {\r\n          return;\r\n        }\r\n        this.currentSweep = sweep;\r\n        if (this.zonesForUserForSpace) {\r\n          this.setZonesForCurrentSweep();\r\n        }\r\n      });\r\n    this.viewerService.viewerIsOn.subscribe(\r\n      (data: {\r\n        spaceID: string | null;\r\n        model3D: string | null;\r\n        sweep: string | null;\r\n        rotation: { x: number; y: number } | null;\r\n      }) => {\r\n        if (this.currentSpaceID !== data.spaceID) {\r\n          this.currentSpaceID = data.spaceID;\r\n        }\r\n        if (!data.spaceID) {\r\n          this.zonesForUserForSpace = null;\r\n          this.zonesSortedForCurrentSweep = null;\r\n          this.audioZonesForUserForSpace = null;\r\n          this.currentZone = null;\r\n          this.zoneChangeService.zoneChange.next(null);\r\n          this.currentSweep = null;\r\n          // save last position\r\n          const lastPose = this.matterportService.poseCamera;\r\n          if (lastPose && this.currentModel3D && this.userService.cu) {\r\n            this.visitLastPosition.set(this.currentModel3D, {\r\n              /**Override sweep/rotation if exist */\r\n              sweep: this.targetSweep ?? lastPose.sweep,\r\n              rotation: this.targetRotation ?? lastPose.rotation,\r\n            });\r\n          }\r\n          this.currentModel3D = data.model3D;\r\n        } else {\r\n          this.currentModel3D = data.model3D;\r\n          /**Override sweep/rotation if exist. Target is reset after (null)*/\r\n          this.targetSweep = this.targetSweep ?? data.sweep;\r\n          this.targetRotation = this.targetRotation ?? data.rotation;\r\n          this.onViewerLoaded().catch((e) => console.log(e));\r\n        }\r\n      }\r\n    );\r\n    this.userService.isChanged.subscribe((isConnected) => {\r\n      if (!isConnected) {\r\n        // user disconnected, clean Map\r\n        this.visitLastPosition = new Map();\r\n      }\r\n    });\r\n\r\n    this.route.queryParams.subscribe(params => {\r\n      const deepParamsBase64 = params['deepParams'];\r\n      if(deepParamsBase64){\r\n        const deepParams : any = JSON.parse(atob(deepParamsBase64));\r\n        this.targetSweep = deepParams.sweepID;\r\n        this.targetRotation = deepParams.rotation;\r\n                \r\n        /**Clear this query params */\r\n        this.router.navigate([], {\r\n          queryParams: { deepParams: null }, queryParamsHandling : \"merge\"\r\n        });\r\n      }\r\n    });\r\n  }\r\n\r\n  \r\n  getDeepLink() : string{\r\n    let data = null;\r\n\r\n    if(this.currentSweep){ /**Todo check matterport mod and adapt */\r\n      data = {\r\n        sweepID : this.currentSweep,\r\n        rotation : this.matterportService.getCurrentCameraPosition().rotation\r\n      };\r\n\r\n      data = btoa(JSON.stringify(data));\r\n    }\r\n    \r\n    const model3D = this.currentModel3D;\r\n\r\n    const url = this.router.createUrlTree([], {\r\n      relativeTo: this.route,\r\n      queryParams: { deepParams: data, model3D },\r\n      queryParamsHandling: \"merge\"\r\n    });\r\n\r\n    return `${location.origin}${url.toString()}`;\r\n  }\r\n\r\n  getLastPositionForModel(model3D: string) {\r\n    return this.visitLastPosition.get(model3D);\r\n  }\r\n\r\n  goToSweepWithRotation(\r\n    sweep: string,\r\n    rotation: { x: number; y: number } | null = null\r\n  ) {\r\n    this.matterportService.action_go_to_sweep(sweep, rotation);\r\n  }\r\n\r\n  async goToFloor(floor: Zone) {\r\n    let matterportFloorSequence = null;\r\n    if (floor.metadata) {\r\n      const metadata = JSON.parse(floor.metadata);\r\n      if (metadata.matterportFloorSequence !== undefined) {\r\n        matterportFloorSequence = metadata.matterportFloorSequence;\r\n      }\r\n    }\r\n    await this.matterportService.action_go_to_floor(\r\n      floor.name,\r\n      matterportFloorSequence\r\n    );\r\n  }\r\n\r\n  async onViewerLoaded() {\r\n    let sweepToGo: string | null = null;\r\n    let rotation: { x: number; y: number } | null = null;\r\n    if (this.targetSweep) {\r\n      sweepToGo = this.targetSweep;\r\n      rotation = this.targetRotation\r\n        ? this.targetRotation\r\n        : this.checkRotationForSweep(this.targetSweep);\r\n        /**Reset / Consume target */\r\n        this.targetRotation = null;\r\n        this.targetSweep = null;\r\n    } else {\r\n      const lastPostion = this.getLastPositionForModel(this.currentModel3D!);\r\n      if (lastPostion) {\r\n        sweepToGo = lastPostion.sweep;\r\n        rotation = lastPostion.rotation;\r\n      }\r\n    }\r\n    if (this.targetRotation) {\r\n      rotation = this.targetRotation;\r\n    }\r\n    if (sweepToGo && !this.floorToGo) {\r\n      // console.log(\"go to sweep\", sweepToGo);\r\n      this.goToSweepWithRotation(sweepToGo, rotation);\r\n    }\r\n    if (this.floorToGo) {\r\n      this.goToFloor(this.floorToGo);\r\n      this.floorToGo = null;\r\n    }\r\n    // if first load and zones are not set\r\n    this.zonesForUserForSpace = await this.zoneService.getZonesBySpaceForUser(\r\n      this.currentSpaceID\r\n    );\r\n    this.audioZonesForUserForSpace = this.zonesForUserForSpace.filter(\r\n      (zone) => zone.audioID\r\n    );\r\n    this.setZonesForCurrentSweep();\r\n  }\r\n\r\n  checkRotationForSweep(sweep: string): { x: number; y: number } | null {\r\n    const lastPosition = this.visitLastPosition.get(this.currentModel3D!);\r\n    if (lastPosition && lastPosition.sweep === sweep) {\r\n      return lastPosition.rotation;\r\n    }\r\n    return null;\r\n  }\r\n\r\n  setZonesForCurrentSweep() {\r\n    if (!this.currentSweep) {\r\n      return;\r\n    }\r\n    let zonesForSweep = this.zonesForUserForSpace?.filter(\r\n      (zone) => zone.sweepIDs && zone.sweepIDs.includes(this.currentSweep)\r\n    );\r\n    const audioZones = this.audioZonesForUserForSpace?.filter(\r\n      (zone) => zone.sweepIDs && zone.sweepIDs.includes(this.currentSweep)\r\n    );\r\n    this.audioZonesChange.next(audioZones);\r\n    this.currentAudioZones = audioZones;\r\n\r\n    // filter out audio zone (not to show to user it's name)\r\n    zonesForSweep = zonesForSweep.filter((zone) => !zone.audio);\r\n    // LINE BELOW IS COMMENTED SINCE CREATES INFINITE SPINNER FOR ZONES WITHOUT AUDIO...\r\n    // if (zonesForSweep && zonesForSweep.length > 0) {\r\n      this.zonesSortedForCurrentSweep = zonesForSweep.sort((a, b) => {\r\n        if (a.sweepIDs!.length === b.sweepIDs!.length) {\r\n          // if the same amount of sweeps: floor == the whole space\r\n          if (a.layer && b.layer) {\r\n            // put type BUILDING at the end\r\n            return a.layer.name !== 'BUILDING'\r\n              ? -1\r\n              : b.layer.name !== 'BUILDING'\r\n              ? 1\r\n              : 0;\r\n          }\r\n          return a.parent?.sweepIDs ? -1 : b.parent?.sweepIDs ? 1 : 0;\r\n        }\r\n        return a.sweepIDs!.length - b.sweepIDs!.length;\r\n      });\r\n      this.zoneChangeService.zonesForUserChange.next(\r\n        this.zonesSortedForCurrentSweep\r\n      );\r\n\r\n      if (\r\n        this.zonesSortedForCurrentSweep.length > 0 &&\r\n        this.currentZone !== this.zonesSortedForCurrentSweep[0]\r\n      ) {\r\n        [this.currentZone] = this.zonesSortedForCurrentSweep;\r\n        this.zoneChangeService.zoneChange.next(this.currentZone);\r\n      }\r\n    // }\r\n  }\r\n}\r\n"]}
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { first } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./matterport.service";
+import * as i2 from "./viewer.service";
+import * as i3 from "./models/zone.service";
+import * as i4 from "./user.service";
+import * as i5 from "./zoneChange.service";
+import * as i6 from "@angular/router";
+export class NavigatorService {
+    constructor(matterportService, viewerService, zoneService, userService, zoneChangeService, router, route) {
+        this.matterportService = matterportService;
+        this.viewerService = viewerService;
+        this.zoneService = zoneService;
+        this.userService = userService;
+        this.zoneChangeService = zoneChangeService;
+        this.router = router;
+        this.route = route;
+        this.visitLastPosition = new Map();
+        this.locationIDChange = new Subject();
+        this.navBarZoneIDChange = new Subject();
+        this.isVisibleChanged = new Subject();
+        this.audioZonesChange = new Subject();
+        this.matterportService.currentSweep
+            .pipe(first()) //  take first in order not to wait 2 sec an first load
+            .subscribe((sweep) => {
+            this.currentSweep = sweep;
+            if (this.zonesForUserForSpace) {
+                this.setZonesForCurrentSweep();
+            }
+        });
+        this.matterportService.currentSweep
+            //.pipe(debounceTime<string>(1500)) //  delays values emitted and return only the latest
+            .subscribe((sweep) => {
+            if (sweep === this.currentSweep) {
+                return;
+            }
+            this.currentSweep = sweep;
+            if (this.zonesForUserForSpace) {
+                this.setZonesForCurrentSweep();
+            }
+        });
+        this.viewerService.viewerIsOn.subscribe((data) => {
+            if (this.currentSpaceID !== data.spaceID) {
+                this.currentSpaceID = data.spaceID;
+            }
+            if (!data.spaceID) {
+                this.zonesForUserForSpace = null;
+                this.zonesSortedForCurrentSweep = null;
+                this.audioZonesForUserForSpace = null;
+                this.currentZone = null;
+                this.zoneChangeService.zoneChange.next(null);
+                this.currentSweep = null;
+                // save last position
+                const lastPose = this.matterportService.poseCamera;
+                if (lastPose && this.currentModel3D && this.userService.cu) {
+                    this.visitLastPosition.set(this.currentModel3D, {
+                        /**Override sweep/rotation if exist */
+                        sweep: this.targetSweep ?? lastPose.sweep,
+                        rotation: this.targetRotation ?? lastPose.rotation,
+                    });
+                }
+                this.currentModel3D = data.model3D;
+            }
+            else {
+                this.currentModel3D = data.model3D;
+                /**Override sweep/rotation if exist. Target is reset after (null)*/
+                this.targetSweep = this.targetSweep ?? data.sweep;
+                this.targetRotation = this.targetRotation ?? data.rotation;
+                this.onViewerLoaded().catch((e) => console.log(e));
+            }
+        });
+        this.userService.isChanged.subscribe((isConnected) => {
+            if (!isConnected) {
+                // user disconnected, clean Map
+                this.visitLastPosition = new Map();
+            }
+        });
+        this.route.queryParams.subscribe(params => {
+            const deepParamsBase64 = params['deepParams'];
+            if (deepParamsBase64) {
+                const deepParams = JSON.parse(atob(deepParamsBase64));
+                this.targetSweep = deepParams.sweepID;
+                this.targetRotation = deepParams.rotation;
+                /**Clear this query params */
+                this.router.navigate([], {
+                    queryParams: { deepParams: null }, queryParamsHandling: "merge"
+                });
+            }
+        });
+    }
+    getDeepLink() {
+        let data = null;
+        if (this.currentSweep) { /**Todo check matterport mod and adapt */
+            data = {
+                sweepID: this.currentSweep,
+                rotation: this.matterportService.getCurrentCameraPosition().rotation
+            };
+            data = btoa(JSON.stringify(data));
+        }
+        const model3D = this.currentModel3D;
+        const url = this.router.createUrlTree([], {
+            relativeTo: this.route,
+            queryParams: { deepParams: data, model3D },
+            queryParamsHandling: "merge"
+        });
+        return `${location.origin}${url.toString()}`;
+    }
+    getLastPositionForModel(model3D) {
+        return this.visitLastPosition.get(model3D);
+    }
+    goToSweepWithRotation(sweep, rotation = null) {
+        this.matterportService.action_go_to_sweep(sweep, rotation);
+    }
+    async goToFloor(floor) {
+        let matterportFloorSequence = null;
+        if (floor.metadata) {
+            const metadata = JSON.parse(floor.metadata);
+            if (metadata.matterportFloorSequence !== undefined) {
+                matterportFloorSequence = metadata.matterportFloorSequence;
+            }
+        }
+        await this.matterportService.action_go_to_floor(floor.name, matterportFloorSequence);
+    }
+    async onViewerLoaded() {
+        let sweepToGo = null;
+        let rotation = null;
+        if (this.targetSweep) {
+            sweepToGo = this.targetSweep;
+            rotation = this.targetRotation
+                ? this.targetRotation
+                : this.checkRotationForSweep(this.targetSweep);
+            /**Reset / Consume target */
+            this.targetRotation = null;
+            this.targetSweep = null;
+        }
+        else {
+            const lastPostion = this.getLastPositionForModel(this.currentModel3D);
+            if (lastPostion) {
+                sweepToGo = lastPostion.sweep;
+                rotation = lastPostion.rotation;
+            }
+        }
+        if (this.targetRotation) {
+            rotation = this.targetRotation;
+        }
+        if (sweepToGo && !this.floorToGo) {
+            // console.log("go to sweep", sweepToGo);
+            this.goToSweepWithRotation(sweepToGo, rotation);
+        }
+        if (this.floorToGo) {
+            this.goToFloor(this.floorToGo);
+            this.floorToGo = null;
+        }
+        // if first load and zones are not set
+        this.zonesForUserForSpace = await this.zoneService.getZonesBySpaceForUser(this.currentSpaceID);
+        this.audioZonesForUserForSpace = this.zonesForUserForSpace.filter((zone) => zone.audioID);
+        this.setZonesForCurrentSweep();
+    }
+    checkRotationForSweep(sweep) {
+        const lastPosition = this.visitLastPosition.get(this.currentModel3D);
+        if (lastPosition && lastPosition.sweep === sweep) {
+            return lastPosition.rotation;
+        }
+        return null;
+    }
+    setZonesForCurrentSweep() {
+        if (!this.currentSweep) {
+            return;
+        }
+        let zonesForSweep = this.zonesForUserForSpace?.filter((zone) => zone.sweepIDs && zone.sweepIDs.includes(this.currentSweep));
+        const audioZones = this.audioZonesForUserForSpace?.filter((zone) => zone.sweepIDs && zone.sweepIDs.includes(this.currentSweep));
+        this.audioZonesChange.next(audioZones);
+        this.currentAudioZones = audioZones;
+        // filter out audio zone (not to show to user it's name)
+        zonesForSweep = zonesForSweep.filter((zone) => !zone.audio);
+        // LINE BELOW IS COMMENTED SINCE CREATES INFINITE SPINNER FOR ZONES WITHOUT AUDIO...
+        // if (zonesForSweep && zonesForSweep.length > 0) {
+        this.zonesSortedForCurrentSweep = zonesForSweep.sort((a, b) => {
+            if (a.sweepIDs.length === b.sweepIDs.length) {
+                // if the same amount of sweeps: floor == the whole space
+                if (a.layer && b.layer) {
+                    // put type BUILDING at the end
+                    return a.layer.name !== 'BUILDING'
+                        ? -1
+                        : b.layer.name !== 'BUILDING'
+                            ? 1
+                            : 0;
+                }
+                return a.parent?.sweepIDs ? -1 : b.parent?.sweepIDs ? 1 : 0;
+            }
+            return a.sweepIDs.length - b.sweepIDs.length;
+        });
+        this.zoneChangeService.zonesForUserChange.next(this.zonesSortedForCurrentSweep);
+        if (this.zonesSortedForCurrentSweep.length > 0 &&
+            this.currentZone !== this.zonesSortedForCurrentSweep[0]) {
+            [this.currentZone] = this.zonesSortedForCurrentSweep;
+            this.zoneChangeService.zoneChange.next(this.currentZone);
+        }
+        // }
+    }
+}
+NavigatorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: NavigatorService, deps: [{ token: i1.MatterportService }, { token: i2.ViewerService }, { token: i3.ZoneService }, { token: i4.BaseUserService }, { token: i5.ZoneChangeService }, { token: i6.Router }, { token: i6.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable });
+NavigatorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: NavigatorService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: NavigatorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatterportService }, { type: i2.ViewerService }, { type: i3.ZoneService }, { type: i4.BaseUserService }, { type: i5.ZoneChangeService }, { type: i6.Router }, { type: i6.ActivatedRoute }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navigator.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/navigator.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { debounceTime, first } from 'rxjs/operators';\nimport { Zone } from '../types.service';\nimport { MatterportService } from './matterport.service';\nimport { ZoneService } from './models/zone.service';\nimport { ZoneChangeService } from './zoneChange.service';\nimport { BaseUserService } from './user.service';\nimport { ViewerService } from './viewer.service';\nimport { ActivatedRoute, Router } from '@angular/router';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class NavigatorService {\n  currentSweep: string | null;\n\n  targetSweep: string | null;\n\n  targetRotation: { x: number; y: number } | null;\n\n  currentModel3D: string | null;\n\n  currentSpaceID: string | null;\n\n  currentZone: Zone | null;\n\n  visitLastPosition: Map<string, { sweep: string; rotation: any }> = new Map();\n\n  floorToGo: Zone | null;\n\n  locationIDChange: Subject<string | null> = new Subject();\n\n  navBarZoneIDChange: Subject<string | null> = new Subject();\n\n  isVisibleChanged = new Subject<boolean>();\n\n  currentNavBarLocationID: string;\n\n  currentNavBarZoneID: string;\n\n  zonesSortedForCurrentSweep: Zone[] | null;\n\n  audioZonesChange: Subject<Zone[]> = new Subject();\n\n  zonesForUserForSpace: Zone[] | null;\n\n  currentAudioZones: Zone[];\n\n  audioZonesForUserForSpace: Zone[];\n\n\n  constructor(\n    private matterportService: MatterportService,\n    private viewerService: ViewerService,\n    private zoneService: ZoneService,\n    private userService: BaseUserService,\n    private zoneChangeService: ZoneChangeService,\n    private router: Router,\n    private route: ActivatedRoute,\n  ) {\n    this.matterportService.currentSweep\n      .pipe(first()) //  take first in order not to wait 2 sec an first load\n      .subscribe((sweep: string) => {\n        this.currentSweep = sweep;\n        if (this.zonesForUserForSpace) {\n          this.setZonesForCurrentSweep();\n        }\n      });\n    this.matterportService.currentSweep\n      //.pipe(debounceTime<string>(1500)) //  delays values emitted and return only the latest\n      .subscribe((sweep: string) => {\n        if (sweep === this.currentSweep) {\n          return;\n        }\n        this.currentSweep = sweep;\n        if (this.zonesForUserForSpace) {\n          this.setZonesForCurrentSweep();\n        }\n      });\n    this.viewerService.viewerIsOn.subscribe(\n      (data: {\n        spaceID: string | null;\n        model3D: string | null;\n        sweep: string | null;\n        rotation: { x: number; y: number } | null;\n      }) => {\n        if (this.currentSpaceID !== data.spaceID) {\n          this.currentSpaceID = data.spaceID;\n        }\n        if (!data.spaceID) {\n          this.zonesForUserForSpace = null;\n          this.zonesSortedForCurrentSweep = null;\n          this.audioZonesForUserForSpace = null;\n          this.currentZone = null;\n          this.zoneChangeService.zoneChange.next(null);\n          this.currentSweep = null;\n          // save last position\n          const lastPose = this.matterportService.poseCamera;\n          if (lastPose && this.currentModel3D && this.userService.cu) {\n            this.visitLastPosition.set(this.currentModel3D, {\n              /**Override sweep/rotation if exist */\n              sweep: this.targetSweep ?? lastPose.sweep,\n              rotation: this.targetRotation ?? lastPose.rotation,\n            });\n          }\n          this.currentModel3D = data.model3D;\n        } else {\n          this.currentModel3D = data.model3D;\n          /**Override sweep/rotation if exist. Target is reset after (null)*/\n          this.targetSweep = this.targetSweep ?? data.sweep;\n          this.targetRotation = this.targetRotation ?? data.rotation;\n          this.onViewerLoaded().catch((e) => console.log(e));\n        }\n      }\n    );\n    this.userService.isChanged.subscribe((isConnected) => {\n      if (!isConnected) {\n        // user disconnected, clean Map\n        this.visitLastPosition = new Map();\n      }\n    });\n\n    this.route.queryParams.subscribe(params => {\n      const deepParamsBase64 = params['deepParams'];\n      if(deepParamsBase64){\n        const deepParams : any = JSON.parse(atob(deepParamsBase64));\n        this.targetSweep = deepParams.sweepID;\n        this.targetRotation = deepParams.rotation;\n                \n        /**Clear this query params */\n        this.router.navigate([], {\n          queryParams: { deepParams: null }, queryParamsHandling : \"merge\"\n        });\n      }\n    });\n  }\n\n  \n  getDeepLink() : string{\n    let data = null;\n\n    if(this.currentSweep){ /**Todo check matterport mod and adapt */\n      data = {\n        sweepID : this.currentSweep,\n        rotation : this.matterportService.getCurrentCameraPosition().rotation\n      };\n\n      data = btoa(JSON.stringify(data));\n    }\n    \n    const model3D = this.currentModel3D;\n\n    const url = this.router.createUrlTree([], {\n      relativeTo: this.route,\n      queryParams: { deepParams: data, model3D },\n      queryParamsHandling: \"merge\"\n    });\n\n    return `${location.origin}${url.toString()}`;\n  }\n\n  getLastPositionForModel(model3D: string) {\n    return this.visitLastPosition.get(model3D);\n  }\n\n  goToSweepWithRotation(\n    sweep: string,\n    rotation: { x: number; y: number } | null = null\n  ) {\n    this.matterportService.action_go_to_sweep(sweep, rotation);\n  }\n\n  async goToFloor(floor: Zone) {\n    let matterportFloorSequence = null;\n    if (floor.metadata) {\n      const metadata = JSON.parse(floor.metadata);\n      if (metadata.matterportFloorSequence !== undefined) {\n        matterportFloorSequence = metadata.matterportFloorSequence;\n      }\n    }\n    await this.matterportService.action_go_to_floor(\n      floor.name,\n      matterportFloorSequence\n    );\n  }\n\n  async onViewerLoaded() {\n    let sweepToGo: string | null = null;\n    let rotation: { x: number; y: number } | null = null;\n    if (this.targetSweep) {\n      sweepToGo = this.targetSweep;\n      rotation = this.targetRotation\n        ? this.targetRotation\n        : this.checkRotationForSweep(this.targetSweep);\n        /**Reset / Consume target */\n        this.targetRotation = null;\n        this.targetSweep = null;\n    } else {\n      const lastPostion = this.getLastPositionForModel(this.currentModel3D!);\n      if (lastPostion) {\n        sweepToGo = lastPostion.sweep;\n        rotation = lastPostion.rotation;\n      }\n    }\n    if (this.targetRotation) {\n      rotation = this.targetRotation;\n    }\n    if (sweepToGo && !this.floorToGo) {\n      // console.log(\"go to sweep\", sweepToGo);\n      this.goToSweepWithRotation(sweepToGo, rotation);\n    }\n    if (this.floorToGo) {\n      this.goToFloor(this.floorToGo);\n      this.floorToGo = null;\n    }\n    // if first load and zones are not set\n    this.zonesForUserForSpace = await this.zoneService.getZonesBySpaceForUser(\n      this.currentSpaceID\n    );\n    this.audioZonesForUserForSpace = this.zonesForUserForSpace.filter(\n      (zone) => zone.audioID\n    );\n    this.setZonesForCurrentSweep();\n  }\n\n  checkRotationForSweep(sweep: string): { x: number; y: number } | null {\n    const lastPosition = this.visitLastPosition.get(this.currentModel3D!);\n    if (lastPosition && lastPosition.sweep === sweep) {\n      return lastPosition.rotation;\n    }\n    return null;\n  }\n\n  setZonesForCurrentSweep() {\n    if (!this.currentSweep) {\n      return;\n    }\n    let zonesForSweep = this.zonesForUserForSpace?.filter(\n      (zone) => zone.sweepIDs && zone.sweepIDs.includes(this.currentSweep)\n    );\n    const audioZones = this.audioZonesForUserForSpace?.filter(\n      (zone) => zone.sweepIDs && zone.sweepIDs.includes(this.currentSweep)\n    );\n    this.audioZonesChange.next(audioZones);\n    this.currentAudioZones = audioZones;\n\n    // filter out audio zone (not to show to user it's name)\n    zonesForSweep = zonesForSweep.filter((zone) => !zone.audio);\n    // LINE BELOW IS COMMENTED SINCE CREATES INFINITE SPINNER FOR ZONES WITHOUT AUDIO...\n    // if (zonesForSweep && zonesForSweep.length > 0) {\n      this.zonesSortedForCurrentSweep = zonesForSweep.sort((a, b) => {\n        if (a.sweepIDs!.length === b.sweepIDs!.length) {\n          // if the same amount of sweeps: floor == the whole space\n          if (a.layer && b.layer) {\n            // put type BUILDING at the end\n            return a.layer.name !== 'BUILDING'\n              ? -1\n              : b.layer.name !== 'BUILDING'\n              ? 1\n              : 0;\n          }\n          return a.parent?.sweepIDs ? -1 : b.parent?.sweepIDs ? 1 : 0;\n        }\n        return a.sweepIDs!.length - b.sweepIDs!.length;\n      });\n      this.zoneChangeService.zonesForUserChange.next(\n        this.zonesSortedForCurrentSweep\n      );\n\n      if (\n        this.zonesSortedForCurrentSweep.length > 0 &&\n        this.currentZone !== this.zonesSortedForCurrentSweep[0]\n      ) {\n        [this.currentZone] = this.zonesSortedForCurrentSweep;\n        this.zoneChangeService.zoneChange.next(this.currentZone);\n      }\n    // }\n  }\n}\n"]}