@smarterplan/ngx-smarterplan-core 1.4.16 → 1.4.17

package/lib/services/models/base-object.service.d.ts

@@ -1,11 +1,13 @@
 import { Equipment, Feature, POI, Ticket } from "../../types.service";
 import { NavigationService } from "./navigation.service";
 import { PoiService } from "./poi.service";
+import { VisitService } from "./visit.service";
 import * as i0 from "@angular/core";
 export declare class BaseObjectService {
     protected poiService: PoiService;
     private navigationService;
-    constructor(poiService: PoiService, navigationService: NavigationService);
+    private visitService;
+    constructor(poiService: PoiService, navigationService: NavigationService, visitService: VisitService);
     getModel3dAndSweep(object: Feature | Ticket | Equipment): Promise<{
         model3D: string;
         sweep: string;
@@ -14,6 +16,14 @@ export declare class BaseObjectService {
             y: number;
         };
     } | void>;
+    /**
+     * The space's 3D visit, or null when it has none.
+     *
+     * Takes the first one the database returns. That is not the space's chosen default - the
+     * default ordering lives in SpaceService, which cannot be injected here. The POI does not record
+     * which capture it was placed in, so with several 3D models this is a guess either way.
+     */
+    private getThreeJsVisitForSpace;
     updateIconForAllObjects(objects: Ticket[] | Feature[] | Equipment[], tagIcon: string): Promise<POI[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BaseObjectService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BaseObjectService>;

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

@@ -10,6 +10,7 @@ import { BaseObjectService } from './base-object.service';
 import { NavigationService } from './navigation.service';
 import { OperationService } from './operation.service';
 import { PoiService } from './poi.service';
+import { VisitService } from './visit.service';
 import { TicketsService } from './ticket.service';
 import { ZoneChangeService } from "../zoneChange.service";
 import * as i0 from "@angular/core";
@@ -49,7 +50,7 @@ export declare class EquipmentService extends BaseObjectService {
     awsKinesisAnalytics: any;
     isMuseumUser: boolean;
     private destroy$;
-    constructor(apiInjected: any, awsKinesisAnalyticsInjected: any, poiService: PoiService, navigationService: NavigationService, operationService: OperationService, ticketsService: TicketsService, navigatorService: NavigatorService, filterService: FilterService, userService: BaseUserService, viewerService: ViewerService, modalService: NgbModal, zoneChangeService: ZoneChangeService);
+    constructor(apiInjected: any, awsKinesisAnalyticsInjected: any, poiService: PoiService, navigationService: NavigationService, visitService: VisitService, operationService: OperationService, ticketsService: TicketsService, navigatorService: NavigatorService, filterService: FilterService, userService: BaseUserService, viewerService: ViewerService, modalService: NgbModal, zoneChangeService: ZoneChangeService);
     readEquipment(id: string): Promise<Equipment>;
     createEquipment(equip: Equipment, imageFile: File, documentFile: File): Promise<Equipment | void>;
     getSignedUrlsForEquipment(equip: Equipment): Promise<Equipment>;

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

@@ -9,6 +9,7 @@ import { CommentService } from "./comment.service";
 import { HashtagService } from "./hashtag.service";
 import { NavigationService } from "./navigation.service";
 import { PoiService } from "./poi.service";
+import { VisitService } from "./visit.service";
 import { ZoneChangeService } from "../zoneChange.service";
 import * as i0 from "@angular/core";
 export declare class FeatureService extends BaseObjectService {
@@ -40,7 +41,7 @@ export declare class FeatureService extends BaseObjectService {
     currentHashtags: Hashtag[];
     createObservable: Subject<Feature>;
     deleteObservable: Subject<Feature>;
-    constructor(apiInjected: any, navigatorService: NavigatorService, filterService: FilterService, poiService: PoiService, commentService: CommentService, userService: BaseUserService, navigationService: NavigationService, hashtagService: HashtagService, zoneChangeService: ZoneChangeService);
+    constructor(apiInjected: any, navigatorService: NavigatorService, filterService: FilterService, poiService: PoiService, commentService: CommentService, userService: BaseUserService, navigationService: NavigationService, visitService: VisitService, hashtagService: HashtagService, zoneChangeService: ZoneChangeService);
     createFeature(feature: Feature): Promise<Feature>;
     deleteFeature(feature: Feature): Promise<Feature>;
     updateFeature(feature: any): Promise<Feature>;

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

@@ -47,6 +47,13 @@ export declare class SpaceService {
      * viewer offers them as a list, so the caller needs all of them rather than just the first.
      */
     getAllowedVisitsForSpace(spaceID: string): Promise<Visit[]>;
+    /**
+     * Sets which capture a visitor opens by default for this space.
+     *
+     * Pass null to clear it. Writing a single field on the space is what keeps the answer unique:
+     * there is nothing to clear elsewhere, and no way for two captures to both claim it.
+     */
+    setDefaultCapture(spaceID: string, captureID: string | null): Promise<Space>;
     getAllowedModel3DForSpace(spaceID: string): Promise<string>;
     softDeleteSpace(spaceID: string): Promise<void>;
     /**

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

@@ -10,6 +10,7 @@ import { BaseObjectService } from './base-object.service';
 import { NavigationService } from './navigation.service';
 import { OperationService } from './operation.service';
 import { PoiService } from './poi.service';
+import { VisitService } from './visit.service';
 import { EventService } from './event.service';
 import { InterventionService } from '../intervention.service';
 import { AffectationService } from './affectation.service';
@@ -38,6 +39,8 @@ export declare class TicketsService extends BaseObjectService {
     }>;
     currentSpaceID: string;
     zoneIDFilter: string;
+    /** Set while a viewer without zone navigation (Three.js) is showing a space. */
+    private spaceSubscription;
     dateFilter: Date[];
     ticketTypeFilter: TicketType[];
     reportingIcon: import("@iconify/types").IconifyIcon;
@@ -55,7 +58,7 @@ export declare class TicketsService extends BaseObjectService {
     floorsPerSpace: Zone[];
     selectedFloor: Zone;
     private destroy$;
-    constructor(awsKinesisAnalyticsInjected: any, apiInjected: any, operationService: OperationService, eventService: EventService, affectationService: AffectationService, poiService: PoiService, userService: BaseUserService, navigatorService: NavigatorService, filterService: FilterService, interventionService: InterventionService, navigationService: NavigationService, viewerService: ViewerService, zoneChangeService: ZoneChangeService, modalService: NgbModal);
+    constructor(awsKinesisAnalyticsInjected: any, apiInjected: any, operationService: OperationService, eventService: EventService, affectationService: AffectationService, poiService: PoiService, userService: BaseUserService, navigatorService: NavigatorService, filterService: FilterService, interventionService: InterventionService, navigationService: NavigationService, visitService: VisitService, viewerService: ViewerService, zoneChangeService: ZoneChangeService, modalService: NgbModal);
     initTickets(): Promise<void>;
     adaptTicket(ticket: Ticket): Promise<Ticket>;
     getPriorityColor(ticket: Ticket): string;

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

@@ -20,6 +20,8 @@ export interface ThreeJsTag {
     };
     /** Drives both the click route and type filtering, so it travels with the tag. */
     poiType?: PoiType | null;
+    /** Shown on hover. A marker with no identity is just a dot on a wall. */
+    label?: string | null;
     /** Icon drawn on the tag. Falls back to a plain disc when absent or it fails to load. */
     iconUrl?: string | null;
     /** Tint for the fallback disc, as a CSS colour. */
@@ -49,6 +51,8 @@ export interface ThreeJsTagPlacement {
         y: number;
         z: number;
     };
+    /** What the placement was armed for, so the caller knows which creation form to open. */
+    poiType?: PoiType | null;
 }
 /** One tag seen in both spaces: where it is stored, and where it really sits on the model. */
 export interface ThreeJsAlignmentPair {
@@ -114,6 +118,11 @@ export declare class ThreeJsService {
     objectClicked$: Subject<string>;
     /** Emits when the user clicks a tag, mirroring Matterport's tag click. */
     tagClicked$: Subject<ThreeJsTagClick>;
+    /** Emits a tag's label while the pointer is over it, and null when it leaves. */
+    tagHovered$: Subject<{
+        label: string;
+        event: MouseEvent;
+    }>;
     private tagGroup;
     private tagSprites;
     private canvasResizeObserver?;
@@ -122,10 +131,30 @@ export declare class ThreeJsService {
     private modelRoot?;
     /** True while the next click on the model places a tag instead of orbiting. */
     private placingTag;
+    /** What the armed placement is for, echoed back when the spot is picked. */
+    private placementPoiType;
     /** Position and normal of the last placed tag, in model space, awaiting commit to a POI. */
     private pendingTagPlacement;
+    /** Pointer position waiting for a preview pick, coalesced to one per frame. */
+    private pendingPreviewEvent;
+    /**
+     * Layer carrying the model alone, so the depth pick can render it without the tags.
+     *
+     * Layers are tested per object at render time and children are traversed regardless of whether
+     * their parent passed, so marking the model's own meshes is enough - no re-parenting.
+     */
+    private static readonly PICK_LAYER;
+    /** Cache Storage bucket holding downloaded models, and how many to keep. */
+    private static readonly MODEL_CACHE;
+    private static readonly MODEL_CACHE_SIZE;
+    private pickTarget?;
+    private pickCamera?;
+    private pickDepthMaterial?;
+    private readonly pickPixel;
     /** Emits once a tag is dropped on the model, so the UI can confirm and persist it. */
     tagPlaced$: Subject<ThreeJsTagPlacement>;
+    /** Emits when the calibration walkthrough is abandoned, so the panel driving it can close. */
+    alignmentCancelled$: Subject<void>;
     /** Translucent marker shown under the cursor while placing. */
     private placementPreview?;
     private aligning;
@@ -191,7 +220,7 @@ export declare class ThreeJsService {
         x: number;
         y: number;
         z: number;
-    }): void;
+    }, cacheKey?: string): void;
     /**
      * Stops the model download in progress, if any.
      *
@@ -225,6 +254,25 @@ export declare class ThreeJsService {
      * stream reports it as it happens rather than in one jump at the end.
      */
     private fetchWithProgress;
+    /**
+     * The model store, or null where the browser will not give us one.
+     *
+     * Cache Storage needs a secure context, so it is absent over plain http and in some embedded
+     * webviews. Every caller treats that as a miss - caching is an optimisation, never a requirement.
+     */
+    private openModelCache;
+    /**
+     * A cached copy of this model, if one was stored.
+     *
+     * Keyed by the S3 key rather than the URL it is fetched from: that URL is signed, so it carries a
+     * fresh signature and expiry every time and would never match twice. The browser's own HTTP cache
+     * misses for the same reason, which is why this exists at all.
+     */
+    private readModelFromCache;
+    /** Stores a model for next time, evicting the oldest once a few are held. */
+    private writeModelToCache;
+    /** Cache Storage keys on a URL, so the S3 key is expressed as one. It is never requested. */
+    private modelCacheUrl;
     /**
      * Fits the camera's clipping planes to how big the model actually is.
      *
@@ -326,6 +374,16 @@ export declare class ThreeJsService {
     startTagAlignment(): void;
     cancelTagAlignment(): void;
     isAligningTags(): boolean;
+    /**
+     * Whether the pointer should be showing the placement ghost.
+     *
+     * True while placing a tag, and while calibrating once a tag has been picked - that second click
+     * is the same question ("where on the model?") and deserves the same aiming aid. Not true for the
+     * first half of a pair, which is a click on a tag, not on the model.
+     */
+    private isPreviewingPlacement;
+    /** Whether a tag is currently registered for this element. */
+    hasTag(elementId: string): boolean;
     /**
      * Solves and applies the alignment collected so far, returning it so the caller can persist it.
      *
@@ -336,7 +394,7 @@ export declare class ThreeJsService {
     /** Handles a click while the alignment walkthrough is running. */
     private handleAlignmentClick;
     /** Arms tag placement: the next click on the model drops a tag instead of being ignored. */
-    startTagPlacement(): void;
+    startTagPlacement(poiType?: PoiType | null): void;
     /** Leaves placement mode without placing anything. */
     cancelTagPlacement(): void;
     /**
@@ -346,6 +404,21 @@ export declare class ThreeJsService {
      * sprite that gets removed the moment the real tag takes its place.
      */
     private updatePlacementPreview;
+    /**
+     * The point under the cursor, read from the depth buffer instead of raycast, in tag space.
+     *
+     * A raycast walks every triangle of the mesh it hits: on a captured model that is millions of
+     * them, tens of milliseconds, every time the pointer moves. Coalescing to one per frame did not
+     * help, because the cost is the pick itself - it simply became one slow frame instead of several.
+     *
+     * Rendering the model's depth into a single pixel under the cursor answers the same question on
+     * the GPU in constant time, whatever the model's size. The camera's view offset is what narrows
+     * the whole image down to that one pixel, so the value read back is the depth the cursor is over.
+     *
+     * Used for the ghost only. The click that actually places a tag still raycasts: it is one pick,
+     * its cost does not matter, and it yields the surface normal, which depth alone cannot give.
+     */
+    private pickPointOnGpu;
     private removePlacementPreview;
     /** Shows or hides one tag, leaving it registered so it can be brought back without reloading. */
     setTagVisibility(elementId: string, visible: boolean): void;
@@ -370,12 +443,30 @@ export declare class ThreeJsService {
     /** The spot picked by the last placement, for whoever commits it to a POI. */
     getPendingTagPlacement(): ThreeJsTagPlacement | null;
     /**
-     * Turns a click into a point on the model, in model space.
+     * Raycasts a click against the model's geometry and returns the hit, in world space.
      *
-     * Returns null when the click missed the geometry, which is a normal outcome - the user clicked
-     * the sky - and leaves placement mode armed so they can simply try again.
+     * Returns null when the click missed, which is a normal outcome - the user clicked the sky - and
+     * leaves whatever mode is armed still armed, so they can simply try again.
+     */
+    private raycastModel;
+    /**
+     * Turns a click into a point on the model, in the frame tag coordinates are persisted in.
+     *
+     * That frame is the tag group's, not the model's. A stored coordinate is read back as a sprite
+     * position inside that group, so a coordinate captured in any other frame comes back displaced by
+     * exactly however far the alignment moves the group. The two frames agree only while the
+     * alignment is identity, which is why this stayed invisible until a model was calibrated.
      */
     private pickPlacementOnModel;
+    /**
+     * Where the user says a tag really belongs, in the space the solved alignment maps onto.
+     *
+     * setTagAlignment writes the solution to the tag group's own transform, which is expressed
+     * relative to its parent - so the target has to be in the parent's frame. Measuring it in the
+     * group's own frame instead would fold the current alignment into the answer, making each
+     * calibration depend on the one before it.
+     */
+    private pickAlignmentTarget;
     /**
      * Sets the transform mapping captured tag coordinates onto this model's space.
      *
@@ -416,6 +507,13 @@ export declare class ThreeJsService {
     updateObjsToScene(objsAdded: ObjAdded[]): void;
     private onMouseMove;
     private onMouseClick;
+    /**
+     * Escape cancels whatever the pointer is currently committed to.
+     *
+     * Emits through the same subjects the explicit Cancel buttons use, so the UI driving them follows
+     * along instead of being left showing a mode that is no longer armed.
+     */
+    private onKeyDown;
     private animate;
     destroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ThreeJsService, never>;

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

@@ -4,9 +4,11 @@ import { ThreeJsService } from './threejs.service';
 import { BaseTagService } from './tag.service';
 import { DbObjectType, POI, PoiType, Comment, Equipment, Ticket, Feature, SpModule } from '../types.service';
 import { PoiService } from './models/poi.service';
+import { Config } from '../config';
 import * as i0 from "@angular/core";
 export declare class ViewerService {
     private readonly sdkKey;
+    private readonly config;
     private poiService;
     private matterportService;
     private threeJsService;
@@ -25,6 +27,14 @@ export declare class ViewerService {
     dataIsLoaded: Subject<boolean>;
     isLoaded: boolean;
     showingViewer: boolean;
+    /**
+     * The space being viewed, whichever viewer is showing it.
+     *
+     * MatterportService carries its own copy, set while its SDK connects - which never happens in
+     * Three.js mode. Anything that reads only that one silently does nothing for a 3D model, and the
+     * lists that feed tags are exactly that.
+     */
+    currentSpaceID: string | null;
     sweepToMove: string | null;
     rotationToMove: {
         x: number;
@@ -52,7 +62,7 @@ export declare class ViewerService {
         };
     };
     private isObjectLoaded;
-    constructor(sdkKey: string, poiService: PoiService, matterportService: MatterportService, threeJsService: ThreeJsService);
+    constructor(sdkKey: string, config: Config, poiService: PoiService, matterportService: MatterportService, threeJsService: ThreeJsService);
     checkMode(indexMode: string): boolean;
     setMode(indexMode: string): void;
     setTourUrl(options: {
@@ -92,6 +102,16 @@ export declare class ViewerService {
      * of the pipeline that already drives Matterport.
      */
     private addThreeJsTagFromPOI;
+    /**
+     * The image to draw a tag with, mirroring what Matterport shows for the same POI.
+     *
+     * Matterport registers one texture per type (`icon-ticket`, `icon-equipment`...) from the same
+     * config entries used here, and overrides it with the POI's own icon when it has one. Reading the
+     * same two sources is what keeps a tag looking like itself across the two viewers.
+     */
+    private resolveTagIconUrl;
+    /** The configured icon for a POI type, or null when that type has none. */
+    private defaultTagIconUrl;
     /** Moves the Three.js camera to frame a tag, mirroring Matterport's goToTag. */
     goToThreeJsTag(elementId: string): void;
     /** Shows only tags of the given POI types; null clears the filter. */
@@ -124,6 +144,11 @@ export declare class ViewerService {
     get threeJsModelLoadCancelled$(): Subject<void>;
     /** Stops the Three.js model download in progress. */
     cancelThreeJsModelLoad(): void;
+    /** Emits a tag's label while the pointer is over it in the Three.js scene. */
+    get threeJsTagHovered$(): Subject<{
+        label: string;
+        event: MouseEvent;
+    }>;
     /** Emits the element id of a tag clicked in the Three.js scene. */
     get threeJsTagClicked$(): Subject<import("./threejs.service").ThreeJsTagClick>;
     /**
@@ -161,8 +186,21 @@ export declare class ViewerService {
      * a tag created here show up in the right place there - and the other way round.
      */
     private commitThreeJsTagPlacement;
+    /**
+     * Creates the POI for an element just placed in the Three.js scene.
+     *
+     * The Matterport path reaches the same result through its tag dictionary - the tag exists first
+     * and carries the coordinates. Three.js has no such object, so the placement captured at click
+     * time is the only record of where the user pointed, and it has to become a POI here or it is
+     * lost when the form closes.
+     *
+     * Returns null when there is no pending placement, which is the normal case in Matterport mode.
+     */
+    createPoiForThreeJsPlacement(element: DbObjectType, poiType: PoiType): Promise<POI | null>;
     /** Emits when a tag is dropped on the model in the Three.js scene. */
     get threeJsTagPlaced$(): Subject<import("./threejs.service").ThreeJsTagPlacement>;
+    /** Emits when the calibration walkthrough is abandoned, including via Escape. */
+    get threeJsAlignmentCancelled$(): Subject<void>;
     /** Leaves Three.js tag placement mode without placing anything. */
     cancelThreeJsTagPlacement(): void;
     editOnlyTagStyleForPoi(poi: POI, object: DbObjectType): void;

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

@@ -8,6 +8,15 @@ import * as i0 from "@angular/core";
 export declare class ZoneChangeService {
     zoneChange: Subject<Zone | null>;
     zonesForUserChange: Subject<Zone[] | null>;
+    /**
+     * Emits the space opened by a viewer that has no zone navigation (Three.js), or null when it
+     * closes.
+     *
+     * Zones are defined by the sweeps they contain, so they only mean something in a Matterport tour.
+     * A 3D model has no sweeps: it shows the whole space at once, and the services that load data
+     * listen here instead of to `zoneChange` to know which space they are looking at.
+     */
+    spaceWithoutZones: Subject<string | null>;
     private currentZone;
     private currentZones;
     floorHasChanged: EventEmitter<Zone>;

package/lib/types.service.d.ts

@@ -570,6 +570,14 @@ export type Space = {
     status?: SpaceStatus | null;
     guestLink?: string | null;
     signedImageUrl?: string | null;
+    /**
+     * The capture a visitor opens by default, of any viewer type.
+     *
+     * Kept on the space rather than as a flag on each capture: there is one field, so there can only
+     * be one answer, whichever screen set it. A flag per capture would let two of them claim the
+     * default and put the choice back where it started - undefined.
+     */
+    defaultCaptureID?: string | null;
     zones?: {
         __typename?: 'ModelZoneConnection';
         items?: Array<Zone | null> | null;

package/package.json

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