@colijnit/homedecorator 255.1.1

package/esm2015/app/development/service/development.service.js

@@ -0,0 +1,212 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as THREE from 'three';
+import { BoxGeometry, Mesh, MeshBasicMaterial, MeshPhongMaterial, Object3D, SphereGeometry, TextureLoader, Vector3 } from 'three';
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { CustomFloorItem } from '../../plugins/core3d/items/custom-floor-item';
+import { RelativePositionUtils } from '../../core/utils/relative-position.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../plugins/core3d/service/intersection.service";
+import * as i2 from "../../plugins/core3d/service/camera.service";
+import * as i3 from "../../plugins/core3d/service/rotation.service";
+import * as i4 from "../../plugins/core3d/service/scene-event.service";
+import * as i5 from "../../plugins/core3d/service/scene.service";
+import * as i6 from "../../plugins/threedselector/threedselector/service/variation.service";
+import * as i7 from "../../plugins/threedselector/threedselector/service/build-furniture.service";
+export var DevelopObjectState;
+(function (DevelopObjectState) {
+    DevelopObjectState[DevelopObjectState["NONE"] = 0] = "NONE";
+    DevelopObjectState[DevelopObjectState["ROTATE"] = 1] = "ROTATE";
+    DevelopObjectState[DevelopObjectState["MOVE"] = 2] = "MOVE";
+})(DevelopObjectState || (DevelopObjectState = {}));
+export class DevelopmentService {
+    constructor(_intersectionService, _cameraService, _rotationService, _sceneEventService, _sceneService, _variationService, _buildFurnitureService) {
+        this._intersectionService = _intersectionService;
+        this._cameraService = _cameraService;
+        this._rotationService = _rotationService;
+        this._sceneEventService = _sceneEventService;
+        this._sceneService = _sceneService;
+        this._variationService = _variationService;
+        this._buildFurnitureService = _buildFurnitureService;
+        this.objectLoaded = new BehaviorSubject(undefined);
+        this._objects = [];
+        this._state = DevelopObjectState.NONE;
+        this.handleMouseDown = (event) => {
+            this._state = DevelopObjectState.NONE;
+            if (event.buttons !== 1) {
+                return;
+            }
+            this._mousePos = RelativePositionUtils.GetClientMousePosition(event);
+            this._mousePosition = this._cameraService.mouseTo3DPosition(this._mousePos);
+            const intersections = this._getIntersections();
+            if (intersections && intersections.length > 0) {
+                event.preventDefault();
+                event.stopPropagation();
+                event.stopImmediatePropagation();
+                this._selectedObject = this._getParentObject(intersections[0].object);
+                this.objectLoaded.next(this._selectedObject);
+                if (event.buttons === 1) {
+                    this._state = DevelopObjectState.MOVE;
+                }
+                else if (event.buttons === 2) {
+                    this._state = DevelopObjectState.ROTATE;
+                }
+            }
+            else {
+                this._selectedObject = undefined;
+                this.objectLoaded.next(undefined);
+            }
+        };
+        this.handleMouseUp = (event) => {
+            this._reset();
+        };
+        this.handleMouseMove = (event) => {
+            if (this._state !== DevelopObjectState.NONE) {
+                event.preventDefault();
+                event.stopPropagation();
+                event.stopImmediatePropagation();
+                if (this._state === DevelopObjectState.MOVE) {
+                    const mousePos = RelativePositionUtils.GetClientMousePosition(event);
+                    // const mousePosition: Vector3 = this._cameraService.mouseTo3DPosition(this._mousePos);
+                    const vec3 = this._sceneEventService.intersectingVec3(mousePos);
+                    // const delta: Vector3 = mousePosition.sub(this._mousePosition);
+                    this._selectedObject.position.copy(vec3);
+                    // this._selectedObject.translateX(delta.x);
+                    // this._selectedObject.translateZ(delta.z);
+                }
+                else if (this._state === DevelopObjectState.ROTATE) {
+                    // @ts-ignore
+                    this._rotationService.enableRotationFor(this._selectedObject);
+                }
+                this._sceneService.needsRender = true;
+            }
+        };
+    }
+    ngOnDestroy() {
+        this._element.nativeElement.removeEventListener('mouseup', this.handleMouseUp);
+        this._element.nativeElement.removeEventListener('mousedown', this.handleMouseDown);
+        this._element.nativeElement.removeEventListener('mousemove', this.handleMouseMove);
+    }
+    init(element) {
+        if (element && element.nativeElement) {
+            this._element = element;
+            this._element.nativeElement.addEventListener('mouseup', this.handleMouseUp);
+            this._element.nativeElement.addEventListener('mousedown', this.handleMouseDown);
+            this._element.nativeElement.addEventListener('mousemove', this.handleMouseMove);
+        }
+    }
+    createResizableRoom() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const obj = new Object3D();
+            const objLeftWall = yield this._createWall('leftWall', 1, 2, 0.1, 'red');
+            this._addConnector(objLeftWall, { name: 'c_sca_x_m_001', connectedTo: 'topWall', color: 'grey', width: 0.1, x: -0.45, y: 0, z: 0.05 });
+            this._addConnector(objLeftWall, { name: 'c_sca_x_f_001', connectedTo: 'bottomWall', color: 'grey', width: 0.1, x: 0.45, y: 0, z: 0.05 });
+            // objLeftWall.rotation.y = 90 * (Math.PI / 180);
+            // objLeftWall.position.set(-1.05, 1, 0);
+            objLeftWall.position.set(0, 1, 0);
+            obj.add(objLeftWall);
+            // const objTopWall: Object3D = this._createWall('topWall', 2, 2, 0.1, 'blue');
+            // this._addConnector(objTopWall, {name: 'c_sca_x_m_002', connectedTo: 'rightWall', color: 'black', width: 0.1, x: -1, y: 0, z: 0});
+            // this._addConnector(objTopWall, {name: 'c_sca_x_f_002', connectedTo: 'leftWall', color: 'black', width: 0.1, x: 1, y: 0, z: 0});
+            // objTopWall.position.set(0, 1, -1.45);
+            // obj.add(objTopWall);
+            //
+            // const objRightWall: Object3D = this._createWall('rightWall', 3, 2, 0.1, 'yellow');
+            // this._addConnector(objRightWall, {name: 'c_sca_x_m_003', connectedTo: 'bottomWall', color: 'lightGreen', width: 0.1, x: -1.45, y: 0, z: 0.05});
+            // this._addConnector(objRightWall, {name: 'c_sca_x_f_003', connectedTo: 'topWall', color: 'lightGreen', width: 0.1, x: 1.45, y: 0, z: 0.05});
+            // objRightWall.rotation.y = -90 * (Math.PI / 180);
+            // objRightWall.position.set(1.05, 1, 0);
+            // obj.add(objRightWall);
+            //
+            // const objBottomWall: Object3D = this._createWall('bottomWall', 2, 2, 0.1, 'green');
+            // this._addConnector(objBottomWall, {name: 'c_sca_x_m_004', connectedTo: 'leftWall', color: 'lightBlue', width: 0.1, x: -1, y: 0, z: 0});
+            // this._addConnector(objBottomWall, {name: 'c_sca_x_f_004', connectedTo: 'rightWall', color: 'lightBlue', width: 0.1, x: 1, y: 0, z: 0});
+            // objBottomWall.position.set(0, 1, 1.45);
+            // obj.add(objBottomWall);
+            const customFloorObject = new CustomFloorItem({
+                position: new Vector3(),
+                itemIdentifier: 'customTestItem'
+            }, obj, {
+                elementSelected: this._buildFurnitureService.selectElement,
+                elementUnselected: this._buildFurnitureService.unSelectElement,
+                dragConnectorHandler: this._buildFurnitureService.dragConnector
+            });
+            customFloorObject.allwaysConfigureMode = true;
+            return customFloorObject;
+        });
+    }
+    addObject(obj) {
+        this._objects.push(obj);
+    }
+    applyMaterialToObject(id, file, object) {
+        return this._variationService.loadVariationFromLocalFile(id, file, object);
+    }
+    _createWall(name, width, height, depth, color) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = new Object3D();
+            const wallGeo = new BoxGeometry(width, height, depth);
+            const wallMaterial = new MeshPhongMaterial( /*{color: color, transparent: true, opacity: 0.4}*/);
+            wallMaterial.map = yield this._loadTextureMaterial('https://cdn1.colijn-it.nl/content43/UP_DBA15/variation/images/Plumb_wood1.jpg');
+            wallMaterial.needsUpdate = true;
+            const wallMesh = new Mesh(wallGeo, wallMaterial);
+            result.add(wallMesh);
+            result.name = name;
+            return result;
+        });
+    }
+    _loadTextureMaterial(url) {
+        return new Promise((resolve) => {
+            const loader = new TextureLoader();
+            loader.load(url, (texture) => {
+                resolve(texture);
+            });
+        });
+    }
+    _addConnector(obj, connectorOptions) {
+        const connector = new Mesh(new SphereGeometry(connectorOptions.width), new MeshBasicMaterial({ color: connectorOptions.color }));
+        connector.name = connectorOptions.name;
+        if (connectorOptions.connectedTo) {
+            connector.connected = true;
+            connector.connectedTo = connectorOptions.connectedTo;
+        }
+        connector.position.set(connectorOptions.x, connectorOptions.y, connectorOptions.z);
+        connector.visible = false;
+        obj.add(connector);
+    }
+    _getIntersections() {
+        try {
+            return this._intersectionService.getIntersections(this._mousePosition, this._objects);
+        }
+        catch (e) {
+            return [];
+        }
+    }
+    _reset() {
+        this._state = DevelopObjectState.NONE;
+    }
+    _getParentObject(obj) {
+        if (obj.parent instanceof THREE.Scene) {
+            return obj;
+        }
+        else {
+            return obj.parent ? this._getParentObject(obj.parent) : obj;
+        }
+    }
+}
+DevelopmentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DevelopmentService, deps: [{ token: i1.IntersectionService }, { token: i2.CameraService }, { token: i3.RotationService }, { token: i4.SceneEventService }, { token: i5.SceneService }, { token: i6.VariationService }, { token: i7.BuildFurnitureService }], target: i0.ɵɵFactoryTarget.Injectable });
+DevelopmentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DevelopmentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DevelopmentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.IntersectionService }, { type: i2.CameraService }, { type: i3.RotationService }, { type: i4.SceneEventService }, { type: i5.SceneService }, { type: i6.VariationService }, { type: i7.BuildFurnitureService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"development.service.js","sourceRoot":"","sources":["../../../../../../src/client/app/development/service/development.service.ts"],"names":[],"mappings":"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","sourcesContent":["import * as THREE from 'three';\r\nimport {\r\n  BoxGeometry,\r\n  Intersection,\r\n  Mesh,\r\n  MeshBasicMaterial,\r\n  MeshPhongMaterial,\r\n  Object3D,\r\n  PlaneGeometry,\r\n  SphereGeometry,\r\n  Texture,\r\n  TextureLoader,\r\n  Vector2,\r\n  Vector3\r\n} from 'three';\r\nimport {ElementRef, Injectable, OnDestroy} from '@angular/core';\r\nimport {BehaviorSubject} from 'rxjs';\r\nimport {IntersectionService} from '../../plugins/core3d/service/intersection.service';\r\nimport {CameraService} from '../../plugins/core3d/service/camera.service';\r\nimport {RotationService} from '../../plugins/core3d/service/rotation.service';\r\nimport {SceneEventService} from '../../plugins/core3d/service/scene-event.service';\r\nimport {SceneService} from '../../plugins/core3d/service/scene.service';\r\nimport {VariationService} from '../../plugins/threedselector/threedselector/service/variation.service';\r\nimport {BuildFurnitureService} from '../../plugins/threedselector/threedselector/service/build-furniture.service';\r\nimport {CustomFloorItem} from '../../plugins/core3d/items/custom-floor-item';\r\nimport {RelativePositionUtils} from '../../core/utils/relative-position.utils';\r\n\r\nexport enum DevelopObjectState {\r\n  NONE = 0,\r\n  ROTATE = 1,\r\n  MOVE = 2\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class DevelopmentService implements OnDestroy {\r\n\r\n  public objectLoaded: BehaviorSubject<Object3D> = new BehaviorSubject<Object3D>(undefined);\r\n\r\n  private _selectedObject: Object3D;\r\n  private _objects: any[] = [];\r\n  private _state: DevelopObjectState = DevelopObjectState.NONE;\r\n  private _mousePosition: Vector3;\r\n  private _element: ElementRef;\r\n  private _mousePos: Vector2;\r\n\r\n  constructor(\r\n    private _intersectionService: IntersectionService,\r\n    private _cameraService: CameraService,\r\n    private _rotationService: RotationService,\r\n    private _sceneEventService: SceneEventService,\r\n    private _sceneService: SceneService,\r\n    private _variationService: VariationService,\r\n    private _buildFurnitureService: BuildFurnitureService\r\n  ) {\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._element.nativeElement.removeEventListener('mouseup', this.handleMouseUp);\r\n    this._element.nativeElement.removeEventListener('mousedown', this.handleMouseDown);\r\n    this._element.nativeElement.removeEventListener('mousemove', this.handleMouseMove);\r\n  }\r\n\r\n  public init(element: ElementRef): void {\r\n    if (element && element.nativeElement) {\r\n      this._element = element;\r\n      this._element.nativeElement.addEventListener('mouseup', this.handleMouseUp);\r\n      this._element.nativeElement.addEventListener('mousedown', this.handleMouseDown);\r\n      this._element.nativeElement.addEventListener('mousemove', this.handleMouseMove);\r\n    }\r\n  }\r\n\r\n  public async createResizableRoom(): Promise<Object3D> {\r\n    const obj: Object3D = new Object3D();\r\n    const objLeftWall: Object3D = await this._createWall('leftWall', 1, 2, 0.1, 'red');\r\n    this._addConnector(objLeftWall, {name: 'c_sca_x_m_001', connectedTo: 'topWall', color: 'grey', width: 0.1, x: -0.45, y: 0, z: 0.05});\r\n    this._addConnector(objLeftWall, {name: 'c_sca_x_f_001', connectedTo: 'bottomWall', color: 'grey', width: 0.1, x: 0.45, y: 0, z: 0.05});\r\n    // objLeftWall.rotation.y = 90 * (Math.PI / 180);\r\n    // objLeftWall.position.set(-1.05, 1, 0);\r\n    objLeftWall.position.set(0, 1, 0);\r\n\r\n    obj.add(objLeftWall);\r\n\r\n    // const objTopWall: Object3D = this._createWall('topWall', 2, 2, 0.1, 'blue');\r\n    // this._addConnector(objTopWall, {name: 'c_sca_x_m_002', connectedTo: 'rightWall', color: 'black', width: 0.1, x: -1, y: 0, z: 0});\r\n    // this._addConnector(objTopWall, {name: 'c_sca_x_f_002', connectedTo: 'leftWall', color: 'black', width: 0.1, x: 1, y: 0, z: 0});\r\n    // objTopWall.position.set(0, 1, -1.45);\r\n    // obj.add(objTopWall);\r\n    //\r\n    // const objRightWall: Object3D = this._createWall('rightWall', 3, 2, 0.1, 'yellow');\r\n    // this._addConnector(objRightWall, {name: 'c_sca_x_m_003', connectedTo: 'bottomWall', color: 'lightGreen', width: 0.1, x: -1.45, y: 0, z: 0.05});\r\n    // this._addConnector(objRightWall, {name: 'c_sca_x_f_003', connectedTo: 'topWall', color: 'lightGreen', width: 0.1, x: 1.45, y: 0, z: 0.05});\r\n    // objRightWall.rotation.y = -90 * (Math.PI / 180);\r\n    // objRightWall.position.set(1.05, 1, 0);\r\n    // obj.add(objRightWall);\r\n    //\r\n    // const objBottomWall: Object3D = this._createWall('bottomWall', 2, 2, 0.1, 'green');\r\n    // this._addConnector(objBottomWall, {name: 'c_sca_x_m_004', connectedTo: 'leftWall', color: 'lightBlue', width: 0.1, x: -1, y: 0, z: 0});\r\n    // this._addConnector(objBottomWall, {name: 'c_sca_x_f_004', connectedTo: 'rightWall', color: 'lightBlue', width: 0.1, x: 1, y: 0, z: 0});\r\n    // objBottomWall.position.set(0, 1, 1.45);\r\n    // obj.add(objBottomWall);\r\n\r\n    const customFloorObject: CustomFloorItem = new CustomFloorItem(\r\n      {\r\n        position: new Vector3(),\r\n        itemIdentifier: 'customTestItem'\r\n      }, obj, {\r\n        elementSelected: this._buildFurnitureService.selectElement,\r\n        elementUnselected: this._buildFurnitureService.unSelectElement,\r\n        dragConnectorHandler: this._buildFurnitureService.dragConnector\r\n      });\r\n    customFloorObject.allwaysConfigureMode = true;\r\n    return customFloorObject;\r\n  }\r\n\r\n  public handleMouseDown = (event: MouseEvent) => {\r\n    this._state = DevelopObjectState.NONE;\r\n    if (event.buttons !== 1) {\r\n      return;\r\n    }\r\n    this._mousePos = RelativePositionUtils.GetClientMousePosition(event);\r\n    this._mousePosition = this._cameraService.mouseTo3DPosition(this._mousePos);\r\n    const intersections = this._getIntersections();\r\n    if (intersections && intersections.length > 0) {\r\n      event.preventDefault();\r\n      event.stopPropagation();\r\n      event.stopImmediatePropagation();\r\n      this._selectedObject = this._getParentObject(intersections[0].object);\r\n      this.objectLoaded.next(this._selectedObject);\r\n      if (event.buttons === 1) {\r\n        this._state = DevelopObjectState.MOVE;\r\n      } else if (event.buttons === 2) {\r\n        this._state = DevelopObjectState.ROTATE;\r\n      }\r\n    } else {\r\n      this._selectedObject = undefined;\r\n      this.objectLoaded.next(undefined);\r\n    }\r\n  }\r\n\r\n  public handleMouseUp = (event: MouseEvent) => {\r\n    this._reset();\r\n  }\r\n\r\n  public handleMouseMove = (event: MouseEvent) => {\r\n    if (this._state !== DevelopObjectState.NONE) {\r\n      event.preventDefault();\r\n      event.stopPropagation();\r\n      event.stopImmediatePropagation();\r\n      if (this._state === DevelopObjectState.MOVE) {\r\n        const mousePos: Vector2 = RelativePositionUtils.GetClientMousePosition(event);\r\n        // const mousePosition: Vector3 = this._cameraService.mouseTo3DPosition(this._mousePos);\r\n        const vec3: Vector3 = this._sceneEventService.intersectingVec3(mousePos);\r\n        // const delta: Vector3 = mousePosition.sub(this._mousePosition);\r\n        this._selectedObject.position.copy(vec3);\r\n        // this._selectedObject.translateX(delta.x);\r\n        // this._selectedObject.translateZ(delta.z);\r\n      } else if (this._state === DevelopObjectState.ROTATE) {\r\n        // @ts-ignore\r\n        this._rotationService.enableRotationFor(this._selectedObject);\r\n      }\r\n      this._sceneService.needsRender = true;\r\n    }\r\n  }\r\n\r\n  public addObject(obj: any): void {\r\n    this._objects.push(obj);\r\n  }\r\n\r\n  public applyMaterialToObject(id: string, file: any, object: Object3D): Promise<void> {\r\n    return this._variationService.loadVariationFromLocalFile(id, file, object);\r\n  }\r\n\r\n  private async _createWall(name: string, width: number, height: number, depth: number, color: string): Promise<Object3D> {\r\n    const result: Object3D = new Object3D();\r\n    const wallGeo: PlaneGeometry = new BoxGeometry(width, height, depth);\r\n    const wallMaterial: MeshPhongMaterial = new MeshPhongMaterial(/*{color: color, transparent: true, opacity: 0.4}*/);\r\n    wallMaterial.map = await this._loadTextureMaterial('https://cdn1.colijn-it.nl/content43/UP_DBA15/variation/images/Plumb_wood1.jpg');\r\n    wallMaterial.needsUpdate = true;\r\n    const wallMesh: Mesh = new Mesh(wallGeo, wallMaterial);\r\n    result.add(wallMesh);\r\n    result.name = name;\r\n    return result;\r\n  }\r\n\r\n  private _loadTextureMaterial(url: string): Promise<Texture> {\r\n    return new Promise((resolve: Function) => {\r\n      const loader: TextureLoader = new TextureLoader();\r\n      loader.load(url, (texture) => {\r\n        resolve(texture);\r\n      })\r\n    });\r\n  }\r\n\r\n  private _addConnector(obj: Object3D, connectorOptions: any): void {\r\n    const connector: Mesh = new Mesh(new SphereGeometry(connectorOptions.width), new MeshBasicMaterial({color: connectorOptions.color}));\r\n    connector.name = connectorOptions.name;\r\n    if (connectorOptions.connectedTo) {\r\n      (connector as any).connected = true;\r\n      (connector as any).connectedTo = connectorOptions.connectedTo;\r\n    }\r\n    connector.position.set(connectorOptions.x, connectorOptions.y, connectorOptions.z);\r\n    connector.visible = false;\r\n    obj.add(connector);\r\n  }\r\n\r\n  private _getIntersections(): Intersection[] {\r\n    try {\r\n      return this._intersectionService.getIntersections(this._mousePosition, this._objects);\r\n    } catch (e) {\r\n      return [];\r\n    }\r\n  }\r\n\r\n  private _reset(): void {\r\n    this._state = DevelopObjectState.NONE;\r\n  }\r\n\r\n  private _getParentObject(obj: any): Object3D {\r\n    if (obj.parent instanceof THREE.Scene) {\r\n      return obj;\r\n    } else {\r\n      return obj.parent ? this._getParentObject(obj.parent) : obj;\r\n    }\r\n  }\r\n\r\n}\r\n"]}

