@colijnit/corecomponents_v12 12.2.21 → 12.2.22

package/esm2015/lib/components/carousel/carousel.component.js

@@ -0,0 +1,130 @@
+import { __awaiter } from "tslib";
+import { Component, ContentChildren, ElementRef, HostBinding, ViewChild, ViewEncapsulation } from '@angular/core';
+import 'hammerjs';
+export class CarouselComponent {
+    constructor() {
+        this.canNavigateLeft = false;
+        this.canNavigateRight = false;
+        this.activeIndex = 0;
+        this.ro = new ResizeObserver(entries => {
+            this._checkNavigationButtons();
+        });
+        this._disableButtons = false;
+    }
+    set containerChild(child) {
+        if (child) {
+            this.container = child;
+            this._checkNavigationButtons();
+            this.ro.observe(this.container.nativeElement);
+        }
+    }
+    set contentChildren(content) {
+        if (content) {
+            this.carouselItems = content.toArray();
+        }
+        this._checkNavigationButtons();
+    }
+    showClass() {
+        return true;
+    }
+    ngOnDestroy() {
+        for (let i = this.carouselItems.length - 1; i >= 0; i--) {
+            this.carouselItems[i] = undefined;
+        }
+        this.container = undefined;
+    }
+    handlePress(event) {
+        console.log(event);
+    }
+    handleSwipe(event) {
+        const x = Math.abs(event.deltaX) > 40 ? (event.deltaX > 0 ? 'right' : 'left') : '';
+        const y = Math.abs(event.deltaY) > 40 ? (event.deltaY > 0 ? 'down' : 'up') : '';
+        console.log(`${x} ${y}`);
+    }
+    handleButtonLeftClick() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._navigate();
+        });
+    }
+    handleButtonRightClick() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._navigate(true);
+        });
+    }
+    _navigate(right = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._disableButtons) {
+                return;
+            }
+            this._disableButtons = true;
+            const wantedIndex = this.activeIndex + (right ? 1 : -1);
+            const left = this._getLeftPositionFromActiveItem(wantedIndex);
+            if (left !== null) {
+                if (yield this._scrollWrapper(left)) {
+                    this.activeIndex = wantedIndex;
+                }
+            }
+            this._checkNavigationButtons();
+            this._disableButtons = false;
+        });
+    }
+    _checkNavigationButtons() {
+        if (this.container && this.container.nativeElement) {
+            this.canNavigateLeft = this.container.nativeElement.scrollLeft > 0;
+            this.canNavigateRight = this.container.nativeElement.scrollLeft + this.container.nativeElement.clientWidth < this.container.nativeElement.scrollWidth;
+        }
+    }
+    _getLeftPositionFromActiveItem(index) {
+        const element = this.carouselItems[index];
+        return element ? element.nativeElement.offsetLeft : null;
+    }
+    _scrollWrapper(left) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                if (this.container && this.container.nativeElement) {
+                    const oldScroll = this.container.nativeElement.scrollLeft;
+                    this.container.nativeElement.scrollLeft = left;
+                    setTimeout(() => {
+                        return resolve(oldScroll !== this.container.nativeElement.scrollLeft);
+                    }, 400);
+                }
+                else {
+                    return resolve(false);
+                }
+            });
+        });
+    }
+}
+CarouselComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'co-carousel',
+                template: `
+    <div class="carousel-wrapper" #container (swipeleft)="handleButtonRightClick()" (swiperight)="handleButtonLeftClick()">
+      <ng-content></ng-content>
+    </div>
+    <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>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+CarouselComponent.propDecorators = {
+    containerChild: [{ type: ViewChild, args: ['container', { read: ElementRef },] }],
+    contentChildren: [{ type: ContentChildren, args: ['carouselItem', { read: ElementRef, descendants: true },] }],
+    showClass: [{ type: HostBinding, args: ['class.co-carousel',] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"carousel.component.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/components/carousel/carousel.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, ContentChildren, ElementRef, HostBinding, OnDestroy, ViewChild, ViewEncapsulation} from '@angular/core';\r\nimport 'hammerjs';\r\n\r\n@Component({\r\n  selector: 'co-carousel',\r\n  template: `\r\n    <div class=\"carousel-wrapper\" #container (swipeleft)=\"handleButtonRightClick()\" (swiperight)=\"handleButtonLeftClick()\">\r\n      <ng-content></ng-content>\r\n    </div>\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  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class CarouselComponent implements OnDestroy {\r\n  @ViewChild('container', { read: ElementRef }) set containerChild(child) {\r\n    if (child) {\r\n      this.container = child;\r\n      this._checkNavigationButtons();\r\n      this.ro.observe(this.container.nativeElement);\r\n    }\r\n  }\r\n\r\n  @ContentChildren('carouselItem', { read: ElementRef, descendants: true }) set contentChildren(content) {\r\n    if (content) {\r\n      this.carouselItems = content.toArray();\r\n    }\r\n    this._checkNavigationButtons();\r\n  }\r\n\r\n  @HostBinding('class.co-carousel')\r\n  public showClass() {\r\n    return true;\r\n  }\r\n\r\n  public carouselItems: ElementRef[];\r\n  public canNavigateLeft: boolean = false;\r\n  public canNavigateRight: boolean = false;\r\n  public container: ElementRef;\r\n  public activeIndex: number = 0;\r\n  public ro: ResizeObserver = new ResizeObserver(entries => {\r\n    this._checkNavigationButtons();\r\n  });\r\n\r\n  private _disableButtons: boolean = false;\r\n\r\n  ngOnDestroy(): void {\r\n    for (let i = this.carouselItems.length - 1; i >= 0; i--) {\r\n      this.carouselItems[i] = undefined;\r\n    }\r\n    this.container = undefined;\r\n  }\r\n\r\n  public handlePress(event): void {\r\n    console.log(event);\r\n  }\r\n\r\n  public handleSwipe(event): void {\r\n    const x = Math.abs(event.deltaX) > 40 ? (event.deltaX > 0 ? 'right' : 'left'):'';\r\n    const y = Math.abs(event.deltaY) > 40 ? (event.deltaY > 0 ? 'down' : 'up') : '';\r\n\r\n    console.log(`${x} ${y}`);\r\n  }\r\n\r\n  public async handleButtonLeftClick(): Promise<void> {\r\n    this._navigate();\r\n  }\r\n\r\n  public async handleButtonRightClick(): Promise<void> {\r\n    this._navigate(true);\r\n  }\r\n\r\n  private async _navigate(right: boolean = false): Promise<void> {\r\n    if (this._disableButtons) {\r\n      return;\r\n    }\r\n    this._disableButtons = true;\r\n    const wantedIndex: number = this.activeIndex + (right ? 1 : -1);\r\n    const left: number = this._getLeftPositionFromActiveItem(wantedIndex);\r\n    if (left !== null) {\r\n      if (await this._scrollWrapper(left)) {\r\n        this.activeIndex = wantedIndex;\r\n      }\r\n    }\r\n    this._checkNavigationButtons();\r\n    this._disableButtons = false;\r\n  }\r\n\r\n  private _checkNavigationButtons(): void {\r\n    if (this.container && this.container.nativeElement) {\r\n      this.canNavigateLeft = this.container.nativeElement.scrollLeft > 0;\r\n      this.canNavigateRight = this.container.nativeElement.scrollLeft + this.container.nativeElement.clientWidth < this.container.nativeElement.scrollWidth;\r\n    }\r\n  }\r\n\r\n  private _getLeftPositionFromActiveItem(index: number): number {\r\n    const element = this.carouselItems[index];\r\n    return element ? element.nativeElement.offsetLeft : null;\r\n  }\r\n\r\n  private async _scrollWrapper(left: number): Promise<boolean> {\r\n    return new Promise((resolve: Function) => {\r\n      if (this.container && this.container.nativeElement) {\r\n        const oldScroll: number = this.container.nativeElement.scrollLeft;\r\n        this.container.nativeElement.scrollLeft = left;\r\n        setTimeout(() => {\r\n          return resolve(oldScroll !== this.container.nativeElement.scrollLeft);\r\n        }, 400)\r\n      } else {\r\n        return resolve(false);\r\n      }\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2015/lib/components/carousel/carousel.module.js

