@colijnit/corecomponents_v12 12.0.17 → 12.0.20

package/esm2015/lib/components/carousel-3d/carousel-3d.component.js

@@ -0,0 +1,313 @@
+import { Component, ContentChildren, ElementRef, EventEmitter, HostBinding, Input, Output, ViewChild, ViewEncapsulation } from "@angular/core";
+import { AmbientLight, Box3, Color, Fog, Mesh, MeshPhongMaterial, PerspectiveCamera, PlaneGeometry, Scene, SpotLight, Vector2, Vector3, WebGLRenderer } from "three";
+import { CarouselItem } from "./carouselItem";
+import { CSS3DRenderer } from "three/examples/jsm/renderers/CSS3DRenderer";
+import * as TWEEN from "@tweenjs/tween.js";
+export class Carousel3dComponent {
+    constructor() {
+        this.cameraHeight = 50;
+        this.shadow = false;
+        this.selectedIndex = 0;
+        this.indexSelected = new EventEmitter();
+        this._cameraZoom = 0;
+        this._backgroundColor = 0xffffff;
+        this._ambientLight = true;
+        this._tileSize = new Vector2();
+        this._tileMargin = 20;
+        this._targetPositions = [];
+        this._tileElements = [];
+        this._tileOffset = 0;
+        this._tiles3D = [];
+        this._planeColor = 0xffffff;
+        this._planeHeight = -46;
+        this._spotLightPosition = new Vector3(0, 250, -200);
+        this._fullCircle = false;
+        this._initialized = false;
+        this._elementsCreated = false;
+        this.canNavigateLeft = false;
+        this.canNavigateRight = false;
+    }
+    set children(children) {
+        this._elementsCreated = false;
+        this._tileElements = children.toArray();
+        this._buildCarousel();
+    }
+    showClass() {
+        return true;
+    }
+    ngAfterViewInit() {
+        this._buildCarousel();
+    }
+    ngOnDestroy() {
+        this.canvasContainer = undefined;
+        this.carouselWrapper = undefined;
+        this._clearScenes();
+    }
+    handleButtonLeftClick() {
+        this._tileOffset -= 1;
+        this._rotate(400);
+    }
+    handleButtonRightClick() {
+        this._tileOffset += 1;
+        this._rotate(400);
+    }
+    _buildCarousel() {
+        if (!this._initialized) {
+            this._init();
+        }
+        if (this._initialized && !this._elementsCreated) {
+            this._createTiles();
+        }
+        this._checkNavigationButtons();
+    }
+    _init() {
+        if (!this.canvasContainer || !this.canvasContainer.nativeElement) {
+            return;
+        }
+        this._initCamera();
+        this._initScene();
+        this._initRenderer();
+        if (this.shadow) {
+            const geometry = new PlaneGeometry(10000, 10000);
+            const material = new MeshPhongMaterial({ color: this._planeColor, shininess: 100 });
+            const plane = new Mesh(geometry, material);
+            plane.receiveShadow = true;
+            plane.rotation.x = -Math.PI / 2;
+            plane.position.y = this._planeHeight;
+            this._scene.add(plane);
+            const spotLight = new SpotLight(0xffffff, 0.5);
+            spotLight.position.copy(this._spotLightPosition);
+            spotLight.castShadow = true;
+            spotLight.shadow.mapSize.width = 512;
+            spotLight.shadow.mapSize.height = 512;
+            spotLight.shadow.camera.near = 50;
+            spotLight.shadow.camera.far = 1200;
+            spotLight.shadow.camera.fov = 30;
+            spotLight.penumbra = 1;
+            this._scene.add(spotLight);
+        }
+        this.carouselWrapper.nativeElement.appendChild(this._rendererCss.domElement);
+        this.canvasContainer.nativeElement.appendChild(this.carouselWrapper.nativeElement);
+        this.canvasContainer.nativeElement.appendChild(this._renderer.domElement);
+        this._render();
+        this._animate();
+        window.addEventListener("resize", () => {
+            this._resizeCanvasToDisplaySize();
+        }, false);
+        this._initialized = true;
+    }
+    _initCamera() {
+        this._camera = new PerspectiveCamera(50, this.canvasContainer.nativeElement.clientWidth / this.canvasContainer.nativeElement.clientHeight, 1, 10000);
+        this._camera.position.z = 600 - this._cameraZoom;
+        this._camera.position.y = this.cameraHeight;
+        this._camera.lookAt(new Vector3());
+    }
+    _initScene() {
+        this._sceneCss = new Scene();
+        this._scene = new Scene();
+        this._scene.background = new Color(this._backgroundColor);
+        if (this._ambientLight) {
+            const light = new AmbientLight(0xaaaaaa); // soft white light
+            this._scene.add(light);
+            this._scene.fog = new Fog(this._backgroundColor, 70, 2500);
+        }
+    }
+    _initRenderer() {
+        this._rendererCss = new CSS3DRenderer();
+        this._rendererCss.setSize(this.canvasContainer.nativeElement.clientWidth, this.canvasContainer.nativeElement.clientHeight);
+        this._rendererCss.domElement.style.position = "absolute";
+        this._renderer = new WebGLRenderer({ antialias: true });
+        this._renderer.setPixelRatio(window.devicePixelRatio);
+        this._renderer.setSize(this.canvasContainer.nativeElement.clientWidth, this.canvasContainer.nativeElement.clientHeight);
+        this._renderer.shadowMap.enabled = true;
+    }
+    _disposeObject(obj) {
+        if (obj instanceof Mesh) {
+            if (obj.geometry) {
+                obj.geometry.dispose();
+            }
+            if (obj.material) {
+                Array.isArray(obj.material) ? obj.material.map(m => m.dispose()) : obj.material.dispose();
+            }
+            obj = undefined;
+        }
+        else {
+            obj.element = undefined;
+            obj = undefined;
+        }
+    }
+    _clearScenes() {
+        const meshes = this._tiles3D.map(t => t.mesh);
+        const cssObjs = this._tiles3D.map(t => t.object);
+        this._scene.remove(...meshes);
+        meshes.map(m => this._disposeObject(m));
+        meshes.length = 0;
+        this._sceneCss.remove(...cssObjs);
+        cssObjs.map(o => this._disposeObject(o));
+        cssObjs.length = 0;
+        this._tiles3D.length = 0;
+        this._targetPositions.length = 0;
+    }
+    _createTiles() {
+        this._clearScenes();
+        this._tileSize.x = this.tileWidth;
+        this._tileSize.y = this.tileHeight;
+        const tileWidth = this._tileSize.x + this._tileMargin;
+        const numItems = Math.max(this._tileElements.length, 20);
+        this._fullCircle = this._tileElements.length >= 20;
+        let angleTileDeg = 360 / numItems;
+        const circumference = numItems * tileWidth;
+        const radius = circumference / (Math.PI * 2);
+        const y = this.shadow ? 75 : 45;
+        const len = numItems;
+        let angleDeg = 90;
+        const position = new Vector3();
+        for (var i = 0; i < len; i++) {
+            const angle = angleDeg * (Math.PI / 180); // Radians
+            const x = radius * Math.cos(angle);
+            const z = -radius + radius * Math.sin(angle);
+            position.set(x, y, z);
+            this._targetPositions.push(position.clone());
+            if (i < this._tileElements.length) {
+                const tile = new CarouselItem({ tileSize: this._tileSize }, i, (idx) => this._rotateTo(idx));
+                tile.setPosition(position);
+                tile.setContent(this._tileElements[i].nativeElement);
+                this._scene.add(tile.mesh);
+                this._sceneCss.add(tile.object);
+                this._tiles3D.push(tile);
+            }
+            angleDeg = angleDeg - angleTileDeg; // CW instead of CCW
+        }
+        this._adjustCameraZoom();
+        this._tileOffset = this.selectedIndex;
+        this._rotate(0);
+        this._render();
+    }
+    _adjustCameraZoom() {
+        if (this._tiles3D.length === 0) {
+            return;
+        }
+        const object = this._tiles3D[0].mesh;
+        // offset = offset || 1.15;
+        // get bounding box of object - this will be used to setup controls and camera
+        const boundingBox = new Box3();
+        boundingBox.setFromObject(object);
+        const center = new Vector3();
+        boundingBox.getCenter(center);
+        const size = new Vector3();
+        boundingBox.getSize(size);
+        // get the max side of the bounding box (fits to width OR height as needed )
+        const maxDim = Math.max(size.x, size.y, size.z);
+        const fov = this._camera.fov * (Math.PI / 180);
+        // let cameraZ = Math.abs(maxDim / 4 * Math.tan(fov * 200));
+        let cameraZ = Math.abs((maxDim / 2) / Math.tan(fov / 2));
+        // cameraZ *= offset; // zoom out a little so that objects don't fill the screen
+        this._camera.position.z = cameraZ;
+        this._camera.lookAt(center);
+    }
+    _checkNavigationButtons() {
+        const currentIdx = this._getSelectedIndex();
+        this.canNavigateLeft = (currentIdx > 0) || this._fullCircle;
+        this.canNavigateRight = (currentIdx < this._tileElements.length - 1) || this._fullCircle;
+    }
+    _animate() {
+        TWEEN.update();
+        setTimeout(() => {
+            this._renderer.setAnimationLoop(() => this._animate());
+        }, 200);
+    }
+    _getSelectedIndex() {
+        return Math.max(0, Math.min(this.selectedIndex, this._tileElements.length - 1));
+    }
+    _rotate(duration) {
+        TWEEN.removeAll();
+        for (let i = 0; i < this._tiles3D.length; i++) {
+            const tile = this._tiles3D[i];
+            if (Math.abs(this._tileOffset) > this._targetPositions.length) { // full circle
+                this._tileOffset = this._tileOffset > 0 ? 1 : -1;
+            }
+            let positionIdx = i - this._tileOffset;
+            if (positionIdx > this._targetPositions.length - 1) {
+                positionIdx = positionIdx - this._targetPositions.length;
+            }
+            else if (positionIdx < 0) {
+                positionIdx = this._targetPositions.length + positionIdx;
+            }
+            const target = this._targetPositions[positionIdx];
+            new TWEEN.Tween(tile.object.position)
+                .to(target, duration)
+                .easing(TWEEN.Easing.Quartic.Out)
+                .start();
+            new TWEEN.Tween(tile.mesh.position)
+                .to(target, duration)
+                .easing(TWEEN.Easing.Quartic.Out)
+                .start();
+        }
+        new TWEEN.Tween()
+            .to({}, duration * 2)
+            .onUpdate(() => {
+            this._render();
+        })
+            .start();
+        this.selectedIndex = this._tileOffset;
+        this._checkNavigationButtons();
+        this.indexSelected.next(this._getSelectedIndex());
+    }
+    _rotateTo(index) {
+        const current = this._getSelectedIndex();
+        this._tileOffset += index - current;
+        this._rotate(800);
+    }
+    _resizeCanvasToDisplaySize() {
+        this._camera.aspect = this.canvasContainer.nativeElement.clientWidth / this.canvasContainer.nativeElement.clientHeight;
+        this._camera.updateProjectionMatrix();
+        this._rendererCss.setSize(this.canvasContainer.nativeElement.clientWidth, this.canvasContainer.nativeElement.clientHeight);
+        this._renderer.setSize(this.canvasContainer.nativeElement.clientWidth, this.canvasContainer.nativeElement.clientHeight);
+        this._render();
+    }
+    _render() {
+        this._rendererCss.render(this._sceneCss, this._camera);
+        this._renderer.render(this._scene, this._camera);
+    }
+}
+Carousel3dComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-carousel-3d",
+                template: `
+    <div class="carousel-3d-canvas-wrapper" #canvasContainer>
+      <div class="carousel-wrapper" #carouselWrapper>
+        <div class="carousel-navigate-button left">
+          <div class="carousel-navigate-button-wrapper" *ngIf="canNavigateLeft" (click)="handleButtonLeftClick()">
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 512">
+              <path
+                d="M31.7 239l136-136c9.4-9.4 24.6-9.4 33.9 0l22.6 22.6c9.4 9.4 9.4 24.6 0 33.9L127.9 256l96.4 96.4c9.4 9.4 9.4 24.6 0 33.9L201.7 409c-9.4 9.4-24.6 9.4-33.9 0l-136-136c-9.5-9.4-9.5-24.6-.1-34z"></path>
+            </svg>
+          </div>
+        </div>
+        <div class="carousel-navigate-button right">
+          <div class="carousel-navigate-button-wrapper" *ngIf="canNavigateRight" (click)="handleButtonRightClick()">
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 512">
+              <path
+                d="M224.3 273l-136 136c-9.4 9.4-24.6 9.4-33.9 0l-22.6-22.6c-9.4-9.4-9.4-24.6 0-33.9l96.4-96.4-96.4-96.4c-9.4-9.4-9.4-24.6 0-33.9L54.3 103c9.4-9.4 24.6-9.4 33.9 0l136 136c9.5 9.4 9.5 24.6.1 34z"></path>
+            </svg>
+          </div>
+        </div>
+      </div>
+    </div>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+Carousel3dComponent.propDecorators = {
+    canvasContainer: [{ type: ViewChild, args: ["canvasContainer", { read: ElementRef },] }],
+    carouselWrapper: [{ type: ViewChild, args: ["carouselWrapper", { read: ElementRef },] }],
+    children: [{ type: ContentChildren, args: ["carouselItem", { read: ElementRef, descendants: true },] }],
+    tileWidth: [{ type: Input }],
+    tileHeight: [{ type: Input }],
+    cameraHeight: [{ type: Input }],
+    shadow: [{ type: Input }],
+    selectedIndex: [{ type: Input }],
+    indexSelected: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-carousel-3d",] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"carousel-3d.component.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/components/carousel-3d/carousel-3d.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  AfterViewInit,\r\n  Component,\r\n  ContentChildren,\r\n  ElementRef,\r\n  EventEmitter,\r\n  HostBinding,\r\n  Input,\r\n  OnDestroy,\r\n  Output,\r\n  ViewChild,\r\n  ViewEncapsulation\r\n} from \"@angular/core\";\r\nimport {\r\n  AmbientLight,\r\n  Box3,\r\n  Color,\r\n  Fog,\r\n  Mesh,\r\n  MeshPhongMaterial,\r\n  PerspectiveCamera,\r\n  PlaneGeometry,\r\n  Scene,\r\n  SpotLight,\r\n  Vector2,\r\n  Vector3,\r\n  WebGLRenderer\r\n} from \"three\";\r\nimport {CarouselItem} from \"./carouselItem\";\r\nimport {CSS3DObject, CSS3DRenderer} from \"three/examples/jsm/renderers/CSS3DRenderer\";\r\nimport * as TWEEN from \"@tweenjs/tween.js\";\r\n\r\n@Component({\r\n  selector: \"co-carousel-3d\",\r\n  template: `\r\n    <div class=\"carousel-3d-canvas-wrapper\" #canvasContainer>\r\n      <div class=\"carousel-wrapper\" #carouselWrapper>\r\n        <div class=\"carousel-navigate-button left\">\r\n          <div class=\"carousel-navigate-button-wrapper\" *ngIf=\"canNavigateLeft\" (click)=\"handleButtonLeftClick()\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 256 512\">\r\n              <path\r\n                d=\"M31.7 239l136-136c9.4-9.4 24.6-9.4 33.9 0l22.6 22.6c9.4 9.4 9.4 24.6 0 33.9L127.9 256l96.4 96.4c9.4 9.4 9.4 24.6 0 33.9L201.7 409c-9.4 9.4-24.6 9.4-33.9 0l-136-136c-9.5-9.4-9.5-24.6-.1-34z\"></path>\r\n            </svg>\r\n          </div>\r\n        </div>\r\n        <div class=\"carousel-navigate-button right\">\r\n          <div class=\"carousel-navigate-button-wrapper\" *ngIf=\"canNavigateRight\" (click)=\"handleButtonRightClick()\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 256 512\">\r\n              <path\r\n                d=\"M224.3 273l-136 136c-9.4 9.4-24.6 9.4-33.9 0l-22.6-22.6c-9.4-9.4-9.4-24.6 0-33.9l96.4-96.4-96.4-96.4c-9.4-9.4-9.4-24.6 0-33.9L54.3 103c9.4-9.4 24.6-9.4 33.9 0l136 136c9.5 9.4 9.5 24.6.1 34z\"></path>\r\n            </svg>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class Carousel3dComponent implements AfterViewInit, OnDestroy {\r\n  @ViewChild(\"canvasContainer\", {read: ElementRef})\r\n  public canvasContainer: ElementRef;\r\n\r\n  @ViewChild(\"carouselWrapper\", {read: ElementRef})\r\n  public carouselWrapper: ElementRef;\r\n\r\n  @ContentChildren(\"carouselItem\", {read: ElementRef, descendants: true}) set children(children) {\r\n    this._elementsCreated = false;\r\n    this._tileElements = children.toArray();\r\n    this._buildCarousel();\r\n  }\r\n\r\n  @Input()\r\n  public tileWidth: number;\r\n\r\n  @Input()\r\n  public tileHeight: number;\r\n\r\n  @Input()\r\n  public cameraHeight: number = 50;\r\n\r\n  @Input()\r\n  public shadow: boolean = false;\r\n\r\n  @Input()\r\n  public selectedIndex: number = 0;\r\n\r\n  @Output()\r\n  public indexSelected: EventEmitter<number> = new EventEmitter<number>();\r\n\r\n  @HostBinding(\"class.co-carousel-3d\")\r\n  public showClass(): boolean {\r\n    return true;\r\n  }\r\n\r\n  private _camera: PerspectiveCamera;\r\n  private _cameraZoom: number = 0;\r\n  private _backgroundColor = 0xffffff;\r\n  private _sceneCss: Scene;\r\n  private _scene: Scene;\r\n  private _rendererCss: CSS3DRenderer;\r\n  private _renderer: WebGLRenderer;\r\n  private _ambientLight: boolean = true;\r\n  private _tileSize: Vector2 = new Vector2();\r\n  private _tileMargin: number = 20;\r\n  private _targetPositions = [];\r\n  private _tileElements: ElementRef[] = [];\r\n  private _tileOffset = 0;\r\n  private _tiles3D: CarouselItem[] = [];\r\n  private _planeColor = 0xffffff;\r\n  private _planeHeight = -46;\r\n  private _spotLightPosition: Vector3 = new Vector3(0, 250, -200);\r\n  private _fullCircle: boolean = false;\r\n  private _initialized: boolean = false;\r\n  private _elementsCreated: boolean = false;\r\n\r\n  public canNavigateLeft: boolean = false;\r\n  public canNavigateRight: boolean = false;\r\n\r\n  ngAfterViewInit(): void {\r\n      this._buildCarousel();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.canvasContainer = undefined;\r\n    this.carouselWrapper = undefined;\r\n    this._clearScenes();\r\n  }\r\n\r\n  public handleButtonLeftClick(): void {\r\n    this._tileOffset -= 1;\r\n    this._rotate(400);\r\n  }\r\n\r\n  public handleButtonRightClick(): void {\r\n    this._tileOffset += 1;\r\n    this._rotate(400);\r\n  }\r\n\r\n  private _buildCarousel(): void {\r\n    if (!this._initialized) {\r\n      this._init();\r\n    }\r\n    if (this._initialized && !this._elementsCreated) {\r\n      this._createTiles();\r\n    }\r\n    this._checkNavigationButtons();\r\n  }\r\n\r\n  private _init(): void {\r\n    if (!this.canvasContainer || !this.canvasContainer.nativeElement) {\r\n      return;\r\n    }\r\n\r\n    this._initCamera();\r\n    this._initScene();\r\n    this._initRenderer();\r\n\r\n    if (this.shadow) {\r\n      const geometry = new PlaneGeometry(10000, 10000);\r\n      const material = new MeshPhongMaterial({color: this._planeColor, shininess: 100});\r\n      const plane = new Mesh(geometry, material);\r\n      plane.receiveShadow = true;\r\n      plane.rotation.x = -Math.PI / 2;\r\n      plane.position.y = this._planeHeight;\r\n      this._scene.add(plane);\r\n\r\n      const spotLight = new SpotLight(0xffffff, 0.5);\r\n      spotLight.position.copy(this._spotLightPosition);\r\n      spotLight.castShadow = true;\r\n      spotLight.shadow.mapSize.width = 512;\r\n      spotLight.shadow.mapSize.height = 512;\r\n      spotLight.shadow.camera.near = 50;\r\n      spotLight.shadow.camera.far = 1200;\r\n      spotLight.shadow.camera.fov = 30;\r\n      spotLight.penumbra = 1;\r\n      this._scene.add(spotLight);\r\n    }\r\n\r\n    this.carouselWrapper.nativeElement.appendChild(this._rendererCss.domElement);\r\n    this.canvasContainer.nativeElement.appendChild(this.carouselWrapper.nativeElement);\r\n    this.canvasContainer.nativeElement.appendChild(this._renderer.domElement);\r\n\r\n    this._render();\r\n    this._animate();\r\n\r\n    window.addEventListener(\"resize\", () => {\r\n      this._resizeCanvasToDisplaySize();\r\n    }, false);\r\n\r\n    this._initialized = true;\r\n  }\r\n\r\n  private _initCamera(): void {\r\n    this._camera = new PerspectiveCamera(50, this.canvasContainer.nativeElement.clientWidth / this.canvasContainer.nativeElement.clientHeight, 1, 10000);\r\n    this._camera.position.z = 600 - this._cameraZoom;\r\n    this._camera.position.y = this.cameraHeight;\r\n    this._camera.lookAt(new Vector3());\r\n  }\r\n\r\n  private _initScene(): void {\r\n    this._sceneCss = new Scene();\r\n    this._scene = new Scene();\r\n    this._scene.background = new Color(this._backgroundColor);\r\n\r\n    if (this._ambientLight) {\r\n      const light = new AmbientLight(0xaaaaaa); // soft white light\r\n      this._scene.add(light);\r\n\r\n      this._scene.fog = new Fog(this._backgroundColor, 70, 2500);\r\n    }\r\n  }\r\n\r\n  private _initRenderer(): void {\r\n    this._rendererCss = new CSS3DRenderer();\r\n    this._rendererCss.setSize(this.canvasContainer.nativeElement.clientWidth, this.canvasContainer.nativeElement.clientHeight);\r\n    this._rendererCss.domElement.style.position = \"absolute\";\r\n\r\n    this._renderer = new WebGLRenderer({antialias: true});\r\n    this._renderer.setPixelRatio(window.devicePixelRatio);\r\n    this._renderer.setSize(this.canvasContainer.nativeElement.clientWidth, this.canvasContainer.nativeElement.clientHeight);\r\n    this._renderer.shadowMap.enabled = true;\r\n  }\r\n\r\n  private _disposeObject(obj: Mesh | CSS3DObject): void {\r\n    if (obj instanceof Mesh) {\r\n      if (obj.geometry) {\r\n        obj.geometry.dispose();\r\n      }\r\n      if (obj.material) {\r\n        Array.isArray(obj.material)? obj.material.map(m => m.dispose()) : obj.material.dispose();\r\n      }\r\n      obj = undefined;\r\n    } else {\r\n      obj.element = undefined;\r\n      obj = undefined;\r\n    }\r\n  }\r\n\r\n  private _clearScenes(): void {\r\n    const meshes: Mesh[] = this._tiles3D.map(t => t.mesh);\r\n    const cssObjs: CSS3DObject[] = this._tiles3D.map(t => t.object);\r\n    this._scene.remove(...meshes);\r\n    meshes.map(m => this._disposeObject(m));\r\n    meshes.length = 0;\r\n    this._sceneCss.remove(...cssObjs);\r\n    cssObjs.map(o => this._disposeObject(o));\r\n    cssObjs.length = 0;\r\n    this._tiles3D.length = 0;\r\n    this._targetPositions.length = 0;\r\n  }\r\n\r\n  private _createTiles(): void {\r\n    this._clearScenes();\r\n    this._tileSize.x = this.tileWidth;\r\n    this._tileSize.y = this.tileHeight;\r\n    const tileWidth = this._tileSize.x + this._tileMargin;\r\n    const numItems: number = Math.max(this._tileElements.length, 20);\r\n    this._fullCircle = this._tileElements.length >= 20;\r\n    let angleTileDeg: number = 360 / numItems;\r\n    const circumference: number = numItems * tileWidth;\r\n    const radius: number = circumference / (Math.PI * 2);\r\n    const y = this.shadow ? 75 : 45;\r\n\r\n    const len: number = numItems;\r\n    let angleDeg: number = 90;\r\n    const position: Vector3 = new Vector3();\r\n    for (var i = 0; i < len; i++) {\r\n      const angle = angleDeg * ( Math.PI / 180 ); // Radians\r\n      const x = radius * Math.cos(angle);\r\n      const z = -radius + radius * Math.sin(angle);\r\n      position.set(x, y, z);\r\n      this._targetPositions.push(position.clone());\r\n      if (i < this._tileElements.length) {\r\n        const tile: CarouselItem = new CarouselItem({tileSize: this._tileSize}, i, (idx: number) => this._rotateTo(idx));\r\n        tile.setPosition(position);\r\n        tile.setContent(this._tileElements[i].nativeElement);\r\n        this._scene.add(tile.mesh);\r\n        this._sceneCss.add(tile.object);\r\n        this._tiles3D.push(tile);\r\n      }\r\n      angleDeg = angleDeg - angleTileDeg; // CW instead of CCW\r\n    }\r\n    this._adjustCameraZoom();\r\n    this._tileOffset = this.selectedIndex;\r\n    this._rotate(0);\r\n    this._render();\r\n  }\r\n\r\n  private _adjustCameraZoom(): void {\r\n    if (this._tiles3D.length === 0) {\r\n      return;\r\n    }\r\n    const object = this._tiles3D[0].mesh;\r\n    // offset = offset || 1.15;\r\n\r\n    // get bounding box of object - this will be used to setup controls and camera\r\n    const boundingBox = new Box3();\r\n    boundingBox.setFromObject(object);\r\n    const center: Vector3 = new Vector3();\r\n    boundingBox.getCenter(center);\r\n    const size: Vector3 = new Vector3();\r\n    boundingBox.getSize(size);\r\n\r\n    // get the max side of the bounding box (fits to width OR height as needed )\r\n    const maxDim = Math.max(size.x, size.y, size.z);\r\n\r\n    const fov: number = this._camera.fov * (Math.PI / 180);\r\n    // let cameraZ = Math.abs(maxDim / 4 * Math.tan(fov * 200));\r\n    let cameraZ = Math.abs((maxDim / 2) / Math.tan(fov / 2));\r\n    // cameraZ *= offset; // zoom out a little so that objects don't fill the screen\r\n    this._camera.position.z = cameraZ;\r\n    this._camera.lookAt(center);\r\n  }\r\n\r\n  private _checkNavigationButtons(): void {\r\n    const currentIdx: number = this._getSelectedIndex();\r\n    this.canNavigateLeft = (currentIdx > 0) || this._fullCircle;\r\n    this.canNavigateRight = (currentIdx < this._tileElements.length - 1) || this._fullCircle;\r\n  }\r\n\r\n  private _animate() {\r\n    TWEEN.update();\r\n    setTimeout(() => {\r\n      this._renderer.setAnimationLoop(() => this._animate());\r\n    }, 200);\r\n  }\r\n\r\n  private _getSelectedIndex() {\r\n    return Math.max(0, Math.min(this.selectedIndex, this._tileElements.length - 1));\r\n  }\r\n\r\n  private _rotate(duration) {\r\n    TWEEN.removeAll();\r\n\r\n    for (let i: number = 0; i < this._tiles3D.length; i++) {\r\n      const tile = this._tiles3D[i];\r\n\r\n      if (Math.abs(this._tileOffset) > this._targetPositions.length) { // full circle\r\n        this._tileOffset = this._tileOffset > 0 ? 1 : -1;\r\n      }\r\n\r\n      let positionIdx: number = i - this._tileOffset;\r\n      if (positionIdx > this._targetPositions.length - 1) {\r\n        positionIdx = positionIdx - this._targetPositions.length;\r\n      } else if (positionIdx < 0) {\r\n        positionIdx = this._targetPositions.length + positionIdx;\r\n      }\r\n      const target = this._targetPositions[positionIdx];\r\n\r\n      new TWEEN.Tween(tile.object.position)\r\n        .to(target, duration)\r\n        .easing(TWEEN.Easing.Quartic.Out)\r\n        .start();\r\n      new TWEEN.Tween(tile.mesh.position)\r\n        .to(target, duration)\r\n        .easing(TWEEN.Easing.Quartic.Out)\r\n        .start();\r\n    }\r\n\r\n    new TWEEN.Tween()\r\n      .to({}, duration * 2)\r\n      .onUpdate(() => {\r\n        this._render();\r\n      })\r\n      .start();\r\n\r\n    this.selectedIndex = this._tileOffset;\r\n    this._checkNavigationButtons();\r\n    this.indexSelected.next(this._getSelectedIndex());\r\n  }\r\n\r\n  private _rotateTo(index: number) {\r\n    const current = this._getSelectedIndex();\r\n    this._tileOffset += index - current;\r\n    this._rotate(800);\r\n  }\r\n\r\n  private _resizeCanvasToDisplaySize() {\r\n    this._camera.aspect = this.canvasContainer.nativeElement.clientWidth / this.canvasContainer.nativeElement.clientHeight;\r\n    this._camera.updateProjectionMatrix();\r\n\r\n    this._rendererCss.setSize(this.canvasContainer.nativeElement.clientWidth, this.canvasContainer.nativeElement.clientHeight);\r\n    this._renderer.setSize(this.canvasContainer.nativeElement.clientWidth, this.canvasContainer.nativeElement.clientHeight);\r\n    this._render();\r\n  }\r\n\r\n  private _render() {\r\n    this._rendererCss.render(this._sceneCss, this._camera);\r\n    this._renderer.render(this._scene, this._camera);\r\n  }\r\n\r\n}\r\n"]}