package/esm2015/app/homedecorator.component.js

@@ -0,0 +1,285 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Component, HostBinding, HostListener, Input, ViewEncapsulation } from '@angular/core';
+import { MessageType } from './core/enum/message-type.enum';
+import { Preset } from './core/model/preset';
+import * as i0 from "@angular/core";
+import * as i1 from "./core/service/homedecorator-connector.service";
+import * as i2 from "./core/service/app-state.service";
+import * as i3 from "./core/service/presets.service";
+import * as i4 from "./shared/screen-size-analysis/screen-size-analysis.service";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/platform-browser";
+import * as i7 from "./core/service/message-bus.service";
+import * as i8 from "./core/service/homedecorator.service";
+import * as i9 from "./shared/progress-bar/progress-bar.component";
+import * as i10 from "./shared/loading-overlay/loading-overlay.component";
+import * as i11 from "./plugins/core3d/core3d/core3d.component";
+import * as i12 from "./plugins/room-planner/room-planner/room-planner.component";
+import * as i13 from "./plugins/furniture-manager/furniture-manager/furniture-manager.component";
+import * as i14 from "./plugins/presets/presets/presets.component";
+import * as i15 from "./plugins/threedselector/threedselector/threedselector.component";
+import * as i16 from "./plugins/toolbar/toolbar/toolbar.component";
+import * as i17 from "./plugins/product-catalog/product-catalog/product-catalog.component";
+import * as i18 from "./plugins/lite-selector/lite-selector/lite-selector.component";
+import * as i19 from "./plugins/help/help/help.component";
+import * as i20 from "./shared/loader/hd-loader.component";
+import * as i21 from "@angular/common";
+export class HomedecoratorComponent {
+    constructor(controllerService, appState, presetsService, screenAnalysis, _componentFactoryResolver, _iconRegistry, _domSanitizer, _messageService, _homedecoratorService) {
+        this.controllerService = controllerService;
+        this.appState = appState;
+        this.presetsService = presetsService;
+        this.screenAnalysis = screenAnalysis;
+        this._componentFactoryResolver = _componentFactoryResolver;
+        this._iconRegistry = _iconRegistry;
+        this._domSanitizer = _domSanitizer;
+        this._messageService = _messageService;
+        this._homedecoratorService = _homedecoratorService;
+        this.showClass = true;
+        this.loaded = false;
+        this.title = 'MyRoomPlans';
+        this.phoneSizeScreen = false;
+        this.isPortraitMode = false;
+        this.showIOneLoader = false;
+        this.shouldShowLandscapeMessage = false;
+        // public settings = {
+        //   'url': 'https://demo1.ionecloud.nl/',
+        //   'schema': '134592',
+        //   'version': '253',
+        //   'branch': '1',
+        //   'currency': 3,
+        //   'useGroups': true,
+        //   'assetIndex': 'index-develop.json',
+        //   'assetPath': 'https://cdn.ione360.com/content43/',
+        //   'threeDAssetPath': 'https://cdn.ione360.com/content43/',
+        //   'apiUrl': 'https://myroomplans.colijn-it.nl',
+        //   'timeoutInMs': 30000,
+        //   'languageCode': 'NL',
+        //   'username': 'ruben',
+        //   'password': 'geen',
+        //   'useLoginEncryption': true,
+        //   'jwtEnabled': false,
+        //   'options': {
+        //     'development': true,
+        //     'showStockStatus': true,
+        //     'showZoomButton': true,
+        //     'showAsConfigured': true,
+        //     'showTagFilter': true,
+        //     'showArButton': true,
+        //     'show3DWatermark': false,
+        //     'showCaptionAddButton': true,
+        //     'bottomAnswers': false,
+        //     'instantReplace': false,
+        //     'arEnabled': true,
+        //     'vrEnabled': false,
+        //     'xrDebug': false,
+        //     'inlineAnswers': false,
+        //     'onlyThreeD': false,
+        //     'showPriceFilter': false,
+        //     'cameraPositionFixed': false,
+        //     'instantEditMenu': false,
+        //     'useNewRender': true,
+        //     'useRenderWebsocket': false,
+        //     'showRoomDownloadButton': true,
+        //     'searchOnStart': true
+        //   },
+        //   'catalogParameters': {
+        //     'showCustomizedArticles': true,
+        //     'showConfigurableArticles': true,
+        //     'showInactiveArticles': false,
+        //     'showRegularArticles': true,
+        //     'showCompositionArticles': false
+        //   },
+        //   'renderParameters': {
+        //     'host': 'render1.colijn-it.nl',
+        //     'port': 8443,
+        //     'secure': true,
+        //     'renderMode': 'render_room'
+        //   },
+        //   'newRenderParameters': {
+        //     'websocket': 'wss://render1.colijn-it.nl:8083',
+        //     'host': 'https://render.colijn-it.nl',
+        //     'port': 443,
+        //     'iterations': 100,
+        //     'imageWidth': 1920,
+        //     'imageHeight': 1080,
+        //     'hdriIntensity': 1.1
+        //   }
+        // };
+        this._subs = [];
+    }
+    set settings(value) {
+        if (value) {
+            let settings;
+            if (typeof value === 'string') {
+                settings = JSON.parse(value);
+            }
+            else {
+                settings = value;
+            }
+            this._setSettings(settings);
+        }
+    }
+    get settings() {
+        return this._settings;
+    }
+    ngOnInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.registerCustomIcons();
+            this._subs.push(this.screenAnalysis.screenSizeChanged.subscribe((info) => {
+                this.phoneSizeScreen = info.isPhoneSize;
+                this.isPortraitMode = info.isPortraitMode;
+                this.shouldShowLandscapeMessage = this.screenAnalysis.isMobileDevice && this.isPortraitMode;
+            }), this._messageService.subscribe(MessageType.ShowIOneLoadingIndicator, () => {
+                this.showIOneLoader = true;
+            }), this._messageService.subscribe(MessageType.HideIOneLoadingIndicator, () => {
+                this.showIOneLoader = false;
+            }), this._messageService.subscribe(MessageType.StartWithEmptyRoom, () => {
+                this._startWithEmptyRoom(true);
+            }), this._messageService.subscribe(MessageType.StartWithPreset, ({ preset, switchTo2D }) => {
+                this._startWithPreset(preset, switchTo2D);
+            }), this._homedecoratorService.loaded.subscribe((loaded) => {
+                if (loaded) {
+                    this.loaded = true;
+                }
+            }));
+        });
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    registerCustomIcons() {
+        const addIcon = key => this._iconRegistry.addSvgIcon(key, this._domSanitizer.bypassSecurityTrustResourceUrl(`assets/icons/${key}.svg`));
+        [
+            'cube-outline',
+            'cube-unfolded',
+            'google-cardboard',
+            'google-cardboard-orange',
+            'street-view',
+            'street-view-orange',
+            'magic-wand',
+            'add-button',
+            'edit-button',
+            'delete-button',
+            'swap-button',
+            'tilt-phone',
+            'hand-pointer',
+            'check',
+            'move-phone-ar',
+            'cart-shopping-regular'
+        ].map(addIcon);
+    }
+    keyup(event) {
+        const { code, ctrlKey, altKey } = event;
+        if (!this.presetsService.isLoading && this.appState.canUndo() && ctrlKey && code === 'KeyZ') {
+            this._messageService.emit(MessageType.Undo);
+        }
+        if (!this.presetsService.isLoading && this.appState.canRedo() && ctrlKey && code === 'KeyY') {
+            this._messageService.emit(MessageType.Redo);
+        }
+        if (!this.presetsService.isLoading && altKey && (code === 'KeyH' || code === 'KeyX')) {
+            this._messageService.emit(MessageType.HideLeftSidebar);
+            if (code === 'KeyH') {
+                this._messageService.emit(MessageType.ShowFurnitureSidebar, 'Test Furniture');
+            }
+        }
+    }
+    _setSettings(settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._homedecoratorService.init(settings, true);
+        });
+    }
+    _startWithEmptyRoom(switchTo2D) {
+        const preset = Preset.CreateModelFromInterface({ filename: 'assets/presets/empty.json' });
+        this._startWithPreset(preset, switchTo2D);
+    }
+    _startWithPreset(preset, switchTo2D = false) {
+        this._messageService.emit(MessageType.ResetRoomplan);
+        if (switchTo2D) {
+            this._messageService.emit(MessageType.Set2DView, { sendUpdates: true });
+        }
+        else {
+            this._messageService.emit(MessageType.Set3DView, { sendUpdates: true });
+        }
+        this._messageService.emit(MessageType.LoadRoomFromPreset, preset);
+    }
+}
+HomedecoratorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorComponent, deps: [{ token: i1.HomedecoratorConnectorService }, { token: i2.AppStateService }, { token: i3.PresetsService }, { token: i4.ScreenSizeAnalysisService }, { token: i0.ComponentFactoryResolver }, { token: i5.MatIconRegistry }, { token: i6.DomSanitizer }, { token: i7.MessageBusService }, { token: i8.HomedecoratorService }], target: i0.ɵɵFactoryTarget.Component });
+HomedecoratorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: HomedecoratorComponent, selector: "co-homedecorator", inputs: { settings: "settings" }, host: { listeners: { "document:keyup": "keyup($event)" }, properties: { "class.co-homedecorator": "this.showClass" } }, ngImport: i0, template: `
+    <div class="viewport" *ngIf="loaded">
+      <progress-bar></progress-bar>
+      <rp-loading-overlay>
+          <rp-core3d></rp-core3d>
+          <rp-room-planner></rp-room-planner>
+          <rp-furniture-manager></rp-furniture-manager>
+          <rp-presets></rp-presets>
+          <rp-threedselector></rp-threedselector>
+          <rp-toolbar></rp-toolbar>
+          <rp-product-catalog></rp-product-catalog>
+          <rp-lite-selector></rp-lite-selector>
+          <rp-help></rp-help>
+      </rp-loading-overlay>
+    </div>
+    <rp-loader [show]="controllerService.shouldShowLoader"></rp-loader>
+    <div *ngIf="shouldShowLandscapeMessage" class="mobile-portrait-overlay">
+<!--
+      <mat-icon svgIcon="tilt-phone" class="tilt-phone-icon"></mat-icon>
+-->
+      <div>
+<!--
+        {{'PLEASE_USE_PHONE_IN_LANDSCAPE_MODE' | localize}}
+-->
+      </div>
+    </div>
+  `, isInline: true, components: [{ type: i9.ProgressBarComponent, selector: "progress-bar" }, { type: i10.LoadingOverlayComponent, selector: "rp-loading-overlay" }, { type: i11.Core3dComponent, selector: "rp-core3d" }, { type: i12.RoomPlannerComponent, selector: "rp-room-planner", inputs: ["isLoading"], outputs: ["done", "showPlugin", "focusControls"] }, { type: i13.FurnitureManagerComponent, selector: "rp-furniture-manager" }, { type: i14.PresetsComponent, selector: "rp-presets" }, { type: i15.ThreedselectorComponent, selector: "rp-threedselector", inputs: ["selections"], outputs: ["customizeButtonClicked"] }, { type: i16.ToolbarComponent, selector: "rp-toolbar" }, { type: i17.ProductCatalogComponent, selector: "rp-product-catalog" }, { type: i18.LiteSelectorComponent, selector: "rp-lite-selector", inputs: ["showAnswers", "show", "showSelections", "showLabel", "canClose", "metadata", "customDimensions"], outputs: ["showChange", "answerChosen"] }, { type: i19.HelpComponent, selector: "rp-help" }, { type: i20.HdLoaderComponent, selector: "rp-loader", inputs: ["show"] }], directives: [{ type: i21.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'co-homedecorator',
+                    template: `
+    <div class="viewport" *ngIf="loaded">
+      <progress-bar></progress-bar>
+      <rp-loading-overlay>
+          <rp-core3d></rp-core3d>
+          <rp-room-planner></rp-room-planner>
+          <rp-furniture-manager></rp-furniture-manager>
+          <rp-presets></rp-presets>
+          <rp-threedselector></rp-threedselector>
+          <rp-toolbar></rp-toolbar>
+          <rp-product-catalog></rp-product-catalog>
+          <rp-lite-selector></rp-lite-selector>
+          <rp-help></rp-help>
+      </rp-loading-overlay>
+    </div>
+    <rp-loader [show]="controllerService.shouldShowLoader"></rp-loader>
+    <div *ngIf="shouldShowLandscapeMessage" class="mobile-portrait-overlay">
+<!--
+      <mat-icon svgIcon="tilt-phone" class="tilt-phone-icon"></mat-icon>
+-->
+      <div>
+<!--
+        {{'PLEASE_USE_PHONE_IN_LANDSCAPE_MODE' | localize}}
+-->
+      </div>
+    </div>
+  `,
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HomedecoratorConnectorService }, { type: i2.AppStateService }, { type: i3.PresetsService }, { type: i4.ScreenSizeAnalysisService }, { type: i0.ComponentFactoryResolver }, { type: i5.MatIconRegistry }, { type: i6.DomSanitizer }, { type: i7.MessageBusService }, { type: i8.HomedecoratorService }]; }, propDecorators: { settings: [{
+                type: Input
+            }], showClass: [{
+                type: HostBinding,
+                args: ['class.co-homedecorator']
+            }], keyup: [{
+                type: HostListener,
+                args: ['document:keyup', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"homedecorator.component.js","sourceRoot":"","sources":["../../../../src/client/app/homedecorator.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, ComponentFactoryResolver, HostBinding, HostListener, Input, OnDestroy, OnInit, ViewEncapsulation} from '@angular/core';\r\nimport {MatIconRegistry} from '@angular/material/icon';\r\nimport {DomSanitizer} from '@angular/platform-browser';\r\nimport {Subscription} from 'rxjs';\r\nimport {AppStateService} from './core/service/app-state.service';\r\nimport {PresetsService} from './core/service/presets.service';\r\nimport {HomedecoratorConnectorService} from './core/service/homedecorator-connector.service';\r\nimport {ScreenSizeAnalysisService} from './shared/screen-size-analysis/screen-size-analysis.service';\r\nimport {MessageBusService} from './core/service/message-bus.service';\r\nimport {ScreenSizeInfo} from './shared/screen-size-analysis/screen-size-info';\r\nimport {MessageType} from './core/enum/message-type.enum';\r\nimport {HomedecoratorService} from './core/service/homedecorator.service';\r\nimport {Preset} from './core/model/preset';\r\n\r\n@Component({\r\n  selector: 'co-homedecorator',\r\n  template: `\r\n    <div class=\"viewport\" *ngIf=\"loaded\">\r\n      <progress-bar></progress-bar>\r\n      <rp-loading-overlay>\r\n          <rp-core3d></rp-core3d>\r\n          <rp-room-planner></rp-room-planner>\r\n          <rp-furniture-manager></rp-furniture-manager>\r\n          <rp-presets></rp-presets>\r\n          <rp-threedselector></rp-threedselector>\r\n          <rp-toolbar></rp-toolbar>\r\n          <rp-product-catalog></rp-product-catalog>\r\n          <rp-lite-selector></rp-lite-selector>\r\n          <rp-help></rp-help>\r\n      </rp-loading-overlay>\r\n    </div>\r\n    <rp-loader [show]=\"controllerService.shouldShowLoader\"></rp-loader>\r\n    <div *ngIf=\"shouldShowLandscapeMessage\" class=\"mobile-portrait-overlay\">\r\n<!--\r\n      <mat-icon svgIcon=\"tilt-phone\" class=\"tilt-phone-icon\"></mat-icon>\r\n-->\r\n      <div>\r\n<!--\r\n        {{'PLEASE_USE_PHONE_IN_LANDSCAPE_MODE' | localize}}\r\n-->\r\n      </div>\r\n    </div>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class HomedecoratorComponent implements OnInit, OnDestroy {\r\n\r\n  @Input()\r\n  public set settings(value: any) {\r\n    if (value) {\r\n      let settings: any;\r\n      if (typeof value === 'string') {\r\n        settings = JSON.parse(value);\r\n      } else {\r\n        settings = value;\r\n      }\r\n      this._setSettings(settings);\r\n    }\r\n  }\r\n\r\n  public get settings(): any {\r\n    return this._settings;\r\n  }\r\n\r\n  @HostBinding('class.co-homedecorator')\r\n  public showClass: boolean = true;\r\n\r\n  public loaded: boolean = false;\r\n  public title: string = 'MyRoomPlans';\r\n  public phoneSizeScreen: boolean = false;\r\n  public isPortraitMode: boolean = false;\r\n  public showIOneLoader: boolean = false;\r\n  public shouldShowLandscapeMessage: boolean = false;\r\n\r\n  // public settings = {\r\n  //   'url': 'https://demo1.ionecloud.nl/',\r\n  //   'schema': '134592',\r\n  //   'version': '253',\r\n  //   'branch': '1',\r\n  //   'currency': 3,\r\n  //   'useGroups': true,\r\n  //   'assetIndex': 'index-develop.json',\r\n  //   'assetPath': 'https://cdn.ione360.com/content43/',\r\n  //   'threeDAssetPath': 'https://cdn.ione360.com/content43/',\r\n  //   'apiUrl': 'https://myroomplans.colijn-it.nl',\r\n  //   'timeoutInMs': 30000,\r\n  //   'languageCode': 'NL',\r\n  //   'username': 'ruben',\r\n  //   'password': 'geen',\r\n  //   'useLoginEncryption': true,\r\n  //   'jwtEnabled': false,\r\n  //   'options': {\r\n  //     'development': true,\r\n  //     'showStockStatus': true,\r\n  //     'showZoomButton': true,\r\n  //     'showAsConfigured': true,\r\n  //     'showTagFilter': true,\r\n  //     'showArButton': true,\r\n  //     'show3DWatermark': false,\r\n  //     'showCaptionAddButton': true,\r\n  //     'bottomAnswers': false,\r\n  //     'instantReplace': false,\r\n  //     'arEnabled': true,\r\n  //     'vrEnabled': false,\r\n  //     'xrDebug': false,\r\n  //     'inlineAnswers': false,\r\n  //     'onlyThreeD': false,\r\n  //     'showPriceFilter': false,\r\n  //     'cameraPositionFixed': false,\r\n  //     'instantEditMenu': false,\r\n  //     'useNewRender': true,\r\n  //     'useRenderWebsocket': false,\r\n  //     'showRoomDownloadButton': true,\r\n  //     'searchOnStart': true\r\n  //   },\r\n  //   'catalogParameters': {\r\n  //     'showCustomizedArticles': true,\r\n  //     'showConfigurableArticles': true,\r\n  //     'showInactiveArticles': false,\r\n  //     'showRegularArticles': true,\r\n  //     'showCompositionArticles': false\r\n  //   },\r\n  //   'renderParameters': {\r\n  //     'host': 'render1.colijn-it.nl',\r\n  //     'port': 8443,\r\n  //     'secure': true,\r\n  //     'renderMode': 'render_room'\r\n  //   },\r\n  //   'newRenderParameters': {\r\n  //     'websocket': 'wss://render1.colijn-it.nl:8083',\r\n  //     'host': 'https://render.colijn-it.nl',\r\n  //     'port': 443,\r\n  //     'iterations': 100,\r\n  //     'imageWidth': 1920,\r\n  //     'imageHeight': 1080,\r\n  //     'hdriIntensity': 1.1\r\n  //   }\r\n  // };\r\n\r\n  private _subs: Subscription[] = [];\r\n  private _settings: any;\r\n\r\n  constructor(\r\n    public controllerService: HomedecoratorConnectorService,\r\n    public appState: AppStateService,\r\n    public presetsService: PresetsService,\r\n    public screenAnalysis: ScreenSizeAnalysisService,\r\n    private _componentFactoryResolver: ComponentFactoryResolver,\r\n    private _iconRegistry: MatIconRegistry,\r\n    private _domSanitizer: DomSanitizer,\r\n    private _messageService: MessageBusService,\r\n    private _homedecoratorService: HomedecoratorService\r\n  ) {\r\n  }\r\n\r\n  async ngOnInit(): Promise<void> {\r\n    this.registerCustomIcons();\r\n    this._subs.push(\r\n      this.screenAnalysis.screenSizeChanged.subscribe((info: ScreenSizeInfo) => {\r\n        this.phoneSizeScreen = info.isPhoneSize;\r\n        this.isPortraitMode = info.isPortraitMode;\r\n        this.shouldShowLandscapeMessage = this.screenAnalysis.isMobileDevice && this.isPortraitMode;\r\n      }),\r\n      this._messageService.subscribe(MessageType.ShowIOneLoadingIndicator, () => {\r\n        this.showIOneLoader = true;\r\n      }),\r\n      this._messageService.subscribe(MessageType.HideIOneLoadingIndicator, () => {\r\n        this.showIOneLoader = false;\r\n      }),\r\n      this._messageService.subscribe(MessageType.StartWithEmptyRoom, () => {\r\n        this._startWithEmptyRoom(true);\r\n      }),\r\n      this._messageService.subscribe(MessageType.StartWithPreset, ({preset, switchTo2D}) => {\r\n        this._startWithPreset(preset, switchTo2D);\r\n      }),\r\n      this._homedecoratorService.loaded.subscribe((loaded: boolean) => {\r\n        if (loaded) {\r\n          this.loaded = true;\r\n        }\r\n      })\r\n    );\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  registerCustomIcons() {\r\n    const addIcon = key =>\r\n      this._iconRegistry.addSvgIcon(key, this._domSanitizer.bypassSecurityTrustResourceUrl(`assets/icons/${key}.svg`));\r\n    [\r\n      'cube-outline',\r\n      'cube-unfolded',\r\n      'google-cardboard',\r\n      'google-cardboard-orange',\r\n      'street-view',\r\n      'street-view-orange',\r\n      'magic-wand',\r\n      'add-button',\r\n      'edit-button',\r\n      'delete-button',\r\n      'swap-button',\r\n      'tilt-phone',\r\n      'hand-pointer',\r\n      'check',\r\n      'move-phone-ar',\r\n      'cart-shopping-regular'\r\n    ].map(addIcon);\r\n  }\r\n\r\n  @HostListener('document:keyup', ['$event'])\r\n  keyup(event: KeyboardEvent) {\r\n    const {code, ctrlKey, altKey}: { code: string, ctrlKey: boolean, altKey: boolean } = event;\r\n    if (!this.presetsService.isLoading && this.appState.canUndo() && ctrlKey && code === 'KeyZ') {\r\n      this._messageService.emit(MessageType.Undo);\r\n    }\r\n    if (!this.presetsService.isLoading && this.appState.canRedo() && ctrlKey && code === 'KeyY') {\r\n      this._messageService.emit(MessageType.Redo);\r\n    }\r\n    if (!this.presetsService.isLoading && altKey && (code === 'KeyH' || code === 'KeyX')) {\r\n      this._messageService.emit(MessageType.HideLeftSidebar);\r\n      if (code === 'KeyH') {\r\n        this._messageService.emit(MessageType.ShowFurnitureSidebar, 'Test Furniture');\r\n      }\r\n    }\r\n  }\r\n\r\n  private async _setSettings(settings: any): Promise<void> {\r\n    await this._homedecoratorService.init(settings, true);\r\n  }\r\n\r\n  private _startWithEmptyRoom(switchTo2D: boolean): void {\r\n    const preset: Preset = Preset.CreateModelFromInterface({filename: 'assets/presets/empty.json'});\r\n    this._startWithPreset(preset, switchTo2D);\r\n  }\r\n\r\n  private _startWithPreset(preset: Preset, switchTo2D: boolean = false): void {\r\n    this._messageService.emit(MessageType.ResetRoomplan);\r\n    if (switchTo2D) {\r\n      this._messageService.emit(MessageType.Set2DView, {sendUpdates: true});\r\n    } else {\r\n      this._messageService.emit(MessageType.Set3DView, {sendUpdates: true});\r\n    }\r\n    this._messageService.emit(MessageType.LoadRoomFromPreset, preset);\r\n  }\r\n}\r\n"]}