@colijnit/configurator 261.1.0 → 261.1.1

package/esm2015/lib/services/scene-event.service.js

@@ -0,0 +1,246 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { Vector2, Vector3 } from 'three';
+import { Subject } from 'rxjs';
+import { fromEvent } from 'rxjs/internal/observable/fromEvent';
+import { delay, filter, takeUntil } from 'rxjs/operators';
+import { of } from 'rxjs/internal/observable/of';
+import { SceneEventState } from '../enum/scene-event.enum';
+import { RelativePositionUtils } from '../utils/relative-position.utils';
+import { IntersectedObjects } from '../model/intersected-objects';
+import * as i0 from "@angular/core";
+import * as i1 from "./scene.service";
+import * as i2 from "./camera.service";
+import * as i3 from "./configurator-connector.service";
+import * as i4 from "./intersection.service";
+import * as i5 from "./floor-plane.service";
+import * as i6 from "./item.service";
+import * as i7 from "./app-event.service";
+export class SceneEventService {
+    constructor(_sceneService, _cameraService, _connectorService, _intersectionService, _floorPlaneService, _itemService, _appEventService) {
+        this._sceneService = _sceneService;
+        this._cameraService = _cameraService;
+        this._connectorService = _connectorService;
+        this._intersectionService = _intersectionService;
+        this._floorPlaneService = _floorPlaneService;
+        this._itemService = _itemService;
+        this._appEventService = _appEventService;
+        this.intersectOffsetForWalls = 20;
+        this.longTouchDuration = 600;
+        this.rotateNoDrag = false;
+        this._mousePosition = new Vector2();
+        this._oldMousePosition = new Vector2();
+        this._rotationStartPoint = null;
+        this._defaultCursorStyle = 'pointer';
+        this._inDragOver = false;
+        this._mouseDown = false;
+        this._mouseMoved = false; // has mouse moved since down click
+        this._rotateMouseOver = false;
+        this._groupingMode = false;
+        this._state = SceneEventState.UNSELECTED;
+        this._subs = [];
+        this._debouncedSaveState = new Subject();
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+        this._element = undefined;
+    }
+    init(element) {
+        this._element = element;
+        this._controls = this._cameraService.controls;
+        this._camera = this._cameraService.camera;
+        this._touchStart = fromEvent(element, 'touchstart');
+        this._touchEnd = fromEvent(element, 'touchend');
+        this._touchCancel = fromEvent(element, 'touchcancel');
+        this._touchMove = fromEvent(element, 'touchmove');
+        fromEvent(element, 'mousedown').pipe(filter((event) => event.button === 0)).subscribe(event => this._leftMouseDownEvent(event));
+        fromEvent(element, 'mouseup').subscribe((event) => this._mouseUpEvent(event));
+        fromEvent(element, 'mousemove').subscribe((event) => this._mouseMoveEvent(event));
+        this._touchStart.subscribe((event) => this._touchStartEvent(event));
+        this._touchEnd.subscribe((event) => this._touchEndEvent(event));
+        this._touchCancel.subscribe((event) => this._touchEndEvent(event));
+        this._touchMove.subscribe((event) => this._touchMoveEvent(event));
+        this._subs.push(
+        // this._itemGroupService.objectAdded.subscribe((object) => this.setSelectedObject(object)),
+        );
+    }
+    setExploreMode(on = true) {
+        // TODO Remove
+    }
+    setSelectedObject(object, mesh) {
+        if (object) {
+            const intersectedObjects = new IntersectedObjects(object, mesh);
+            this._state = SceneEventState.SELECTED;
+            this._appEventService.onObjectSelected.next(intersectedObjects);
+        }
+        this._markSceneToUpdate();
+    }
+    setUnselectedObject() {
+        this._state = SceneEventState.UNSELECTED;
+        this._appEventService.onObjectUnSelected.next(true);
+    }
+    _updateIntersections() {
+        // get floorplan
+        const floorPlane = this._floorPlaneService.floorPlane;
+        // get object in the scene
+        const item = this._itemService.sceneItems.values().next().value;
+        const objectPlanes = [floorPlane, item];
+        const intersects = this._getIntersections(this._mousePosition, objectPlanes, { onlyVisible: true, includeFloors: false });
+        // object intersection is prioritized
+        if (intersects.length > 1) {
+            this._setIntersectedObject(intersects[0].object);
+        }
+        else if (intersects.length === 1 && intersects[0].object.name === floorPlane.name) {
+            // just the floor, no object
+            this._clearIntersectedObject();
+        }
+        else {
+            this._clearIntersectedObject();
+        }
+    }
+    _clearIntersectedObject() {
+        this._intersectedMesh = null;
+        this._intersectedObject = null;
+    }
+    _setMousePositionFromTouchEvent(event) {
+        const canvas = this._element;
+        this._mousePosition = RelativePositionUtils.GetClientTouchPosition(event, canvas);
+    }
+    _touchStartEvent(event) {
+        if (this._isMouseEventAllowed(event)) {
+            const longTouch = of(1)
+                .pipe(delay(this.longTouchDuration))
+                .pipe(takeUntil(this._touchStart))
+                .pipe(takeUntil(this._touchEnd))
+                .pipe(takeUntil(this._touchCancel));
+            longTouch.subscribe(() => {
+                this._updateIntersections();
+            });
+            this._mouseMoved = false;
+            this._mouseDown = true;
+            this._setMousePositionFromTouchEvent(event);
+            switch (this._state) {
+                case SceneEventState.SELECTED:
+                    if (!this._intersectedObject) {
+                        this.setUnselectedObject();
+                    }
+                    else {
+                        this.setSelectedObject(this._intersectedObject, this._intersectedMesh);
+                    }
+                    break;
+                case SceneEventState.UNSELECTED:
+                    if (this._intersectedObject) {
+                        this.setSelectedObject(this._intersectedObject, this._intersectedMesh);
+                    }
+                    break;
+            }
+        }
+    }
+    _touchEndEvent(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO check if we still need this.
+        });
+    }
+    _touchMoveEvent(event) {
+        if (this._isMouseEventAllowed(event)) {
+            this._setMousePositionFromTouchEvent(event);
+            this._mouseMoved = true;
+            if (this._mouseMoved) {
+                this._updateIntersections();
+            }
+        }
+    }
+    //
+    // MOUSE EVENTS
+    //
+    // TODO Might be ok to remove
+    _mouseUpEvent(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // this._mouseDown = false;
+            // switch (this._state) {
+            //   case SceneEventState.UNSELECTED:
+            //     break;
+            //   case SceneEventState.SELECTED:
+            //     break;
+            // }
+        });
+    }
+    _mouseMoveEvent(event) {
+        if (this._isMouseEventAllowed(event)) {
+            const mousePos = event ? RelativePositionUtils.GetClientMousePosition(event) : this._mousePosition;
+            let canvas;
+            if (event) {
+                event.preventDefault();
+                canvas = event.currentTarget;
+            }
+            this._mousePosition.set(mousePos.x - (canvas ? canvas.offsetLeft : 0), mousePos.y - (canvas ? canvas.offsetTop : 0));
+            if (this._oldMousePosition.x !== mousePos.x && this._oldMousePosition.y !== mousePos.y) {
+                this._mouseMoved = true;
+            }
+            if (this._mouseMoved) {
+                this._updateIntersections();
+            }
+        }
+    }
+    _leftMouseDownEvent(event) {
+        if (this._isMouseEventAllowed(event)) {
+            if (event) {
+                event.preventDefault();
+            }
+            switch (this._state) {
+                case SceneEventState.SELECTED:
+                    if (!this._intersectedObject) {
+                        this.setUnselectedObject();
+                    }
+                    else {
+                        this.setSelectedObject(this._intersectedObject, this._intersectedMesh);
+                    }
+                    break;
+                case SceneEventState.UNSELECTED:
+                    if (this._intersectedObject) {
+                        this.setSelectedObject(this._intersectedObject, this._intersectedMesh);
+                    }
+                    break;
+            }
+        }
+    }
+    _getIntersections(mousePos, objects, options) {
+        const mouseVector = this._mouseToVec3(mousePos);
+        return this._intersectionService.getIntersections(mouseVector, objects, options);
+    }
+    _setIntersectedObject(mesh) {
+        if (mesh && mesh.parent && mesh.parent.userData && mesh.parent.userData.rootObject) {
+            this._intersectedMesh = mesh;
+        }
+        if (mesh && mesh.userData && mesh.userData.rootObject) {
+            this._intersectedObject = mesh;
+        }
+        else if (mesh.parent) {
+            this._setIntersectedObject(mesh.parent);
+        }
+    }
+    _isMouseEventAllowed(event) {
+        return event ? (event.target && event.target.nodeName === 'CANVAS') : true;
+    }
+    // Reverted changes from IONE-31399
+    _mouseToVec3(vec2) {
+        const rendererElement = this._element;
+        const mPosition = new Vector2((vec2.x / rendererElement.clientWidth) * 2 - 1, -(vec2.y / rendererElement.clientHeight) * 2 + 1);
+        const vector = new Vector3(mPosition.x, mPosition.y, 0.5);
+        vector.unproject(this._camera);
+        return vector;
+    }
+    _markSceneToUpdate() {
+        this._sceneService.needsRender = true;
+    }
+    _setCursorStyle(style) {
+        this._element.style.cursor = style;
+    }
+}
+SceneEventService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneEventService, deps: [{ token: i1.SceneService }, { token: i2.CameraService }, { token: i3.ConfiguratorConnectorService }, { token: i4.IntersectionService }, { token: i5.FloorPlaneService }, { token: i6.ItemService }, { token: i7.AppEventService }], target: i0.ɵɵFactoryTarget.Injectable });
+SceneEventService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneEventService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneEventService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.SceneService }, { type: i2.CameraService }, { type: i3.ConfiguratorConnectorService }, { type: i4.IntersectionService }, { type: i5.FloorPlaneService }, { type: i6.ItemService }, { type: i7.AppEventService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scene-event.service.js","sourceRoot":"","sources":["../../../../../projects/configurator/src/lib/services/scene-event.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {Camera, Intersection, Mesh, Object3D, Vector2, Vector3} from 'three';\r\nimport {CameraService} from './camera.service';\r\nimport {Observable, Subject, Subscription} from 'rxjs';\r\nimport {fromEvent} from 'rxjs/internal/observable/fromEvent';\r\nimport {delay, filter, takeUntil} from 'rxjs/operators';\r\nimport {of} from 'rxjs/internal/observable/of';\r\nimport {SceneEventState} from '../enum/scene-event.enum';\r\nimport {RelativePositionUtils} from '../utils/relative-position.utils';\r\nimport {SceneService} from './scene.service';\r\nimport {ConfiguratorConnectorService} from './configurator-connector.service';\r\nimport {IntersectionService} from './intersection.service';\r\nimport {FloorPlaneService} from './floor-plane.service';\r\nimport {ItemService} from './item.service';\r\nimport {IntersectedObjects} from '../model/intersected-objects';\r\nimport {AppEventService} from './app-event.service';\r\n\r\n@Injectable({providedIn: 'root'})\r\nexport class SceneEventService implements OnDestroy {\r\n  public readonly intersectOffsetForWalls = 20;\r\n  public readonly longTouchDuration = 600;\r\n\r\n  public rotateNoDrag: boolean = false;\r\n  private _element: HTMLElement;\r\n  private _controls: any;\r\n  private _camera: Camera;\r\n\r\n  private _mousePosition: Vector2 = new Vector2();\r\n  private _oldMousePosition: Vector2 = new Vector2();\r\n\r\n  private _rotationStartPoint: Vector3 = null;\r\n\r\n  private _intersectedObject: Object3D;\r\n  private _intersectedMesh: Object3D | Mesh;\r\n  private _mouseoverObject: Object3D;\r\n  private _selectedObject: any;\r\n  private _prevSelectedObject: any;\r\n  private _defaultCursorStyle = 'pointer';\r\n  private _inDragOver = false;\r\n\r\n  private _mouseDown = false;\r\n  private _mouseMoved = false; // has mouse moved since down click\r\n\r\n  private _rotateMouseOver = false;\r\n  private _groupingMode: boolean = false;\r\n\r\n  private _state: SceneEventState = SceneEventState.UNSELECTED;\r\n\r\n  private _intersectedWall: Intersection;\r\n  private _intersectedFloor: Intersection;\r\n\r\n  private _subs: Subscription[] = [];\r\n  private _cameraMoveSub: Subscription;\r\n\r\n  private _debouncedSaveState: Subject<string> = new Subject();\r\n  private _touchStart: Observable<Event>;\r\n  private _touchEnd: Observable<Event>;\r\n  private _touchCancel: Observable<Event>;\r\n  private _touchMove: Observable<Event>;\r\n\r\n  constructor(\r\n    private _sceneService: SceneService,\r\n    private _cameraService: CameraService,\r\n    private _connectorService: ConfiguratorConnectorService,\r\n    private _intersectionService: IntersectionService,\r\n    private _floorPlaneService: FloorPlaneService,\r\n    private _itemService: ItemService,\r\n    private _appEventService: AppEventService\r\n  ) {\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n    this._element = undefined;\r\n  }\r\n\r\n  public init(element: HTMLElement) {\r\n    this._element = element;\r\n    this._controls = this._cameraService.controls;\r\n    this._camera = this._cameraService.camera;\r\n\r\n    this._touchStart = fromEvent(element, 'touchstart');\r\n    this._touchEnd = fromEvent(element, 'touchend');\r\n    this._touchCancel = fromEvent(element, 'touchcancel');\r\n    this._touchMove = fromEvent(element, 'touchmove');\r\n\r\n    fromEvent(element, 'mousedown').pipe(filter((event: MouseEvent) => event.button === 0)).subscribe(event => this._leftMouseDownEvent(event));\r\n    fromEvent(element, 'mouseup').subscribe((event: MouseEvent) => this._mouseUpEvent(event));\r\n    fromEvent(element, 'mousemove').subscribe((event: MouseEvent) => this._mouseMoveEvent(event));\r\n    this._touchStart.subscribe((event: TouchEvent) => this._touchStartEvent(event));\r\n    this._touchEnd.subscribe((event: TouchEvent) => this._touchEndEvent(event));\r\n    this._touchCancel.subscribe((event: TouchEvent) => this._touchEndEvent(event));\r\n    this._touchMove.subscribe((event: TouchEvent) => this._touchMoveEvent(event));\r\n\r\n    this._subs.push(\r\n      // this._itemGroupService.objectAdded.subscribe((object) => this.setSelectedObject(object)),\r\n    );\r\n\r\n  }\r\n\r\n  public setExploreMode(on = true) {\r\n    // TODO Remove\r\n  }\r\n\r\n  public setSelectedObject(object: Object3D, mesh?: Object3D | Mesh): void {\r\n    if (object) {\r\n      const intersectedObjects: IntersectedObjects = new IntersectedObjects(object, mesh);\r\n      this._state = SceneEventState.SELECTED;\r\n      this._appEventService.onObjectSelected.next(intersectedObjects);\r\n    }\r\n    this._markSceneToUpdate();\r\n  }\r\n\r\n  public setUnselectedObject(): void {\r\n    this._state = SceneEventState.UNSELECTED;\r\n    this._appEventService.onObjectUnSelected.next(true);\r\n  }\r\n\r\n  private _updateIntersections(): void {\r\n    // get floorplan\r\n    const floorPlane: Object3D = this._floorPlaneService.floorPlane;\r\n    // get object in the scene\r\n    const item: Object3D = this._itemService.sceneItems.values().next().value;\r\n    const objectPlanes: Object3D[] = [floorPlane, item];\r\n\r\n    const intersects = this._getIntersections(\r\n      this._mousePosition,\r\n      objectPlanes,\r\n      {onlyVisible: true, includeFloors: false}\r\n    );\r\n\r\n    // object intersection is prioritized\r\n    if (intersects.length > 1) {\r\n      this._setIntersectedObject(intersects[0].object);\r\n    } else if (intersects.length === 1 && intersects[0].object.name === floorPlane.name) {\r\n      // just the floor, no object\r\n      this._clearIntersectedObject();\r\n    } else {\r\n      this._clearIntersectedObject();\r\n    }\r\n  }\r\n\r\n  private _clearIntersectedObject(): void {\r\n    this._intersectedMesh = null;\r\n    this._intersectedObject = null;\r\n  }\r\n\r\n  private _setMousePositionFromTouchEvent(event: TouchEvent) {\r\n    const canvas: HTMLElement = this._element;\r\n    this._mousePosition = RelativePositionUtils.GetClientTouchPosition(event, canvas);\r\n  }\r\n\r\n  private _touchStartEvent(event: TouchEvent): void {\r\n    if (this._isMouseEventAllowed(event)) {\r\n      const longTouch = of(1)\r\n        .pipe(delay(this.longTouchDuration))\r\n        .pipe(takeUntil(this._touchStart))\r\n        .pipe(takeUntil(this._touchEnd))\r\n        .pipe(takeUntil(this._touchCancel));\r\n      longTouch.subscribe(() => {\r\n        this._updateIntersections();\r\n\r\n      });\r\n\r\n      this._mouseMoved = false;\r\n      this._mouseDown = true;\r\n\r\n      this._setMousePositionFromTouchEvent(event);\r\n      switch (this._state) {\r\n        case SceneEventState.SELECTED:\r\n          if (!this._intersectedObject) {\r\n            this.setUnselectedObject();\r\n          } else {\r\n            this.setSelectedObject(this._intersectedObject, this._intersectedMesh);\r\n          }\r\n          break;\r\n        case SceneEventState.UNSELECTED:\r\n          if (this._intersectedObject) {\r\n            this.setSelectedObject(this._intersectedObject, this._intersectedMesh);\r\n          }\r\n          break;\r\n      }\r\n    }\r\n  }\r\n\r\n  private async _touchEndEvent(event: TouchEvent): Promise<void> {\r\n    // TODO check if we still need this.\r\n  }\r\n\r\n  private _touchMoveEvent(event: TouchEvent): void {\r\n    if (this._isMouseEventAllowed(event)) {\r\n      this._setMousePositionFromTouchEvent(event);\r\n      this._mouseMoved = true;\r\n      if (this._mouseMoved) {\r\n        this._updateIntersections();\r\n      }\r\n    }\r\n  }\r\n\r\n  //\r\n  // MOUSE EVENTS\r\n  //\r\n\r\n  // TODO Might be ok to remove\r\n  private async _mouseUpEvent(event?: MouseEvent): Promise<void> {\r\n    // this._mouseDown = false;\r\n    // switch (this._state) {\r\n    //   case SceneEventState.UNSELECTED:\r\n    //     break;\r\n    //   case SceneEventState.SELECTED:\r\n    //     break;\r\n    // }\r\n  }\r\n\r\n  private _mouseMoveEvent(event?: MouseEvent): void {\r\n    if (this._isMouseEventAllowed(event)) {\r\n      const mousePos: Vector2 = event ? RelativePositionUtils.GetClientMousePosition(event) : this._mousePosition;\r\n      let canvas: HTMLElement;\r\n      if (event) {\r\n        event.preventDefault();\r\n        canvas = event.currentTarget as HTMLElement;\r\n      }\r\n      this._mousePosition.set(mousePos.x - (canvas ? canvas.offsetLeft : 0), mousePos.y - (canvas ? canvas.offsetTop : 0));\r\n\r\n      if (this._oldMousePosition.x !== mousePos.x && this._oldMousePosition.y !== mousePos.y) {\r\n        this._mouseMoved = true;\r\n      }\r\n      if (this._mouseMoved) {\r\n        this._updateIntersections();\r\n      }\r\n    }\r\n  }\r\n\r\n  private _leftMouseDownEvent(event?): void {\r\n    if (this._isMouseEventAllowed(event)) {\r\n      if (event) {\r\n        event.preventDefault();\r\n      }\r\n      switch (this._state) {\r\n        case SceneEventState.SELECTED:\r\n          if (!this._intersectedObject) {\r\n            this.setUnselectedObject();\r\n          } else {\r\n            this.setSelectedObject(this._intersectedObject, this._intersectedMesh);\r\n          }\r\n          break;\r\n        case SceneEventState.UNSELECTED:\r\n          if (this._intersectedObject) {\r\n            this.setSelectedObject(this._intersectedObject, this._intersectedMesh);\r\n          }\r\n          break;\r\n      }\r\n    }\r\n  }\r\n\r\n  private _getIntersections(mousePos: Vector2, objects: Object3D[], options?): Intersection[] {\r\n    const mouseVector = this._mouseToVec3(mousePos);\r\n    return this._intersectionService.getIntersections(mouseVector, objects, options);\r\n  }\r\n\r\n  private _setIntersectedObject(mesh: any): void {\r\n    if (mesh && mesh.parent && mesh.parent.userData && mesh.parent.userData.rootObject) {\r\n      this._intersectedMesh = mesh;\r\n    }\r\n    if (mesh && mesh.userData && mesh.userData.rootObject) {\r\n      this._intersectedObject = mesh;\r\n    } else if (mesh.parent) {\r\n      this._setIntersectedObject(mesh.parent as Object3D);\r\n    }\r\n  }\r\n\r\n  private _isMouseEventAllowed(event?: Event): boolean {\r\n    return event ? (event.target && (event.target as Element).nodeName === 'CANVAS') : true;\r\n  }\r\n\r\n  // Reverted changes from IONE-31399\r\n  private _mouseToVec3(vec2: Vector2): Vector3 {\r\n    const rendererElement = this._element;\r\n    const mPosition = new Vector2(\r\n      (vec2.x / rendererElement.clientWidth) * 2 - 1,\r\n      -(vec2.y / rendererElement.clientHeight) * 2 + 1\r\n    );\r\n    const vector = new Vector3(mPosition.x, mPosition.y, 0.5);\r\n    vector.unproject(this._camera);\r\n    return vector;\r\n  }\r\n\r\n  private _markSceneToUpdate(): void {\r\n    this._sceneService.needsRender = true;\r\n  }\r\n\r\n  private _setCursorStyle(style: string): void {\r\n    this._element.style.cursor = style;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/services/scene-options.service.js

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class SceneOptionsService {
+    constructor() {
+        this.sceneOptionButtonAdded = new BehaviorSubject(undefined);
+        this.sceneOptionButtonUpdated = new Subject();
+    }
+    addSceneOptionButton(button) {
+        this.sceneOptionButtonAdded.next(button);
+    }
+    updateSceneOptionButton(button) {
+        this.sceneOptionButtonUpdated.next(button);
+    }
+}
+SceneOptionsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneOptionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SceneOptionsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneOptionsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SceneOptionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NlbmUtb3B0aW9ucy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29uZmlndXJhdG9yL3NyYy9saWIvc2VydmljZXMvc2NlbmUtb3B0aW9ucy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFDLGVBQWUsRUFBRSxPQUFPLEVBQUMsTUFBTSxNQUFNLENBQUM7O0FBTzlDLE1BQU0sT0FBTyxtQkFBbUI7SUFIaEM7UUFLUywyQkFBc0IsR0FBZ0QsSUFBSSxlQUFlLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDckcsNkJBQXdCLEdBQXdDLElBQUksT0FBTyxFQUFFLENBQUM7S0FVdEY7SUFSUSxvQkFBb0IsQ0FBQyxNQUFrQztRQUM1RCxJQUFJLENBQUMsc0JBQXNCLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQzNDLENBQUM7SUFFTSx1QkFBdUIsQ0FBQyxNQUFrQztRQUMvRCxJQUFJLENBQUMsd0JBQXdCLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQzdDLENBQUM7O2lIQVhVLG1CQUFtQjtxSEFBbkIsbUJBQW1CLGNBRmxCLE1BQU07NEZBRVAsbUJBQW1CO2tCQUgvQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW5qZWN0YWJsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7QmVoYXZpb3JTdWJqZWN0LCBTdWJqZWN0fSBmcm9tICdyeGpzJztcclxuaW1wb3J0IHtTY2VuZU9wdGlvbkJ1dHRvbkludGVyZmFjZX0gZnJvbSAnLi4vaW50ZXJmYWNlcy9zY2VuZS1vcHRpb24tYnV0dG9uLmludGVyZmFjZSc7XHJcblxyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgU2NlbmVPcHRpb25zU2VydmljZSB7XHJcblxyXG4gIHB1YmxpYyBzY2VuZU9wdGlvbkJ1dHRvbkFkZGVkOiBCZWhhdmlvclN1YmplY3Q8U2NlbmVPcHRpb25CdXR0b25JbnRlcmZhY2U+ID0gbmV3IEJlaGF2aW9yU3ViamVjdCh1bmRlZmluZWQpO1xyXG4gIHB1YmxpYyBzY2VuZU9wdGlvbkJ1dHRvblVwZGF0ZWQ6IFN1YmplY3Q8U2NlbmVPcHRpb25CdXR0b25JbnRlcmZhY2U+ID0gbmV3IFN1YmplY3QoKTtcclxuXHJcbiAgcHVibGljIGFkZFNjZW5lT3B0aW9uQnV0dG9uKGJ1dHRvbjogU2NlbmVPcHRpb25CdXR0b25JbnRlcmZhY2UpOiB2b2lkIHtcclxuICAgIHRoaXMuc2NlbmVPcHRpb25CdXR0b25BZGRlZC5uZXh0KGJ1dHRvbik7XHJcbiAgfVxyXG5cclxuICBwdWJsaWMgdXBkYXRlU2NlbmVPcHRpb25CdXR0b24oYnV0dG9uOiBTY2VuZU9wdGlvbkJ1dHRvbkludGVyZmFjZSk6IHZvaWQge1xyXG4gICAgdGhpcy5zY2VuZU9wdGlvbkJ1dHRvblVwZGF0ZWQubmV4dChidXR0b24pO1xyXG4gIH1cclxuXHJcbn1cclxuIl19