package/esm2015/lib/components/carousel-3d/carousel-3d.module.js

@@ -0,0 +1,19 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { Carousel3dComponent } from "./carousel-3d.component";
+export class Carousel3dModule {
+}
+Carousel3dModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule
+                ],
+                declarations: [
+                    Carousel3dComponent
+                ],
+                exports: [
+                    Carousel3dComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2Fyb3VzZWwtM2QubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29yZWNvbXBvbmVudHMvc3JjL2xpYi9jb21wb25lbnRzL2Nhcm91c2VsLTNkL2Nhcm91c2VsLTNkLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsbUJBQW1CLEVBQUMsTUFBTSx5QkFBeUIsQ0FBQztBQWE1RCxNQUFNLE9BQU8sZ0JBQWdCOzs7WUFYNUIsUUFBUSxTQUFDO2dCQUNSLE9BQU8sRUFBRTtvQkFDUCxZQUFZO2lCQUNiO2dCQUNELFlBQVksRUFBRTtvQkFDWixtQkFBbUI7aUJBQ3BCO2dCQUNELE9BQU8sRUFBRTtvQkFDUCxtQkFBbUI7aUJBQ3BCO2FBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vblwiO1xyXG5pbXBvcnQge0Nhcm91c2VsM2RDb21wb25lbnR9IGZyb20gXCIuL2Nhcm91c2VsLTNkLmNvbXBvbmVudFwiO1xyXG5cclxuQE5nTW9kdWxlKHtcclxuICBpbXBvcnRzOiBbXHJcbiAgICBDb21tb25Nb2R1bGVcclxuICBdLFxyXG4gIGRlY2xhcmF0aW9uczogW1xyXG4gICAgQ2Fyb3VzZWwzZENvbXBvbmVudFxyXG4gIF0sXHJcbiAgZXhwb3J0czogW1xyXG4gICAgQ2Fyb3VzZWwzZENvbXBvbmVudFxyXG4gIF1cclxufSlcclxuZXhwb3J0IGNsYXNzIENhcm91c2VsM2RNb2R1bGUge1xyXG59XHJcbiJdfQ==

package/esm2015/lib/components/carousel-3d/carouselItem.js

@@ -0,0 +1,54 @@
+import { CSS3DObject } from "three/examples/jsm/renderers/CSS3DRenderer";
+import { Mesh, PlaneBufferGeometry } from "three";
+export class CarouselItem {
+    constructor(options, index, onClick) {
+        var _a, _b;
+        this._options = options || {};
+        this.index = index;
+        const width = ((_a = this._options.tileSize) === null || _a === void 0 ? void 0 : _a.x) || 0;
+        const height = ((_b = this._options.tileSize) === null || _b === void 0 ? void 0 : _b.y) || 0;
+        this._element = document.createElement('div');
+        // this._element.style.backgroundColor = this._options.tileBackgroundColor;
+        this._element.style.width = width + "px";
+        this._element.style.height = height + "px";
+        this._element.addEventListener("click", () => {
+            if (onClick) {
+                onClick(this.index);
+            }
+        }, false);
+        this.object = new CSS3DObject(this._element);
+        const geometry = new PlaneBufferGeometry(width, height);
+        this.mesh = new Mesh(geometry, options.tileMaterial);
+        this.mesh.castShadow = true;
+    }
+    setPosition(position) {
+        if (this.mesh) {
+            this.mesh.position.copy(position);
+        }
+        if (this.object) {
+            this.object.position.copy(position);
+        }
+    }
+    setContent(content) {
+        if (this._element) {
+            // remove any exising tile content before setting new content
+            while (this._element.lastElementChild) {
+                this._element.removeChild(this._element.lastElementChild);
+            }
+            try {
+                this._element.appendChild(content);
+            }
+            catch (err) {
+            }
+        }
+    }
+    setVisible(visible) {
+        if (this.mesh) {
+            this.mesh.visible = visible;
+        }
+        if (this.object) {
+            this.object.visible = visible;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/co-dialog/co-dialog.module.js

@@ -2,18 +2,16 @@ import { NgModule } from "@angular/core";
 import { CoDialogComponent } from "./co-dialog.component";
 import { IconModule } from "../icon/icon.module";
 import { CommonModule } from "@angular/common";
-import { BrowserAnimationsModule } from "@angular/platform-browser/animations";
 export class CoDialogModule {
 }
 CoDialogModule.decorators = [
     { type: NgModule, args: [{
                 imports: [
                     CommonModule,
-                    BrowserAnimationsModule,
                     IconModule
                 ],
                 declarations: [CoDialogComponent],
                 exports: [CoDialogComponent]
             },] }
 ];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY28tZGlhbG9nLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmVjb21wb25lbnRzL3NyYy9saWIvY29tcG9uZW50cy9jby1kaWFsb2cvY28tZGlhbG9nLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxpQkFBaUIsRUFBQyxNQUFNLHVCQUF1QixDQUFDO0FBQ3hELE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDN0MsT0FBTyxFQUFDLHVCQUF1QixFQUFDLE1BQU0sc0NBQXNDLENBQUM7QUFXN0UsTUFBTSxPQUFPLGNBQWM7OztZQVQxQixRQUFRLFNBQUM7Z0JBQ1IsT0FBTyxFQUFFO29CQUNQLFlBQVk7b0JBQ1osdUJBQXVCO29CQUN2QixVQUFVO2lCQUNYO2dCQUNDLFlBQVksRUFBRSxDQUFDLGlCQUFpQixDQUFDO2dCQUNqQyxPQUFPLEVBQUUsQ0FBQyxpQkFBaUIsQ0FBQzthQUMvQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7TmdNb2R1bGV9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7Q29EaWFsb2dDb21wb25lbnR9IGZyb20gXCIuL2NvLWRpYWxvZy5jb21wb25lbnRcIjtcclxuaW1wb3J0IHtJY29uTW9kdWxlfSBmcm9tIFwiLi4vaWNvbi9pY29uLm1vZHVsZVwiO1xyXG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vblwiO1xyXG5pbXBvcnQge0Jyb3dzZXJBbmltYXRpb25zTW9kdWxlfSBmcm9tIFwiQGFuZ3VsYXIvcGxhdGZvcm0tYnJvd3Nlci9hbmltYXRpb25zXCI7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGltcG9ydHM6IFtcclxuICAgIENvbW1vbk1vZHVsZSxcclxuICAgIEJyb3dzZXJBbmltYXRpb25zTW9kdWxlLFxyXG4gICAgSWNvbk1vZHVsZVxyXG4gIF0sXHJcbiAgICBkZWNsYXJhdGlvbnM6IFtDb0RpYWxvZ0NvbXBvbmVudF0sXHJcbiAgICBleHBvcnRzOiBbQ29EaWFsb2dDb21wb25lbnRdXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBDb0RpYWxvZ01vZHVsZSB7XHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY28tZGlhbG9nLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmVjb21wb25lbnRzL3NyYy9saWIvY29tcG9uZW50cy9jby1kaWFsb2cvY28tZGlhbG9nLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxpQkFBaUIsRUFBQyxNQUFNLHVCQUF1QixDQUFDO0FBQ3hELE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFVN0MsTUFBTSxPQUFPLGNBQWM7OztZQVIxQixRQUFRLFNBQUM7Z0JBQ1IsT0FBTyxFQUFFO29CQUNQLFlBQVk7b0JBQ1osVUFBVTtpQkFDWDtnQkFDQyxZQUFZLEVBQUUsQ0FBQyxpQkFBaUIsQ0FBQztnQkFDakMsT0FBTyxFQUFFLENBQUMsaUJBQWlCLENBQUM7YUFDL0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5pbXBvcnQge0NvRGlhbG9nQ29tcG9uZW50fSBmcm9tIFwiLi9jby1kaWFsb2cuY29tcG9uZW50XCI7XHJcbmltcG9ydCB7SWNvbk1vZHVsZX0gZnJvbSBcIi4uL2ljb24vaWNvbi5tb2R1bGVcIjtcclxuaW1wb3J0IHtDb21tb25Nb2R1bGV9IGZyb20gXCJAYW5ndWxhci9jb21tb25cIjtcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgaW1wb3J0czogW1xyXG4gICAgQ29tbW9uTW9kdWxlLFxyXG4gICAgSWNvbk1vZHVsZVxyXG4gIF0sXHJcbiAgICBkZWNsYXJhdGlvbnM6IFtDb0RpYWxvZ0NvbXBvbmVudF0sXHJcbiAgICBleHBvcnRzOiBbQ29EaWFsb2dDb21wb25lbnRdXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBDb0RpYWxvZ01vZHVsZSB7XHJcbn1cclxuIl19

package/esm2015/lib/components/drop-down-list/drop-down-list.component.js

@@ -1,15 +1,25 @@
-import { ChangeDetectionStrategy, Component, forwardRef, HostBinding, Input, ViewEncapsulation } from "@angular/core";
+import { ChangeDetectorRef, Component, ComponentFactoryResolver, ElementRef, forwardRef, HostBinding, Input, Optional, ViewEncapsulation } from "@angular/core";
 import { COMPONENT_INTERFACE_NAME } from "../base/component-interface-name";
 import { BaseInputComponent } from "../base/base-input.component";
 import { CheckBoxSelectionService } from "@syncfusion/ej2-angular-dropdowns";
+import { FormInputUserModelChangeListenerService } from "../../core/service/form-input-user-change-listener.service";
+import { NgZoneWrapperService } from "../../core/service/ng-zone-wrapper.service";
+import { FormComponent } from "../form/form.component";
 export class DropDownListComponent extends BaseInputComponent {
-    constructor() {
-        super(...arguments);
+    constructor(formComponent, changeDetector, componentFactoryResolver, formUserChangeListener, ngZoneWrapper, elementRef) {
+        super(changeDetector, componentFactoryResolver, formUserChangeListener, ngZoneWrapper, elementRef);
+        this.formComponent = formComponent;
+        this.changeDetector = changeDetector;
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.formUserChangeListener = formUserChangeListener;
+        this.ngZoneWrapper = ngZoneWrapper;
+        this.elementRef = elementRef;
         /**
          * In the form { text: 'name', value: 'id' }
          * Where 'text' is showing in the dropdown and 'id' used for the model binding
          */
         this.fields = {};
+        super._markAsOnPush();
     }
     showClass() {
         return true;
@@ -28,15 +38,20 @@ DropDownListComponent.decorators = [
       [dataSource]="collection"
       [value]="model"
       [fields]="fields"
-      [placeholder]="placeHolder"
-      [cssClass]="'co-drop-down-list'"
+      [placeholder]="placeholder"
       [readonly]="readonly"
       [itemTemplate]="itemTemplate"
       [headerTemplate]="headerTemplate"
       [valueTemplate]="valueTemplate"
+      [ngModel]="model"
+      (ngModelChange)="modelChange.emit($event)"
       (valueChange)="handleValueChanged($event)"
+      showClearButton="true"
+      floatLabelType="Auto"
     >
     </ejs-dropdownlist>
+    <div class="required-indicator"></div>
+    <ng-template #validationError></ng-template>
   `,
                 providers: [
                     CheckBoxSelectionService,
@@ -45,17 +60,24 @@ DropDownListComponent.decorators = [
                         useExisting: forwardRef(() => DropDownListComponent)
                     }
                 ],
-                changeDetection: ChangeDetectionStrategy.OnPush,
                 encapsulation: ViewEncapsulation.None
             },] }
 ];
+DropDownListComponent.ctorParameters = () => [
+    { type: FormComponent, decorators: [{ type: Optional }] },
+    { type: ChangeDetectorRef },
+    { type: ComponentFactoryResolver },
+    { type: FormInputUserModelChangeListenerService },
+    { type: NgZoneWrapperService },
+    { type: ElementRef }
+];
 DropDownListComponent.propDecorators = {
     collection: [{ type: Input }],
     fields: [{ type: Input }],
-    placeHolder: [{ type: Input }],
+    placeholder: [{ type: Input }],
     itemTemplate: [{ type: Input }],
     headerTemplate: [{ type: Input }],
     valueTemplate: [{ type: Input }],
     showClass: [{ type: HostBinding, args: ["class.co-drop-down-list",] }]
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/drop-down-list/drop-down.module.js

@@ -1,8 +1,9 @@
-import { NgModule } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { BaseModule } from '../base/base.module';
-import { DropDownListComponent } from './drop-down-list.component';
-import { DropDownListModule, MultiSelectModule } from '@syncfusion/ej2-angular-dropdowns';
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { BaseModule } from "../base/base.module";
+import { DropDownListComponent } from "./drop-down-list.component";
+import { DropDownListModule, MultiSelectModule } from "@syncfusion/ej2-angular-dropdowns";
+import { FormsModule } from "@angular/forms";
 export class DropDownModule {
 }
 DropDownModule.decorators = [
@@ -11,10 +12,11 @@ DropDownModule.decorators = [
                     BaseModule,
                     CommonModule,
                     DropDownListModule,
-                    MultiSelectModule
+                    MultiSelectModule,
+                    FormsModule
                 ],
                 declarations: [DropDownListComponent],
                 exports: [DropDownListComponent]
             },] }
 ];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJvcC1kb3duLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmVjb21wb25lbnRzL3NyYy9saWIvY29tcG9uZW50cy9kcm9wLWRvd24tbGlzdC9kcm9wLWRvd24ubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNqRCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUNuRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQVkxRixNQUFNLE9BQU8sY0FBYzs7O1lBVjFCLFFBQVEsU0FBQztnQkFDTixPQUFPLEVBQUU7b0JBQ0wsVUFBVTtvQkFDVixZQUFZO29CQUNaLGtCQUFrQjtvQkFDbEIsaUJBQWlCO2lCQUNwQjtnQkFDRCxZQUFZLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztnQkFDckMsT0FBTyxFQUFFLENBQUMscUJBQXFCLENBQUM7YUFDbkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xyXG5pbXBvcnQgeyBCYXNlTW9kdWxlIH0gZnJvbSAnLi4vYmFzZS9iYXNlLm1vZHVsZSc7XHJcbmltcG9ydCB7IERyb3BEb3duTGlzdENvbXBvbmVudCB9IGZyb20gJy4vZHJvcC1kb3duLWxpc3QuY29tcG9uZW50JztcclxuaW1wb3J0IHsgRHJvcERvd25MaXN0TW9kdWxlLCBNdWx0aVNlbGVjdE1vZHVsZSB9IGZyb20gJ0BzeW5jZnVzaW9uL2VqMi1hbmd1bGFyLWRyb3Bkb3ducyc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gICAgaW1wb3J0czogW1xyXG4gICAgICAgIEJhc2VNb2R1bGUsXHJcbiAgICAgICAgQ29tbW9uTW9kdWxlLFxyXG4gICAgICAgIERyb3BEb3duTGlzdE1vZHVsZSxcclxuICAgICAgICBNdWx0aVNlbGVjdE1vZHVsZVxyXG4gICAgXSxcclxuICAgIGRlY2xhcmF0aW9uczogW0Ryb3BEb3duTGlzdENvbXBvbmVudF0sXHJcbiAgICBleHBvcnRzOiBbRHJvcERvd25MaXN0Q29tcG9uZW50XVxyXG59KVxyXG5leHBvcnQgY2xhc3MgRHJvcERvd25Nb2R1bGUge1xyXG59XHJcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJvcC1kb3duLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmVjb21wb25lbnRzL3NyYy9saWIvY29tcG9uZW50cy9kcm9wLWRvd24tbGlzdC9kcm9wLWRvd24ubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBQzdDLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEVBQUMscUJBQXFCLEVBQUMsTUFBTSw0QkFBNEIsQ0FBQztBQUNqRSxPQUFPLEVBQUMsa0JBQWtCLEVBQUUsaUJBQWlCLEVBQUMsTUFBTSxtQ0FBbUMsQ0FBQztBQUN4RixPQUFPLEVBQUMsV0FBVyxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFhM0MsTUFBTSxPQUFPLGNBQWM7OztZQVgxQixRQUFRLFNBQUM7Z0JBQ04sT0FBTyxFQUFFO29CQUNMLFVBQVU7b0JBQ1YsWUFBWTtvQkFDWixrQkFBa0I7b0JBQ2xCLGlCQUFpQjtvQkFDakIsV0FBVztpQkFDZDtnQkFDRCxZQUFZLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztnQkFDckMsT0FBTyxFQUFFLENBQUMscUJBQXFCLENBQUM7YUFDbkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vblwiO1xyXG5pbXBvcnQge0Jhc2VNb2R1bGV9IGZyb20gXCIuLi9iYXNlL2Jhc2UubW9kdWxlXCI7XHJcbmltcG9ydCB7RHJvcERvd25MaXN0Q29tcG9uZW50fSBmcm9tIFwiLi9kcm9wLWRvd24tbGlzdC5jb21wb25lbnRcIjtcclxuaW1wb3J0IHtEcm9wRG93bkxpc3RNb2R1bGUsIE11bHRpU2VsZWN0TW9kdWxlfSBmcm9tIFwiQHN5bmNmdXNpb24vZWoyLWFuZ3VsYXItZHJvcGRvd25zXCI7XHJcbmltcG9ydCB7Rm9ybXNNb2R1bGV9IGZyb20gXCJAYW5ndWxhci9mb3Jtc1wiO1xyXG5cclxuQE5nTW9kdWxlKHtcclxuICAgIGltcG9ydHM6IFtcclxuICAgICAgICBCYXNlTW9kdWxlLFxyXG4gICAgICAgIENvbW1vbk1vZHVsZSxcclxuICAgICAgICBEcm9wRG93bkxpc3RNb2R1bGUsXHJcbiAgICAgICAgTXVsdGlTZWxlY3RNb2R1bGUsXHJcbiAgICAgICAgRm9ybXNNb2R1bGVcclxuICAgIF0sXHJcbiAgICBkZWNsYXJhdGlvbnM6IFtEcm9wRG93bkxpc3RDb21wb25lbnRdLFxyXG4gICAgZXhwb3J0czogW0Ryb3BEb3duTGlzdENvbXBvbmVudF1cclxufSlcclxuZXhwb3J0IGNsYXNzIERyb3BEb3duTW9kdWxlIHtcclxufVxyXG4iXX0=