@smarterplan/ngx-smarterplan-core 1.4.20 → 1.4.22

package/esm2022/lib/components/splat-viewer/splat-viewer.component.mjs

@@ -0,0 +1,361 @@
+import { Component, EventEmitter, HostListener, Input, Output, ViewChild, } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import { getSignedFile } from '../../services/s3.service';
+import { VIEWER_BACKGROUND } from '../../services/threejs.service';
+import { isStreamedSplatFile } from '../../services/viewer.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/viewer.service";
+import * as i2 from "@angular/platform-browser";
+import * as i3 from "@ngx-translate/core";
+/**
+ * Gaussian splats, drawn by SuperSplat's viewer (PlayCanvas) in an iframe, as Matterport's showcase
+ * is: the page built from projects/splat-viewer, which each app serves from assets/viewers/splat.
+ *
+ * The visit's Three.js scene stays underneath, unseen, holding the tags, their calibration and the
+ * measurement, as it does for a model it draws itself; this hands the viewer what the scene holds,
+ * and turns what is clicked in it into what a click in the scene does - through ViewerService, so
+ * that whatever drives the scene (the add buttons, the calibration panel, the measuring tool, the
+ * tag lists) drives this as well. Tags clicked come out of ViewerService.threeJsTagClicked$, as
+ * clicks in the scene do.
+ *
+ * What it says of loading is for the app's own loading overlay; see the outputs.
+ */
+export class SplatViewerComponent {
+    viewerService;
+    host;
+    sanitizer;
+    translate;
+    /** The model: the S3 key - or assets/ path - of a splat file, or of a Streamed SOG's lod-meta.json. */
+    modelKey = null;
+    /** Which of the model's axes is up, from its capture's placement; null for the viewer's own idea. */
+    up = null;
+    /** How far loading has got, from 0 to 1, or null when the size is not known. 0 when it starts. */
+    loadProgress = new EventEmitter();
+    loaded = new EventEmitter();
+    loadFailed = new EventEmitter();
+    /** Said whenever the mode changes, the viewer's own buttons included. */
+    modeChange = new EventEmitter();
+    frame;
+    /**
+     * The viewer's page, made once, in ngOnInit: a new object, even for the same address, would make
+     * Angular set the iframe's src again, which loads the viewer afresh with nothing in it.
+     */
+    page;
+    /** Whether the page has said it is ready; it says so again each time it starts over. */
+    ready = false;
+    /** The model handed to the page, so the same one is not downloaded twice. */
+    loadedKey = null;
+    /** Set by cancelLoad: the page, starting over empty, waits to be asked again (reload). */
+    cancelled = false;
+    /** Whether the page was last asked to take a click for a calibration. */
+    pickingForCalibration = false;
+    /** The calibration under way, as ViewerService last said. */
+    alignment = null;
+    /** Each segment's length of the measurement on the model, as ViewerService last said. */
+    measureDistances = [];
+    /** The last lod-meta.json handed to the page, as a link of this page's own. */
+    streamedMeta = null;
+    /** Pictures asked of the page, by the number they were asked with, until it answers. */
+    snapshots = new Map();
+    snapshotCount = 0;
+    destroyed$ = new Subject();
+    constructor(viewerService, host, sanitizer, translate) {
+        this.viewerService = viewerService;
+        this.host = host;
+        this.sanitizer = sanitizer;
+        this.translate = translate;
+    }
+    ngOnInit() {
+        // In the app's language, which the viewer's controls speak, and in its colours, as this element's
+        // styles take them from the app's - by now in the page, where they reach it.
+        const style = getComputedStyle(this.host.nativeElement);
+        const query = new URLSearchParams({
+            lang: this.translate.currentLang || 'en',
+            accent: style.color,
+            background: style.backgroundColor,
+        });
+        this.page = this.sanitizer.bypassSecurityTrustResourceUrl(`assets/viewers/splat/index.html?${query}`);
+        // The Three.js scene underneath has nothing to draw while this covers it, and the splat viewer
+        // needs all the graphics card there is.
+        this.viewerService.setThreeJsRenderingPaused(true);
+        const on = (source, next) => source.pipe(takeUntil(this.destroyed$)).subscribe(next);
+        on(this.viewerService.threeJsTagsChanged$, () => this.postTags());
+        // Placing a tag starts from the add buttons, the same in every viewer; the page picks the spot
+        // and says where ('picked').
+        on(this.viewerService.threeJsPlacementChanged$, (placing) => this.post({ type: 'placing', on: placing }));
+        on(this.viewerService.threeJsAlignmentProgress$, (progress) => {
+            this.alignment = progress;
+            this.postCalibration();
+        });
+        on(this.viewerService.threeJsAlignmentCancelled$, () => {
+            this.alignment = null;
+            this.postCalibration();
+        });
+        on(this.viewerService.threeJsMeasuringChanged$, (measuring) => this.post({ type: 'measuring', on: measuring }));
+        on(this.viewerService.threeJsMeasurementProgress$, (progress) => {
+            this.measureDistances = progress?.distances ?? [];
+            this.postMeasurement(!!progress);
+        });
+        // A finished measurement stays drawn while its form is open; this is when it goes.
+        on(this.viewerService.threeJsMeasurementCleared$, () => {
+            this.measureDistances = [];
+            this.postMeasurement(false);
+        });
+        // The camera sent to a tag, from a list: the page points it out.
+        on(this.viewerService.threeJsTagFocused$, (id) => this.post({ type: 'goToTag', id }));
+    }
+    ngOnChanges(changes) {
+        if (changes['modelKey'] && this.ready && !this.cancelled) {
+            void this.load();
+        }
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+        this.destroyed$.complete();
+        this.viewerService.setThreeJsRenderingPaused(false);
+        if (this.streamedMeta) {
+            URL.revokeObjectURL(this.streamedMeta);
+        }
+        this.snapshots.forEach((resolve) => resolve(null));
+        this.snapshots.clear();
+    }
+    /** Stops the model loading; nothing is loaded again until reload(). */
+    cancelLoad() {
+        this.cancelled = true;
+        this.loadedKey = null;
+        this.post({ type: 'cancel-load' });
+    }
+    /** Loads the model again, after cancelLoad. */
+    reload() {
+        this.cancelled = false;
+        this.loadedKey = null;
+        if (this.ready) {
+            void this.load();
+        }
+    }
+    setMode(mode) {
+        this.post({ type: 'mode', mode });
+    }
+    /**
+     * The scene as it is on screen, with the measurement drawn on it and no tags, as a JPEG data URL;
+     * null when there is no scene to take, or the page does not answer within ten seconds.
+     */
+    snapshot() {
+        const id = ++this.snapshotCount;
+        return new Promise((resolve) => {
+            this.snapshots.set(id, resolve);
+            this.post({ type: 'snapshot', id });
+            setTimeout(() => {
+                if (this.snapshots.delete(id)) {
+                    resolve(null);
+                }
+            }, 10000);
+        });
+    }
+    /** What the page says: that it is ready, how loading goes, what was clicked in it. */
+    onMessage(event) {
+        // Only this component's page, served from this same origin.
+        if (event.source !== this.frame?.nativeElement.contentWindow || event.origin !== window.location.origin) {
+            return;
+        }
+        const message = event.data;
+        const aligning = this.viewerService.isThreeJsAligningTags();
+        switch (message?.type) {
+            case 'ready':
+                // A new page, with nothing loaded or armed in it: the first, or the viewer starting over
+                // for the next model or after a cancelled load.
+                this.ready = true;
+                this.loadedKey = null;
+                this.pickingForCalibration = false;
+                if (!this.cancelled) {
+                    void this.load();
+                }
+                this.postTags();
+                this.postCalibration();
+                this.post({ type: 'measuring', on: this.viewerService.isThreeJsMeasuring() });
+                this.postMeasurement(this.viewerService.getThreeJsMeasurePointsInModelFrame().length > 0);
+                break;
+            case 'progress':
+                this.loadProgress.emit(message.fraction ?? null);
+                break;
+            case 'loaded':
+                this.loaded.emit();
+                break;
+            case 'error':
+                console.error('Splat viewer:', message.message);
+                this.loadFailed.emit(String(message.message ?? ''));
+                break;
+            case 'mode':
+                this.modeChange.emit(message.mode);
+                break;
+            case 'picked':
+                if (aligning && this.alignment?.awaiting === 'point') {
+                    // Where the tag being matched really is, as a click on the model in the scene would say.
+                    if (!this.viewerService.matchThreeJsAlignmentTagAtModelPoint(message.position)) {
+                        this.viewerService.ignoreThreeJsAlignmentClick('point');
+                    }
+                    break;
+                }
+                // As a click on the model in the scene: the app opens the creation form from threeJsTagPlaced$.
+                this.viewerService.placeThreeJsTagAtModelPoint(message.position, message.normal ?? null);
+                break;
+            case 'placing-cancelled':
+                // Escape, as in the scene: it ends a measurement or a calibration as it ends placing a tag.
+                if (this.viewerService.isThreeJsMeasuring()) {
+                    this.viewerService.action_toolbox_cancel_mesure();
+                }
+                else if (aligning) {
+                    this.viewerService.cancelThreeJsTagAlignment();
+                }
+                else {
+                    this.viewerService.cancelThreeJsTagPlacement();
+                }
+                break;
+            case 'calibration-undo':
+                // Ctrl+Z or Backspace in the page, as in the scene.
+                this.viewerService.undoThreeJsAlignmentStep();
+                break;
+            case 'measure-point':
+                this.viewerService.addThreeJsMeasurePointAtModelPoint(message.position);
+                break;
+            case 'tagClick':
+                if (aligning) {
+                    // Calibrating: a tag clicked is the one to match, as in the scene, and opens nothing.
+                    if (this.alignment?.awaiting !== 'tag' || !this.viewerService.selectThreeJsAlignmentTag(message.id)) {
+                        this.viewerService.ignoreThreeJsAlignmentClick('tag');
+                    }
+                    break;
+                }
+                this.viewerService.clickThreeJsTag(message.id);
+                break;
+            case 'snapshot':
+                this.snapshots.get(message.id)?.(message.image ?? null);
+                this.snapshots.delete(message.id);
+                break;
+            case 'sign': {
+                // A piece of the Streamed SOG open, by its name beside lod-meta.json.
+                const key = this.loadedKey;
+                const folder = key ? key.slice(0, key.lastIndexOf('/') + 1) : '';
+                const file = String(message.file ?? '');
+                const allowed = key && isStreamedSplatFile(key) && /^[\w.-]+$/.test(file);
+                (allowed ? getSignedFile(folder + file) : Promise.resolve(null)).then((url) => {
+                    this.post({ type: 'signed', id: message.id, url });
+                });
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    async load() {
+        const key = this.modelKey;
+        if (!key || key === this.loadedKey) {
+            return;
+        }
+        this.loadedKey = key;
+        this.loadProgress.emit(0);
+        let url = key.startsWith('assets/') ? key : await getSignedFile(key);
+        if (url && isStreamedSplatFile(key)) {
+            url = await this.streamedEntry(url);
+        }
+        if (this.loadedKey !== key) {
+            // Another model was asked for, or the load cancelled, while the link was being signed.
+            return;
+        }
+        this.post({ type: 'load', url, fileName: key.split('/').pop(), up: this.up });
+    }
+    /**
+     * The lod-meta.json of a Streamed SOG, with its pieces named so that the page asks for each of
+     * them when it needs it ('sign').
+     *
+     * The pieces sit beside lod-meta.json in S3 and are named relative to it, which a signed link -
+     * its signature in the query - does not survive. And they are fetched while the visit lasts, as the
+     * camera reaches them, long after any link signed up front has run out.
+     */
+    async streamedEntry(signedMeta) {
+        const meta = await (await fetch(signedMeta)).json();
+        meta.filenames = (meta.filenames ?? []).map((name) => `https://splat.invalid/${name}`);
+        if (this.streamedMeta) {
+            URL.revokeObjectURL(this.streamedMeta);
+        }
+        this.streamedMeta = URL.createObjectURL(new Blob([JSON.stringify(meta)], { type: 'application/json' }));
+        return this.streamedMeta;
+    }
+    postTags() {
+        const { tags, alignment } = this.viewerService.getThreeJsTagSnapshot();
+        // Tags placed elsewhere - in Matterport, in another model - are in that place's coordinates,
+        // and only a calibration says where they are in this one. Without it they float off the model
+        // and seem to slide as the camera moves: they are left out until it is calibrated. A
+        // calibration under way, or its panel open, shows them all: they are what it matches.
+        const all = this.viewerService.isThreeJsCalibrated() || this.viewerService.isThreeJsShowingCalibrationTags();
+        const shown = all ? tags : tags.filter((tag) => tag.inModelFrame);
+        this.post({
+            type: 'tags',
+            tags: shown.map(({ id, position, label, iconUrl, inModelFrame, normal }) => ({ id, position, label, iconUrl, inModelFrame, normal })),
+            alignment,
+        });
+    }
+    /**
+     * The calibration under way, for the page to draw - the pins dropped, the tag being matched - and,
+     * while the place of a tag is asked for, to take the click on the model that says where ('picked').
+     */
+    postCalibration() {
+        const on = this.viewerService.isThreeJsAligningTags() && !!this.alignment;
+        const awaiting = on ? this.alignment.awaiting : null;
+        this.post({
+            type: 'calibration',
+            calibration: on
+                ? {
+                    selected: awaiting === 'point' ? this.alignment.tagId ?? null : null,
+                    pairs: this.alignment.matched.map(({ tagId, target }) => ({ tagId, target })),
+                }
+                : null,
+        });
+        const picking = awaiting === 'point';
+        // Only when it changes: placing a tag uses the same click, and is not to be switched off here.
+        if (picking !== this.pickingForCalibration) {
+            this.pickingForCalibration = picking;
+            this.post({ type: 'placing', on: picking });
+        }
+    }
+    /** The measurement for the page to draw - its points, each segment's length - or nothing. */
+    postMeasurement(drawn) {
+        this.post({
+            type: 'measurement',
+            measurement: drawn
+                ? { points: this.viewerService.getThreeJsMeasurePointsInModelFrame(), distances: this.measureDistances }
+                : null,
+        });
+    }
+    post(command) {
+        const page = this.frame?.nativeElement.contentWindow;
+        if (page && this.ready) {
+            page.postMessage(command, window.location.origin);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SplatViewerComponent, deps: [{ token: i1.ViewerService }, { token: i0.ElementRef }, { token: i2.DomSanitizer }, { token: i3.TranslateService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: SplatViewerComponent, selector: "lib-splat-viewer", inputs: { modelKey: "modelKey", up: "up" }, outputs: { loadProgress: "loadProgress", loaded: "loaded", loadFailed: "loadFailed", modeChange: "modeChange" }, host: { listeners: { "window:message": "onMessage($event)" } }, viewQueries: [{ propertyName: "frame", first: true, predicate: ["frame"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: '<iframe #frame [src]="page" title="3D" allow="fullscreen; xr-spatial-tracking" allowfullscreen></iframe>', isInline: true, styles: [":host{display:block;color:var(--smarterplan-primary, rgb(83, 182, 187));background-color:var(--smarterplan-viewer-background, #e0f7ff)}iframe{display:block;width:100%;height:100%;border:0}\n"] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SplatViewerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-splat-viewer', template: '<iframe #frame [src]="page" title="3D" allow="fullscreen; xr-spatial-tracking" allowfullscreen></iframe>', styles: [":host{display:block;color:var(--smarterplan-primary, rgb(83, 182, 187));background-color:var(--smarterplan-viewer-background, #e0f7ff)}iframe{display:block;width:100%;height:100%;border:0}\n"] }]
+        }], ctorParameters: () => [{ type: i1.ViewerService }, { type: i0.ElementRef }, { type: i2.DomSanitizer }, { type: i3.TranslateService }], propDecorators: { modelKey: [{
+                type: Input
+            }], up: [{
+                type: Input
+            }], loadProgress: [{
+                type: Output
+            }], loaded: [{
+                type: Output
+            }], loadFailed: [{
+                type: Output
+            }], modeChange: [{
+                type: Output
+            }], frame: [{
+                type: ViewChild,
+                args: ['frame', { static: true }]
+            }], onMessage: [{
+                type: HostListener,
+                args: ['window:message', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"splat-viewer.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-smarterplan-core/src/lib/components/splat-viewer/splat-viewer.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component, ElementRef, EventEmitter, HostListener, Input, OnChanges, OnDestroy, OnInit, Output, SimpleChanges, ViewChild,\n} from '@angular/core';\nimport { DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';\nimport { TranslateService } from '@ngx-translate/core';\nimport { Subject, takeUntil } from 'rxjs';\nimport { ThreeJsModelUp } from '../../helpers.service';\nimport { getSignedFile } from '../../services/s3.service';\nimport { ThreeJsAlignmentProgress, VIEWER_BACKGROUND } from '../../services/threejs.service';\nimport { isStreamedSplatFile, ViewerService } from '../../services/viewer.service';\n\n/** How the splat viewer is moved through: around the model, or inside it. */\nexport type SplatViewerMode = 'orbit' | 'walk';\n\n/**\n * Gaussian splats, drawn by SuperSplat's viewer (PlayCanvas) in an iframe, as Matterport's showcase\n * is: the page built from projects/splat-viewer, which each app serves from assets/viewers/splat.\n *\n * The visit's Three.js scene stays underneath, unseen, holding the tags, their calibration and the\n * measurement, as it does for a model it draws itself; this hands the viewer what the scene holds,\n * and turns what is clicked in it into what a click in the scene does - through ViewerService, so\n * that whatever drives the scene (the add buttons, the calibration panel, the measuring tool, the\n * tag lists) drives this as well. Tags clicked come out of ViewerService.threeJsTagClicked$, as\n * clicks in the scene do.\n *\n * What it says of loading is for the app's own loading overlay; see the outputs.\n */\n@Component({\n  selector: 'lib-splat-viewer',\n  template: '<iframe #frame [src]=\"page\" title=\"3D\" allow=\"fullscreen; xr-spatial-tracking\" allowfullscreen></iframe>',\n  // The app's colours, which the page is opened with (see ngOnInit): color is its primary, for the\n  // viewer's controls, and background-color the 3D viewers' background, the Three.js scene's too.\n  styles: [`\n    :host {\n      display: block;\n      color: var(--smarterplan-primary, rgb(83, 182, 187));\n      background-color: var(--smarterplan-viewer-background, ${VIEWER_BACKGROUND});\n    }\n    iframe { display: block; width: 100%; height: 100%; border: 0; }\n  `],\n})\nexport class SplatViewerComponent implements OnInit, OnChanges, OnDestroy {\n  /** The model: the S3 key - or assets/ path - of a splat file, or of a Streamed SOG's lod-meta.json. */\n  @Input() modelKey: string | null = null;\n\n  /** Which of the model's axes is up, from its capture's placement; null for the viewer's own idea. */\n  @Input() up: ThreeJsModelUp | null = null;\n\n  /** How far loading has got, from 0 to 1, or null when the size is not known. 0 when it starts. */\n  @Output() loadProgress = new EventEmitter<number | null>();\n\n  @Output() loaded = new EventEmitter<void>();\n\n  @Output() loadFailed = new EventEmitter<string>();\n\n  /** Said whenever the mode changes, the viewer's own buttons included. */\n  @Output() modeChange = new EventEmitter<SplatViewerMode>();\n\n  @ViewChild('frame', { static: true }) frame!: ElementRef<HTMLIFrameElement>;\n\n  /**\n   * The viewer's page, made once, in ngOnInit: a new object, even for the same address, would make\n   * Angular set the iframe's src again, which loads the viewer afresh with nothing in it.\n   */\n  page!: SafeResourceUrl;\n\n  /** Whether the page has said it is ready; it says so again each time it starts over. */\n  private ready = false;\n\n  /** The model handed to the page, so the same one is not downloaded twice. */\n  private loadedKey: string | null = null;\n\n  /** Set by cancelLoad: the page, starting over empty, waits to be asked again (reload). */\n  private cancelled = false;\n\n  /** Whether the page was last asked to take a click for a calibration. */\n  private pickingForCalibration = false;\n\n  /** The calibration under way, as ViewerService last said. */\n  private alignment: ThreeJsAlignmentProgress | null = null;\n\n  /** Each segment's length of the measurement on the model, as ViewerService last said. */\n  private measureDistances: number[] = [];\n\n  /** The last lod-meta.json handed to the page, as a link of this page's own. */\n  private streamedMeta: string | null = null;\n\n  /** Pictures asked of the page, by the number they were asked with, until it answers. */\n  private snapshots = new Map<number, (image: string | null) => void>();\n\n  private snapshotCount = 0;\n\n  private destroyed$ = new Subject<void>();\n\n  constructor(\n    private viewerService: ViewerService,\n    private host: ElementRef<HTMLElement>,\n    private sanitizer: DomSanitizer,\n    private translate: TranslateService,\n  ) {}\n\n  ngOnInit(): void {\n    // In the app's language, which the viewer's controls speak, and in its colours, as this element's\n    // styles take them from the app's - by now in the page, where they reach it.\n    const style = getComputedStyle(this.host.nativeElement);\n    const query = new URLSearchParams({\n      lang: this.translate.currentLang || 'en',\n      accent: style.color,\n      background: style.backgroundColor,\n    });\n    this.page = this.sanitizer.bypassSecurityTrustResourceUrl(`assets/viewers/splat/index.html?${query}`);\n\n    // The Three.js scene underneath has nothing to draw while this covers it, and the splat viewer\n    // needs all the graphics card there is.\n    this.viewerService.setThreeJsRenderingPaused(true);\n    const on = <T>(source: { pipe: Function }, next: (value: T) => void) =>\n      (source.pipe(takeUntil(this.destroyed$)) as any).subscribe(next);\n\n    on(this.viewerService.threeJsTagsChanged$, () => this.postTags());\n    // Placing a tag starts from the add buttons, the same in every viewer; the page picks the spot\n    // and says where ('picked').\n    on<boolean>(this.viewerService.threeJsPlacementChanged$, (placing) => this.post({ type: 'placing', on: placing }));\n    on<ThreeJsAlignmentProgress>(this.viewerService.threeJsAlignmentProgress$, (progress) => {\n      this.alignment = progress;\n      this.postCalibration();\n    });\n    on(this.viewerService.threeJsAlignmentCancelled$, () => {\n      this.alignment = null;\n      this.postCalibration();\n    });\n    on<boolean>(this.viewerService.threeJsMeasuringChanged$, (measuring) => this.post({ type: 'measuring', on: measuring }));\n    on<{ points: number; distances: number[] } | null>(this.viewerService.threeJsMeasurementProgress$, (progress) => {\n      this.measureDistances = progress?.distances ?? [];\n      this.postMeasurement(!!progress);\n    });\n    // A finished measurement stays drawn while its form is open; this is when it goes.\n    on(this.viewerService.threeJsMeasurementCleared$, () => {\n      this.measureDistances = [];\n      this.postMeasurement(false);\n    });\n    // The camera sent to a tag, from a list: the page points it out.\n    on<string>(this.viewerService.threeJsTagFocused$, (id) => this.post({ type: 'goToTag', id }));\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['modelKey'] && this.ready && !this.cancelled) {\n      void this.load();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.destroyed$.next();\n    this.destroyed$.complete();\n    this.viewerService.setThreeJsRenderingPaused(false);\n    if (this.streamedMeta) {\n      URL.revokeObjectURL(this.streamedMeta);\n    }\n    this.snapshots.forEach((resolve) => resolve(null));\n    this.snapshots.clear();\n  }\n\n  /** Stops the model loading; nothing is loaded again until reload(). */\n  cancelLoad(): void {\n    this.cancelled = true;\n    this.loadedKey = null;\n    this.post({ type: 'cancel-load' });\n  }\n\n  /** Loads the model again, after cancelLoad. */\n  reload(): void {\n    this.cancelled = false;\n    this.loadedKey = null;\n    if (this.ready) {\n      void this.load();\n    }\n  }\n\n  setMode(mode: SplatViewerMode): void {\n    this.post({ type: 'mode', mode });\n  }\n\n  /**\n   * The scene as it is on screen, with the measurement drawn on it and no tags, as a JPEG data URL;\n   * null when there is no scene to take, or the page does not answer within ten seconds.\n   */\n  snapshot(): Promise<string | null> {\n    const id = ++this.snapshotCount;\n    return new Promise((resolve) => {\n      this.snapshots.set(id, resolve);\n      this.post({ type: 'snapshot', id });\n      setTimeout(() => {\n        if (this.snapshots.delete(id)) {\n          resolve(null);\n        }\n      }, 10000);\n    });\n  }\n\n  /** What the page says: that it is ready, how loading goes, what was clicked in it. */\n  @HostListener('window:message', ['$event'])\n  onMessage(event: MessageEvent): void {\n    // Only this component's page, served from this same origin.\n    if (event.source !== this.frame?.nativeElement.contentWindow || event.origin !== window.location.origin) {\n      return;\n    }\n    const message = event.data;\n    const aligning = this.viewerService.isThreeJsAligningTags();\n    switch (message?.type) {\n      case 'ready':\n        // A new page, with nothing loaded or armed in it: the first, or the viewer starting over\n        // for the next model or after a cancelled load.\n        this.ready = true;\n        this.loadedKey = null;\n        this.pickingForCalibration = false;\n        if (!this.cancelled) {\n          void this.load();\n        }\n        this.postTags();\n        this.postCalibration();\n        this.post({ type: 'measuring', on: this.viewerService.isThreeJsMeasuring() });\n        this.postMeasurement(this.viewerService.getThreeJsMeasurePointsInModelFrame().length > 0);\n        break;\n      case 'progress':\n        this.loadProgress.emit(message.fraction ?? null);\n        break;\n      case 'loaded':\n        this.loaded.emit();\n        break;\n      case 'error':\n        console.error('Splat viewer:', message.message);\n        this.loadFailed.emit(String(message.message ?? ''));\n        break;\n      case 'mode':\n        this.modeChange.emit(message.mode);\n        break;\n      case 'picked':\n        if (aligning && this.alignment?.awaiting === 'point') {\n          // Where the tag being matched really is, as a click on the model in the scene would say.\n          if (!this.viewerService.matchThreeJsAlignmentTagAtModelPoint(message.position)) {\n            this.viewerService.ignoreThreeJsAlignmentClick('point');\n          }\n          break;\n        }\n        // As a click on the model in the scene: the app opens the creation form from threeJsTagPlaced$.\n        this.viewerService.placeThreeJsTagAtModelPoint(message.position, message.normal ?? null);\n        break;\n      case 'placing-cancelled':\n        // Escape, as in the scene: it ends a measurement or a calibration as it ends placing a tag.\n        if (this.viewerService.isThreeJsMeasuring()) {\n          this.viewerService.action_toolbox_cancel_mesure();\n        } else if (aligning) {\n          this.viewerService.cancelThreeJsTagAlignment();\n        } else {\n          this.viewerService.cancelThreeJsTagPlacement();\n        }\n        break;\n      case 'calibration-undo':\n        // Ctrl+Z or Backspace in the page, as in the scene.\n        this.viewerService.undoThreeJsAlignmentStep();\n        break;\n      case 'measure-point':\n        this.viewerService.addThreeJsMeasurePointAtModelPoint(message.position);\n        break;\n      case 'tagClick':\n        if (aligning) {\n          // Calibrating: a tag clicked is the one to match, as in the scene, and opens nothing.\n          if (this.alignment?.awaiting !== 'tag' || !this.viewerService.selectThreeJsAlignmentTag(message.id)) {\n            this.viewerService.ignoreThreeJsAlignmentClick('tag');\n          }\n          break;\n        }\n        this.viewerService.clickThreeJsTag(message.id);\n        break;\n      case 'snapshot':\n        this.snapshots.get(message.id)?.(message.image ?? null);\n        this.snapshots.delete(message.id);\n        break;\n      case 'sign': {\n        // A piece of the Streamed SOG open, by its name beside lod-meta.json.\n        const key = this.loadedKey;\n        const folder = key ? key.slice(0, key.lastIndexOf('/') + 1) : '';\n        const file = String(message.file ?? '');\n        const allowed = key && isStreamedSplatFile(key) && /^[\\w.-]+$/.test(file);\n        (allowed ? getSignedFile(folder + file) : Promise.resolve(null)).then((url) => {\n          this.post({ type: 'signed', id: message.id, url });\n        });\n        break;\n      }\n      default:\n        break;\n    }\n  }\n\n  private async load(): Promise<void> {\n    const key = this.modelKey;\n    if (!key || key === this.loadedKey) {\n      return;\n    }\n    this.loadedKey = key;\n    this.loadProgress.emit(0);\n    let url = key.startsWith('assets/') ? key : await getSignedFile(key);\n    if (url && isStreamedSplatFile(key)) {\n      url = await this.streamedEntry(url);\n    }\n    if (this.loadedKey !== key) {\n      // Another model was asked for, or the load cancelled, while the link was being signed.\n      return;\n    }\n    this.post({ type: 'load', url, fileName: key.split('/').pop(), up: this.up });\n  }\n\n  /**\n   * The lod-meta.json of a Streamed SOG, with its pieces named so that the page asks for each of\n   * them when it needs it ('sign').\n   *\n   * The pieces sit beside lod-meta.json in S3 and are named relative to it, which a signed link -\n   * its signature in the query - does not survive. And they are fetched while the visit lasts, as the\n   * camera reaches them, long after any link signed up front has run out.\n   */\n  private async streamedEntry(signedMeta: string): Promise<string> {\n    const meta = await (await fetch(signedMeta)).json();\n    meta.filenames = (meta.filenames ?? []).map((name: string) => `https://splat.invalid/${name}`);\n    if (this.streamedMeta) {\n      URL.revokeObjectURL(this.streamedMeta);\n    }\n    this.streamedMeta = URL.createObjectURL(new Blob([JSON.stringify(meta)], { type: 'application/json' }));\n    return this.streamedMeta;\n  }\n\n  private postTags(): void {\n    const { tags, alignment } = this.viewerService.getThreeJsTagSnapshot();\n    // Tags placed elsewhere - in Matterport, in another model - are in that place's coordinates,\n    // and only a calibration says where they are in this one. Without it they float off the model\n    // and seem to slide as the camera moves: they are left out until it is calibrated. A\n    // calibration under way, or its panel open, shows them all: they are what it matches.\n    const all = this.viewerService.isThreeJsCalibrated() || this.viewerService.isThreeJsShowingCalibrationTags();\n    const shown = all ? tags : tags.filter((tag) => tag.inModelFrame);\n    this.post({\n      type: 'tags',\n      tags: shown.map(({ id, position, label, iconUrl, inModelFrame, normal }) => ({ id, position, label, iconUrl, inModelFrame, normal })),\n      alignment,\n    });\n  }\n\n  /**\n   * The calibration under way, for the page to draw - the pins dropped, the tag being matched - and,\n   * while the place of a tag is asked for, to take the click on the model that says where ('picked').\n   */\n  private postCalibration(): void {\n    const on = this.viewerService.isThreeJsAligningTags() && !!this.alignment;\n    const awaiting = on ? this.alignment!.awaiting : null;\n    this.post({\n      type: 'calibration',\n      calibration: on\n        ? {\n          selected: awaiting === 'point' ? this.alignment!.tagId ?? null : null,\n          pairs: this.alignment!.matched.map(({ tagId, target }) => ({ tagId, target })),\n        }\n        : null,\n    });\n    const picking = awaiting === 'point';\n    // Only when it changes: placing a tag uses the same click, and is not to be switched off here.\n    if (picking !== this.pickingForCalibration) {\n      this.pickingForCalibration = picking;\n      this.post({ type: 'placing', on: picking });\n    }\n  }\n\n  /** The measurement for the page to draw - its points, each segment's length - or nothing. */\n  private postMeasurement(drawn: boolean): void {\n    this.post({\n      type: 'measurement',\n      measurement: drawn\n        ? { points: this.viewerService.getThreeJsMeasurePointsInModelFrame(), distances: this.measureDistances }\n        : null,\n    });\n  }\n\n  private post(command: object): void {\n    const page = this.frame?.nativeElement.contentWindow;\n    if (page && this.ready) {\n      page.postMessage(command, window.location.origin);\n    }\n  }\n}\n"]}