@@ -0,0 +1,32 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { CarouselComponent } from './carousel.component';
+import { HAMMER_GESTURE_CONFIG, HammerGestureConfig, HammerModule } from '@angular/platform-browser';
+export class CarouselHammerConfig extends HammerGestureConfig {
+    constructor() {
+        super(...arguments);
+        this.overrides = {
+            swipe: { direction: Hammer.DIRECTION_HORIZONTAL },
+        };
+    }
+}
+export class CarouselModule {
+}
+CarouselModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    HammerModule
+                ],
+                declarations: [
+                    CarouselComponent
+                ],
+                exports: [
+                    CarouselComponent
+                ],
+                providers: [
+                    { provide: HAMMER_GESTURE_CONFIG, useClass: CarouselHammerConfig },
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,315 @@
+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();
+        this._resizeCanvasToDisplaySize();
+    }
+    _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);
+        this._camera.position.z = Math.abs((maxDim / 2) * Math.atan(this._camera.fov / 2));
+        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() {
+        setTimeout(() => {
+            if (!this.canvasContainer || !this.canvasContainer.nativeElement) {
+                return;
+            }
+            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    this._resizeCanvasToDisplaySize();\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    this._camera.position.z = Math.abs((maxDim / 2) * Math.atan(this._camera.fov / 2));\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    setTimeout(() => {\r\n      if (!this.canvasContainer || !this.canvasContainer.nativeElement) {\r\n        return;\r\n      }\r\n      this._camera.aspect = this.canvasContainer.nativeElement.clientWidth / this.canvasContainer.nativeElement.clientHeight;\r\n      this._camera.updateProjectionMatrix();\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\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==