@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/lite-selector/lite-selector/lite-selector.component.js

@@ -0,0 +1,150 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Component, EventEmitter, HostBinding, Input, Output, TemplateRef, ViewChild } from '@angular/core';
+import { animate, state, style, transition, trigger } from '@angular/animations';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/service/homedecorator-connector.service";
+import * as i2 from "../../threedselector/threedselector/service/build-furniture.service";
+import * as i3 from "../../../core/service/homedecorator-settings.service";
+import * as i4 from "./component/selections-summary/selections-summary.component";
+import * as i5 from "./component/answers-slideout/answers-slideout.component";
+import * as i6 from "@angular/common";
+export class LiteSelectorComponent {
+    constructor(iOne, buildFurnitureService, _settingsService) {
+        this.iOne = iOne;
+        this.buildFurnitureService = buildFurnitureService;
+        this._settingsService = _settingsService;
+        this.showLabel = true;
+        this.canClose = true;
+        this.customDimensions = false;
+        this.showChange = new EventEmitter();
+        this.answerChosen = new EventEmitter();
+        this.inlineAnswers = false;
+        this.animateSlideout = true;
+        this._answersShowing = false;
+        this._showSelections = false;
+        this._subs = [];
+        this._subs.push(this.iOne.answersReceived.subscribe((answers) => {
+            this.answerToShowFromSelectionText =
+                this.inlineAnswers && answers.length > 0 && this._selectionSelected ?
+                    this._selectionSelected.question :
+                    undefined;
+            this._answersShowing = answers.length > 0;
+        }), this._settingsService.settingsLoaded.subscribe((loaded) => {
+            if (loaded) {
+                this.inlineAnswers = this._settingsService.settings.options ? this._settingsService.settings.options.inlineAnswers : false;
+            }
+        }));
+    }
+    set showAnswers(value) {
+        this._showAnswers = value;
+        if (!this.showAnswers) {
+            setTimeout(() => {
+                this.animateSlideout = true;
+            }, 400);
+        }
+        else {
+            this.animateSlideout = false;
+        }
+    }
+    get showAnswers() {
+        return this._showAnswers;
+    }
+    set showSelections(value) {
+        this._showSelections = value;
+    }
+    get showSelections() {
+        return this._showSelections;
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+        this.templateAnswers = undefined;
+    }
+    onCloseLiteSelectorButtonClick() {
+        this.show = false;
+        this.showChange.emit(false);
+    }
+    // todo: move to threedselector.component to be able to handle errors?
+    onSelectionsSummarySelectSelection(selection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.inlineAnswers && this.answerToShowFromSelectionText) {
+                if (this._selectionSelected !== selection) {
+                    if (this._answersShowing) {
+                        yield this.buildFurnitureService.cancelAnswer(this.metadata, false);
+                    }
+                    yield this.buildFurnitureService.selectSelection(selection, this.metadata);
+                }
+                else {
+                    if (this._answersShowing) {
+                        yield this.buildFurnitureService.cancelAnswer(this.metadata, false);
+                    }
+                }
+            }
+            else {
+                yield this.buildFurnitureService.selectSelection(selection, this.metadata);
+            }
+            this._selectionSelected = selection;
+        });
+    }
+    onAnswersSlideoutAnswerChosen(answerSelected) {
+        this._answersShowing = false;
+        this.buildFurnitureService.selectAnswer(answerSelected.answer, answerSelected.input, this.metadata);
+        this.answerChosen.next(answerSelected.answer);
+        // this.iOne.getMoodImageForAnswerSelection(answerSelected.answer, false);
+    }
+}
+LiteSelectorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LiteSelectorComponent, deps: [{ token: i1.HomedecoratorConnectorService }, { token: i2.BuildFurnitureService }, { token: i3.HomedecoratorSettingsService }], target: i0.ɵɵFactoryTarget.Component });
+LiteSelectorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: LiteSelectorComponent, selector: "rp-lite-selector", inputs: { showAnswers: "showAnswers", show: "show", showSelections: "showSelections", showLabel: "showLabel", canClose: "canClose", metadata: "metadata", customDimensions: "customDimensions" }, outputs: { showChange: "showChange", answerChosen: "answerChosen" }, host: { properties: { "class.custom-dimensions": "this.customDimensions" } }, viewQueries: [{ propertyName: "templateAnswers", first: true, predicate: ["templateAnswers"], descendants: true, read: TemplateRef, static: true }], ngImport: i0, template: "<ng-container *ngIf=\"show\">\r\n  <rp-selections-summary *ngIf=\"showSelections && iOne.selectionsToDisplay.length > 0\" @showSelections [@.disabled]=\"!animateSlideout\"\r\n                         class=\"rp-selections-summary\"\r\n                         [showLabel]=\"showLabel\"\r\n                         [canClose]=\"canClose\"\r\n                         [customDimensions]=\"customDimensions\"\r\n                         [answersTemplate]=\"inlineAnswers ? templateAnswers : undefined\"\r\n                         [answerToShowFromSelectionText]=\"answerToShowFromSelectionText\"\r\n                         [selections]=\"iOne.selectionsToDisplay\"\r\n                         (selectSelection)=\"onSelectionsSummarySelectSelection($event)\"\r\n                         (closeClick)=\"onCloseLiteSelectorButtonClick()\"\r\n  >\r\n  </rp-selections-summary>\r\n  <ng-container *ngIf=\"!inlineAnswers\" [ngTemplateOutlet]=\"templateAnswers\"></ng-container>\r\n</ng-container>\r\n\r\n<ng-template #templateAnswers>\r\n  <rp-answers-slideout\r\n    class=\"rp-answers-slideout\"\r\n    [metadata]=\"metadata\"\r\n    [isShown]=\"showAnswers && buildFurnitureService.activeAnswers.length > 0\"\r\n    [showTitle]=\"!inlineAnswers\"\r\n    [showFilter]=\"!inlineAnswers\"\r\n    [useSlideout]=\"!inlineAnswers\"\r\n    [customDimensions]=\"customDimensions\"\r\n    [question]=\"buildFurnitureService.activeQuestion\"\r\n    [answers]=\"buildFurnitureService.activeAnswers\"\r\n    (answerChosen)=\"onAnswersSlideoutAnswerChosen($event)\"\r\n  ></rp-answers-slideout>\r\n</ng-template>\r\n", styles: [":host.floating ::ng-deep rp-selections-summary{position:absolute;right:0;max-height:calc(100vh - 120px)}:host:not(.custom-dimensions).floating ::ng-deep rp-selections-summary{top:64px;max-height:calc(100vh - 184px)}\n"], components: [{ type: i4.SelectionsSummaryComponent, selector: "rp-selections-summary", inputs: ["selections", "showLabel", "canClose", "answersTemplate", "answerToShowFromSelectionText", "customDimensions"], outputs: ["closeClick", "cancelAnswers", "selectSelection"] }, { type: i5.AnswersSlideoutComponent, selector: "rp-answers-slideout", inputs: ["isShown", "question", "showTitle", "showFilter", "metadata", "answers", "useSlideout", "customDimensions"], outputs: ["isShownChange", "answerChosen"] }], directives: [{ type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i6.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], animations: [
+        trigger('showSelections', [
+            state('void', style({ 'transform': 'translateX(100%)', opacity: 0 })),
+            state('*', style({ 'transform': 'translateX(0%)', opacity: 1 })),
+            transition('void <=> *', animate(200))
+        ])
+    ] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LiteSelectorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'rp-lite-selector',
+                    templateUrl: './lite-selector.component.html',
+                    styleUrls: ['./lite-selector.component.scss'],
+                    animations: [
+                        trigger('showSelections', [
+                            state('void', style({ 'transform': 'translateX(100%)', opacity: 0 })),
+                            state('*', style({ 'transform': 'translateX(0%)', opacity: 1 })),
+                            transition('void <=> *', animate(200))
+                        ])
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HomedecoratorConnectorService }, { type: i2.BuildFurnitureService }, { type: i3.HomedecoratorSettingsService }]; }, propDecorators: { templateAnswers: [{
+                type: ViewChild,
+                args: ['templateAnswers', { read: TemplateRef, static: true }]
+            }], showAnswers: [{
+                type: Input
+            }], show: [{
+                type: Input
+            }], showSelections: [{
+                type: Input
+            }], showLabel: [{
+                type: Input
+            }], canClose: [{
+                type: Input
+            }], metadata: [{
+                type: Input
+            }], customDimensions: [{
+                type: HostBinding,
+                args: ['class.custom-dimensions']
+            }, {
+                type: Input
+            }], showChange: [{
+                type: Output
+            }], answerChosen: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lite-selector.component.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/lite-selector/lite-selector/lite-selector.component.ts","../../../../../../../src/client/app/plugins/lite-selector/lite-selector/lite-selector.component.html"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, OnDestroy, Output, TemplateRef, ViewChild} from '@angular/core';\r\nimport {Selection} from '@colijnit/configuratorapi/build/model/selection';\r\nimport {Answer} from '@colijnit/configuratorapi/build/model/answer';\r\nimport {Subscription} from 'rxjs';\r\nimport {animate, state, style, transition, trigger} from '@angular/animations';\r\nimport {Metadata} from '../../core3d/items/metadata';\r\nimport {HomedecoratorConnectorService} from '../../../core/service/homedecorator-connector.service';\r\nimport {BuildFurnitureService} from '../../threedselector/threedselector/service/build-furniture.service';\r\nimport {HomedecoratorSettingsService} from '../../../core/service/homedecorator-settings.service';\r\n\r\n@Component({\r\n  selector: 'rp-lite-selector',\r\n  templateUrl: './lite-selector.component.html',\r\n  styleUrls: ['./lite-selector.component.scss'],\r\n  animations: [\r\n    trigger('showSelections', [\r\n      state('void', style({'transform': 'translateX(100%)', opacity: 0})),\r\n      state('*', style({'transform': 'translateX(0%)', opacity: 1})),\r\n      transition('void <=> *', animate(200))\r\n    ])\r\n  ]\r\n})\r\nexport class LiteSelectorComponent implements OnDestroy {\r\n  @ViewChild('templateAnswers', { read: TemplateRef, static: true })\r\n  public templateAnswers: TemplateRef<any>;\r\n\r\n  @Input()\r\n  public set showAnswers(value: boolean) {\r\n    this._showAnswers = value;\r\n    if (!this.showAnswers) {\r\n      setTimeout(() => {\r\n        this.animateSlideout = true;\r\n      }, 400);\r\n    } else {\r\n      this.animateSlideout = false;\r\n    }\r\n  }\r\n\r\n  public get showAnswers(): boolean {\r\n    return this._showAnswers;\r\n  }\r\n\r\n  @Input()\r\n  public show: boolean;\r\n\r\n  @Input()\r\n  public set showSelections(value: boolean) {\r\n    this._showSelections = value;\r\n  }\r\n\r\n  public get showSelections(): boolean {\r\n    return this._showSelections;\r\n  }\r\n\r\n  @Input()\r\n  public showLabel: boolean = true;\r\n\r\n  @Input()\r\n  public canClose: boolean = true;\r\n\r\n  @Input()\r\n  public metadata: Metadata;\r\n\r\n  @HostBinding('class.custom-dimensions')\r\n  @Input()\r\n  public customDimensions: boolean = false;\r\n\r\n  @Output()\r\n  public readonly showChange: EventEmitter<boolean> = new EventEmitter<boolean>();\r\n\r\n  @Output()\r\n  public readonly answerChosen: EventEmitter<Answer> = new EventEmitter<Answer>();\r\n\r\n  public answerToShowFromSelectionText: string;\r\n\r\n  public inlineAnswers: boolean = false;\r\n  public animateSlideout: boolean = true;\r\n\r\n  private _showAnswers: boolean;\r\n  private _answersShowing: boolean = false;\r\n  private _showSelections: boolean = false;\r\n  private _selectionSelected: Selection;\r\n  private _subs: Subscription[] = [];\r\n\r\n  constructor(\r\n    public iOne: HomedecoratorConnectorService,\r\n    public buildFurnitureService: BuildFurnitureService,\r\n    private _settingsService: HomedecoratorSettingsService\r\n  ) {\r\n    this._subs.push(\r\n      this.iOne.answersReceived.subscribe((answers: Answer[]) => {\r\n        this.answerToShowFromSelectionText =\r\n          this.inlineAnswers && answers.length > 0 && this._selectionSelected ?\r\n            this._selectionSelected.question :\r\n            undefined;\r\n        this._answersShowing = answers.length > 0;\r\n      }),\r\n      this._settingsService.settingsLoaded.subscribe((loaded: boolean) => {\r\n        if (loaded) {\r\n          this.inlineAnswers = this._settingsService.settings.options ? this._settingsService.settings.options.inlineAnswers : false;\r\n        }\r\n      }));\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n    this.templateAnswers = undefined;\r\n  }\r\n\r\n  public onCloseLiteSelectorButtonClick(): void {\r\n    this.show = false;\r\n    this.showChange.emit(false);\r\n  }\r\n\r\n  // todo: move to threedselector.component to be able to handle errors?\r\n  public async onSelectionsSummarySelectSelection(selection: Selection): Promise<void> {\r\n    if (this.inlineAnswers && this.answerToShowFromSelectionText) {\r\n      if (this._selectionSelected !== selection) {\r\n        if (this._answersShowing) {\r\n          await this.buildFurnitureService.cancelAnswer(this.metadata, false);\r\n        }\r\n        await this.buildFurnitureService.selectSelection(selection, this.metadata);\r\n      } else {\r\n        if (this._answersShowing) {\r\n          await this.buildFurnitureService.cancelAnswer(this.metadata, false);\r\n        }\r\n      }\r\n    } else {\r\n      await this.buildFurnitureService.selectSelection(selection, this.metadata);\r\n    }\r\n    this._selectionSelected = selection;\r\n  }\r\n\r\n  public onAnswersSlideoutAnswerChosen(answerSelected: any): void {\r\n    this._answersShowing = false;\r\n    this.buildFurnitureService.selectAnswer(answerSelected.answer, answerSelected.input, this.metadata);\r\n    this.answerChosen.next(answerSelected.answer);\r\n    // this.iOne.getMoodImageForAnswerSelection(answerSelected.answer, false);\r\n  }\r\n}\r\n","<ng-container *ngIf=\"show\">\r\n  <rp-selections-summary *ngIf=\"showSelections && iOne.selectionsToDisplay.length > 0\" @showSelections [@.disabled]=\"!animateSlideout\"\r\n                         class=\"rp-selections-summary\"\r\n                         [showLabel]=\"showLabel\"\r\n                         [canClose]=\"canClose\"\r\n                         [customDimensions]=\"customDimensions\"\r\n                         [answersTemplate]=\"inlineAnswers ? templateAnswers : undefined\"\r\n                         [answerToShowFromSelectionText]=\"answerToShowFromSelectionText\"\r\n                         [selections]=\"iOne.selectionsToDisplay\"\r\n                         (selectSelection)=\"onSelectionsSummarySelectSelection($event)\"\r\n                         (closeClick)=\"onCloseLiteSelectorButtonClick()\"\r\n  >\r\n  </rp-selections-summary>\r\n  <ng-container *ngIf=\"!inlineAnswers\" [ngTemplateOutlet]=\"templateAnswers\"></ng-container>\r\n</ng-container>\r\n\r\n<ng-template #templateAnswers>\r\n  <rp-answers-slideout\r\n    class=\"rp-answers-slideout\"\r\n    [metadata]=\"metadata\"\r\n    [isShown]=\"showAnswers && buildFurnitureService.activeAnswers.length > 0\"\r\n    [showTitle]=\"!inlineAnswers\"\r\n    [showFilter]=\"!inlineAnswers\"\r\n    [useSlideout]=\"!inlineAnswers\"\r\n    [customDimensions]=\"customDimensions\"\r\n    [question]=\"buildFurnitureService.activeQuestion\"\r\n    [answers]=\"buildFurnitureService.activeAnswers\"\r\n    (answerChosen)=\"onAnswersSlideoutAnswerChosen($event)\"\r\n  ></rp-answers-slideout>\r\n</ng-template>\r\n"]}

package/esm2015/app/plugins/lite-selector/lite-selector/service/customizer.service.js

@@ -0,0 +1,222 @@
+import { Injectable, Input } from '@angular/core';
+import * as THREE from 'three';
+import { Box3, CanvasTexture, Euler, FrontSide, Mesh, MeshStandardMaterial, Quaternion, SRGBColorSpace, Vector3, WebGLRenderer } from 'three';
+import { DecalGeometry } from 'three/examples/jsm/geometries/DecalGeometry';
+import { fabric } from 'fabric';
+import { Utils } from '../../../core3d/core/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core3d/service/scene.service";
+import * as i2 from "../../../threedselector/threedselector/service/build-furniture.service";
+export class CustomizerService {
+    constructor(_sceneService, _buildFurnitureService) {
+        this._sceneService = _sceneService;
+        this._buildFurnitureService = _buildFurnitureService;
+        this.showCustomizeSlideout = false;
+        this._enabled = true;
+    }
+    get enabled() {
+        return this._enabled;
+    }
+    set canvasElement(value) {
+        if (value) {
+            this._canvasElement = value.nativeElement;
+            this.createFabricCanvas();
+        }
+    }
+    get canvasElement() {
+        return this._canvasElement;
+    }
+    addCanvasMesh() {
+        // this.selectedObject = this._plane as CustomMesh;
+        if (!this.selectedObject) {
+            return;
+        }
+        if (!this.canvas) {
+            this.createFabricCanvas();
+        }
+        this._initializeDimensions();
+        this.selectedObject.updateMatrixWorld(true);
+        const connectorRotation = new Quaternion();
+        const connector = this.selectedObject.children.find(c => c.name.toLowerCase().startsWith('p_'));
+        if (connector) {
+            connectorRotation.setFromEuler(connector.rotation);
+        }
+        const meshRotation = new Quaternion();
+        this.selectedObject.getWorldQuaternion(meshRotation);
+        meshRotation.multiply(connectorRotation);
+        const mesh = this.selectedObject.clone();
+        // const canvDom: HTMLCanvasElement = document.getElementById('fabricSurface') as HTMLCanvasElement;
+        const decalDiffuse = new CanvasTexture(this._canvasElement);
+        const decalMaterial = new MeshStandardMaterial({
+            map: decalDiffuse,
+            metalnessMap: this._metalnessMap,
+            normalMap: this._normalMap,
+            roughnessMap: this._roughnessMap,
+            aoMap: this._aoMap,
+            roughness: this._roughness,
+            metalness: this._metalness,
+            transparent: true,
+            polygonOffset: true,
+            polygonOffsetFactor: -0.1,
+            side: FrontSide,
+        });
+        decalMaterial.map.minFilter = THREE.LinearFilter;
+        decalMaterial.map.colorSpace = SRGBColorSpace;
+        decalDiffuse.minFilter = THREE.LinearMipMapLinearFilter;
+        decalDiffuse.wrapS = THREE.RepeatWrapping;
+        decalDiffuse.wrapT = THREE.RepeatWrapping;
+        decalDiffuse.repeat.set(1, 1);
+        decalDiffuse.anisotropy = this._sceneService.renderer instanceof WebGLRenderer ? this._sceneService.renderer.capabilities.getMaxAnisotropy() : 16;
+        decalDiffuse.flipY = meshRotation.x === 0;
+        this._customDecalMesh = mesh.getObjectByName('customDecal');
+        if (this._customDecalMesh) {
+            mesh.remove(this._customDecalMesh);
+            Utils.DisposeObject(this._customDecalMesh);
+            this._sceneService.needsRender = true;
+            return undefined;
+        }
+        mesh.position.set(0, 0, 0); // reset position
+        mesh.rotation.set(0, 0, 0); // reset rotation
+        mesh.rotation.setFromQuaternion(meshRotation);
+        // temporarily add mesh to the scene (for world coordinates)
+        this._sceneService.scene.add(mesh);
+        mesh.updateMatrixWorld(true);
+        const originalOrigin = new Vector3().copy(mesh.geometry.boundingBox.max).sub(mesh.geometry.boundingBox.min).divideScalar(2);
+        const delta = new Vector3().copy(mesh.geometry.boundingBox.min).add(new Vector3().copy(originalOrigin));
+        // move geometry to the correct origin (center);
+        mesh.geometry.translate(-delta.x, -delta.y, -delta.z);
+        // const decalSize: Vector3 = new Vector3(2, 2, 2);
+        const maxSize = Math.max(this.getHalfSize().x, this.getHalfSize().y, this.getHalfSize().z) * 2;
+        const decalSize = new Vector3(maxSize, maxSize, maxSize);
+        const pos = new Vector3();
+        const rotation = new Euler();
+        const decalMesh = new Mesh(new DecalGeometry(mesh, pos, rotation, decalSize), decalMaterial);
+        decalMesh.rotation.setFromQuaternion(meshRotation);
+        decalMesh.name = 'customDecal';
+        this.selectedObject.add(decalMesh);
+        // move decal geometry to the same origin as the selected mesh
+        decalMesh.geometry.translate(delta.x, delta.y, delta.z);
+        // finally remove the temp mesh
+        this._sceneService.removeObject(mesh);
+        this._sceneService.needsRender = true;
+    }
+    updateCanvasToMesh() {
+        this.canvas.on('after:render', () => {
+            this.selectedObject.userData.customizedCanvas = JSON.stringify(this.canvas.toJSON());
+            this.getSelectedobjectMaterials();
+            this.addCanvasMesh();
+        });
+    }
+    getSelectedobjectMaterials() {
+        const map = this.selectedObject.material;
+        this._metalnessMap = map.metalnessMap;
+        this._roughnessMap = map.roughnessMap;
+        this._aoMap = map.aoMap;
+        this._normalMap = map.normalMap;
+        this._roughness = map.roughness;
+        this._metalness = map.metalness;
+    }
+    getHalfSize() {
+        return this._halfSize.clone();
+    }
+    addImage(data) {
+        fabric.Image.fromURL(data, (img) => {
+            const oImg = img.set({
+                left: 25,
+                top: 25,
+                angle: 0,
+            }).scale(1);
+            this.canvas.add(oImg).renderAll();
+        });
+    }
+    addText() {
+        const oText = new fabric.IText('Tap and Type', {
+            left: 100,
+            top: 100,
+            fontFamily: 'arial black',
+            fill: '#333',
+            fontSize: 180,
+        });
+        this.canvas.add(oText);
+        oText.bringToFront();
+        return this.canvas.setActiveObject(oText);
+    }
+    setActiveProp(name, value) {
+        const object = this.canvas.getActiveObject();
+        if (!object) {
+            return;
+        }
+        object.set(name, value);
+        this.canvas.renderAll();
+    }
+    clearCanvas() {
+        return this.canvas.remove.apply(this.canvas, this.canvas.getObjects().concat());
+    }
+    deleteActiveObject() {
+        return this.canvas.remove(this.canvas.getActiveObject());
+    }
+    createFabricCanvas() {
+        if (!this.canvasElement) {
+            this.canvasElement = document.createElement('canvas');
+        }
+        this.canvasElement.id = 'fabricSurface';
+        this.canvas = new fabric.Canvas('fabricSurface', {
+            selection: false,
+            selectionLineWidth: 100,
+        });
+        this.canvas.setHeight(2048);
+        this.canvas.setWidth(2048);
+        this.canvas.enableRetinaScaling = true;
+        this.canvas.requestRenderAll();
+        this._setCanvasBoundaries();
+        fabric.Object.prototype.set({
+            borderScaleFactor: 10,
+            cornerSize: 70,
+            padding: 20,
+            cornerColor: 'red',
+            transparentCorners: false,
+        });
+        if (this.selectedObject.userData.customizedCanvas) {
+            this.canvasJson = JSON.parse(this.selectedObject.userData.customizedCanvas);
+            this.canvas.loadFromJSON(this.canvasJson);
+        }
+        this.updateCanvasToMesh();
+    }
+    _initializeDimensions() {
+        const objectBox = new Box3();
+        objectBox.setFromObject(this.selectedObject);
+        this._halfSize = objectBox.max.clone().sub(objectBox.min).divideScalar(2);
+    }
+    _setCanvasBoundaries() {
+        this.canvas.on('object:moving', (e) => {
+            const obj = e.target;
+            // if object is too big, ignore
+            if (obj.currentHeight > this.canvas.height || obj.currentWidth > obj.canvas.width) {
+                return;
+            }
+            obj.setCoords();
+            // top-left corner boundary
+            if (obj.getBoundingRect().top < 0 || obj.getBoundingRect().left < 0) {
+                obj.top = Math.max(obj.top, obj.top - obj.getBoundingRect().top);
+                obj.left = Math.max(obj.left, obj.left - obj.getBoundingRect().left);
+            }
+            // bot-right corner boundary
+            if (obj.getBoundingRect().top + obj.getBoundingRect().height > obj.canvas.height || obj.getBoundingRect().left +
+                obj.getBoundingRect().width > obj.canvas.width) {
+                obj.top = Math.min(obj.top, obj.canvas.height - obj.getBoundingRect().height + obj.top - obj.getBoundingRect().top);
+                obj.left = Math.min(obj.left, obj.canvas.width - obj.getBoundingRect().width + obj.left - obj.getBoundingRect().left);
+            }
+        });
+    }
+}
+CustomizerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CustomizerService, deps: [{ token: i1.SceneService }, { token: i2.BuildFurnitureService }], target: i0.ɵɵFactoryTarget.Injectable });
+CustomizerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CustomizerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CustomizerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SceneService }, { type: i2.BuildFurnitureService }]; }, propDecorators: { showCustomizeSlideout: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"customizer.service.js","sourceRoot":"","sources":["../../../../../../../../src/client/app/plugins/lite-selector/lite-selector/service/customizer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, Input} from '@angular/core';\r\nimport * as THREE from 'three';\r\nimport {\r\n  Box3,\r\n  CanvasTexture,\r\n  Euler,\r\n  FrontSide,\r\n  Mesh,\r\n  MeshStandardMaterial,\r\n  Quaternion,\r\n  SRGBColorSpace,\r\n  Texture,\r\n  Vector3,\r\n  WebGLRenderer\r\n} from 'three';\r\nimport {DecalGeometry} from 'three/examples/jsm/geometries/DecalGeometry';\r\nimport {fabric} from 'fabric';\r\nimport {CustomMesh} from '../../../core3d/items/custom-objects';\r\nimport {SceneService} from '../../../core3d/service/scene.service';\r\nimport {BuildFurnitureService} from '../../../threedselector/threedselector/service/build-furniture.service';\r\nimport {Utils} from '../../../core3d/core/utils';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class CustomizerService {\r\n\r\n  public get enabled(): boolean {\r\n    return this._enabled;\r\n  }\r\n\r\n  public canvas: fabric.Canvas;\r\n  public selectedObject: CustomMesh;\r\n  public canvasJson: string;\r\n\r\n  @Input()\r\n  public showCustomizeSlideout: boolean = false;\r\n\r\n  public set canvasElement(value: any) {\r\n    if (value) {\r\n      this._canvasElement = value.nativeElement;\r\n      this.createFabricCanvas();\r\n    }\r\n  }\r\n\r\n  public get canvasElement(): any {\r\n    return this._canvasElement;\r\n  }\r\n\r\n  private _halfSize: Vector3;\r\n  private _canvasElement: any;\r\n  private _enabled: boolean = true;\r\n  private _metalnessMap: Texture;\r\n  private _normalMap: Texture;\r\n  private _roughnessMap: Texture;\r\n  private _aoMap: Texture;\r\n  private _roughness: number;\r\n  private _metalness: number;\r\n  private _repeatX: number;\r\n  private _repeatY: number;\r\n  private _customDecalMesh: Mesh;\r\n\r\n  constructor(\r\n    private _sceneService: SceneService,\r\n    private _buildFurnitureService: BuildFurnitureService,\r\n  ) {\r\n  }\r\n\r\n  public addCanvasMesh(): void {\r\n    // this.selectedObject = this._plane as CustomMesh;\r\n    if (!this.selectedObject) {\r\n      return;\r\n    }\r\n    if (!this.canvas) {\r\n      this.createFabricCanvas();\r\n    }\r\n    this._initializeDimensions();\r\n    this.selectedObject.updateMatrixWorld(true);\r\n    const connectorRotation: Quaternion = new Quaternion();\r\n    const connector = this.selectedObject.children.find(c => c.name.toLowerCase().startsWith('p_'));\r\n    if (connector) {\r\n      connectorRotation.setFromEuler(connector.rotation);\r\n    }\r\n    const meshRotation: Quaternion = new Quaternion();\r\n    this.selectedObject.getWorldQuaternion(meshRotation);\r\n    meshRotation.multiply(connectorRotation);\r\n    const mesh: CustomMesh = this.selectedObject.clone();\r\n    // const canvDom: HTMLCanvasElement = document.getElementById('fabricSurface') as HTMLCanvasElement;\r\n    const decalDiffuse: CanvasTexture = new CanvasTexture(this._canvasElement);\r\n    const decalMaterial: MeshStandardMaterial = new MeshStandardMaterial({\r\n      map: decalDiffuse,\r\n      metalnessMap: this._metalnessMap,\r\n      normalMap: this._normalMap,\r\n      roughnessMap: this._roughnessMap,\r\n      aoMap: this._aoMap,\r\n      roughness: this._roughness,\r\n      metalness: this._metalness,\r\n      transparent: true,\r\n      polygonOffset: true,\r\n      polygonOffsetFactor: -0.1,\r\n      side: FrontSide,\r\n    });\r\n    decalMaterial.map.minFilter = THREE.LinearFilter;\r\n    decalMaterial.map.colorSpace = SRGBColorSpace;\r\n    decalDiffuse.minFilter = THREE.LinearMipMapLinearFilter;\r\n    decalDiffuse.wrapS = THREE.RepeatWrapping;\r\n    decalDiffuse.wrapT = THREE.RepeatWrapping;\r\n    decalDiffuse.repeat.set(1, 1);\r\n    decalDiffuse.anisotropy = this._sceneService.renderer instanceof WebGLRenderer ? this._sceneService.renderer.capabilities.getMaxAnisotropy() : 16;\r\n    decalDiffuse.flipY = meshRotation.x === 0;\r\n\r\n    this._customDecalMesh = mesh.getObjectByName('customDecal') as CustomMesh;\r\n    if (this._customDecalMesh) {\r\n      mesh.remove(this._customDecalMesh);\r\n      Utils.DisposeObject(this._customDecalMesh);\r\n      this._sceneService.needsRender = true;\r\n      return undefined;\r\n    }\r\n\r\n    mesh.position.set(0, 0, 0); // reset position\r\n    mesh.rotation.set(0, 0, 0); // reset rotation\r\n    mesh.rotation.setFromQuaternion(meshRotation);\r\n\r\n    // temporarily add mesh to the scene (for world coordinates)\r\n    this._sceneService.scene.add(mesh);\r\n    mesh.updateMatrixWorld(true);\r\n    const originalOrigin: Vector3 = new Vector3().copy(mesh.geometry.boundingBox.max).sub(mesh.geometry.boundingBox.min).divideScalar(2);\r\n    const delta: Vector3 = new Vector3().copy(mesh.geometry.boundingBox.min).add(new Vector3().copy(originalOrigin));\r\n    // move geometry to the correct origin (center);\r\n    mesh.geometry.translate(-delta.x, -delta.y, -delta.z);\r\n\r\n    // const decalSize: Vector3 = new Vector3(2, 2, 2);\r\n    const maxSize: number = Math.max(this.getHalfSize().x, this.getHalfSize().y, this.getHalfSize().z) * 2;\r\n    const decalSize: Vector3 = new Vector3(maxSize, maxSize, maxSize);\r\n    const pos: Vector3 = new Vector3();\r\n    const rotation: Euler = new Euler();\r\n    const decalMesh: Mesh = new Mesh(new DecalGeometry(mesh, pos, rotation, decalSize), decalMaterial);\r\n    decalMesh.rotation.setFromQuaternion(meshRotation);\r\n    decalMesh.name = 'customDecal';\r\n    this.selectedObject.add(decalMesh);\r\n\r\n    // move decal geometry to the same origin as the selected mesh\r\n    decalMesh.geometry.translate(delta.x, delta.y, delta.z);\r\n    // finally remove the temp mesh\r\n    this._sceneService.removeObject(mesh);\r\n    this._sceneService.needsRender = true;\r\n  }\r\n\r\n  public updateCanvasToMesh(): void {\r\n    this.canvas.on('after:render', () => {\r\n      this.selectedObject.userData.customizedCanvas = JSON.stringify(this.canvas.toJSON());\r\n      this.getSelectedobjectMaterials();\r\n      this.addCanvasMesh();\r\n    });\r\n  }\r\n\r\n  public getSelectedobjectMaterials(): void {\r\n    const map = this.selectedObject.material as MeshStandardMaterial;\r\n    this._metalnessMap = map.metalnessMap;\r\n    this._roughnessMap = map.roughnessMap;\r\n    this._aoMap = map.aoMap;\r\n    this._normalMap = map.normalMap;\r\n    this._roughness = map.roughness;\r\n    this._metalness = map.metalness;\r\n  }\r\n\r\n  public getHalfSize(): Vector3 {\r\n    return this._halfSize.clone();\r\n  }\r\n\r\n  public addImage(data: string | ArrayBuffer): void {\r\n    fabric.Image.fromURL(data, (img) => {\r\n      const oImg = img.set({\r\n        left: 25,\r\n        top: 25,\r\n        angle: 0,\r\n      }).scale(1);\r\n      this.canvas.add(oImg).renderAll();\r\n    });\r\n  }\r\n\r\n  public addText(): void {\r\n    const oText: fabric.IText = new fabric.IText('Tap and Type', {\r\n      left: 100,\r\n      top: 100,\r\n      fontFamily: 'arial black',\r\n      fill: '#333',\r\n      fontSize: 180,\r\n    });\r\n    this.canvas.add(oText);\r\n    oText.bringToFront();\r\n    return this.canvas.setActiveObject(oText);\r\n  }\r\n\r\n  public setActiveProp(name, value): void {\r\n    const object = this.canvas.getActiveObject();\r\n    if (!object) {\r\n      return;\r\n    }\r\n    object.set(name, value);\r\n    this.canvas.renderAll();\r\n  }\r\n\r\n  public clearCanvas(): void {\r\n    return this.canvas.remove.apply(this.canvas, this.canvas.getObjects().concat());\r\n  }\r\n\r\n  public deleteActiveObject(): void {\r\n    return this.canvas.remove(this.canvas.getActiveObject());\r\n  }\r\n\r\n  public createFabricCanvas(): void {\r\n    if (!this.canvasElement) {\r\n      this.canvasElement = document.createElement('canvas');\r\n    }\r\n    this.canvasElement.id = 'fabricSurface';\r\n    this.canvas = new fabric.Canvas('fabricSurface', {\r\n      selection: false,\r\n      selectionLineWidth: 100,\r\n    });\r\n    this.canvas.setHeight(2048);\r\n    this.canvas.setWidth(2048);\r\n    this.canvas.enableRetinaScaling = true;\r\n    this.canvas.requestRenderAll();\r\n    this._setCanvasBoundaries();\r\n    fabric.Object.prototype.set({\r\n      borderScaleFactor: 10,\r\n      cornerSize: 70,\r\n      padding: 20,\r\n      cornerColor: 'red',\r\n      transparentCorners: false,\r\n    });\r\n    if (this.selectedObject.userData.customizedCanvas) {\r\n      this.canvasJson = JSON.parse(this.selectedObject.userData.customizedCanvas);\r\n      this.canvas.loadFromJSON(this.canvasJson);\r\n    }\r\n    this.updateCanvasToMesh();\r\n  }\r\n\r\n  private _initializeDimensions(): void {\r\n    const objectBox = new Box3();\r\n    objectBox.setFromObject(this.selectedObject);\r\n    this._halfSize = objectBox.max.clone().sub(objectBox.min).divideScalar(2);\r\n  }\r\n\r\n  private _setCanvasBoundaries() {\r\n    this.canvas.on('object:moving', (e) => {\r\n      const obj = e.target;\r\n      // if object is too big, ignore\r\n      if (obj.currentHeight > this.canvas.height || obj.currentWidth > obj.canvas.width) {\r\n        return;\r\n      }\r\n      obj.setCoords();\r\n      // top-left corner boundary\r\n      if (obj.getBoundingRect().top < 0 || obj.getBoundingRect().left < 0) {\r\n        obj.top = Math.max(obj.top, obj.top - obj.getBoundingRect().top);\r\n        obj.left = Math.max(obj.left, obj.left - obj.getBoundingRect().left);\r\n      }\r\n      // bot-right corner boundary\r\n      if (obj.getBoundingRect().top + obj.getBoundingRect().height > obj.canvas.height || obj.getBoundingRect().left +\r\n        obj.getBoundingRect().width > obj.canvas.width) {\r\n        obj.top = Math.min(obj.top, obj.canvas.height - obj.getBoundingRect().height + obj.top - obj.getBoundingRect().top);\r\n        obj.left = Math.min(obj.left, obj.canvas.width - obj.getBoundingRect().width + obj.left - obj.getBoundingRect().left);\r\n      }\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2015/app/plugins/lite-selector/lite-selector.module.js

@@ -0,0 +1,108 @@
+import { NgModule, NO_ERRORS_SCHEMA } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { ButtonModule, CardModule, HtmlHeaderModule, IconModule, InputTextChipsModule, InputTextModule, PriceDisplayPipeModule, SlideoutModule, SummaryLineModule } from '@colijnit/corecomponents';
+import { FormsModule } from '@angular/forms';
+import { CoreModule } from '../../core/core.module';
+import { LiteSelectorComponent } from './lite-selector/lite-selector.component';
+import { AnswerCardComponent } from './lite-selector/component/answer-card/answer-card.component';
+import { AnswersSlideoutComponent } from './lite-selector/component/answers-slideout/answers-slideout.component';
+import { SelectionsSummaryComponent } from './lite-selector/component/selections-summary/selections-summary.component';
+import { SelectionsSummaryLineComponent } from './lite-selector/component/selections-summary/selections-summary-line.component';
+import { ColorFilterComponent } from './lite-selector/component/color-filter/color-filter.component';
+import { ImageZoomComponent } from './lite-selector/component/image-zoom/image-zoom.component';
+import { TagFilterComponent } from './lite-selector/component/tag-filter/tag-filter.component';
+import { CustomizerComponent } from './lite-selector/component/customizer/customizer.component';
+import { AnimationComponent } from './lite-selector/component/animation/animation.component';
+import { HomedecoratorIconCacheService } from '../../core/service/homedecorator-icon-cache.service';
+import { AnimationService } from '../threedselector/threedselector/service/animation.service';
+import * as i0 from "@angular/core";
+export class LiteSelectorModule {
+}
+LiteSelectorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LiteSelectorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LiteSelectorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LiteSelectorModule, declarations: [LiteSelectorComponent,
+        AnswerCardComponent,
+        AnswersSlideoutComponent,
+        SelectionsSummaryComponent,
+        SelectionsSummaryLineComponent,
+        ColorFilterComponent,
+        ImageZoomComponent,
+        TagFilterComponent,
+        CustomizerComponent,
+        AnimationComponent], imports: [CoreModule,
+        CommonModule,
+        MatIconModule,
+        MatButtonModule,
+        CardModule,
+        SlideoutModule,
+        SummaryLineModule,
+        PriceDisplayPipeModule,
+        ButtonModule,
+        HtmlHeaderModule,
+        InputTextModule,
+        InputTextChipsModule,
+        IconModule,
+        FormsModule], exports: [LiteSelectorComponent, AnimationComponent, CustomizerComponent] });
+LiteSelectorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LiteSelectorModule, providers: [
+        HomedecoratorIconCacheService,
+        AnimationService
+    ], imports: [[
+            CoreModule,
+            CommonModule,
+            MatIconModule,
+            MatButtonModule,
+            CardModule,
+            SlideoutModule,
+            SummaryLineModule,
+            PriceDisplayPipeModule,
+            ButtonModule,
+            HtmlHeaderModule,
+            InputTextModule,
+            InputTextChipsModule,
+            IconModule,
+            FormsModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LiteSelectorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CoreModule,
+                        CommonModule,
+                        MatIconModule,
+                        MatButtonModule,
+                        CardModule,
+                        SlideoutModule,
+                        SummaryLineModule,
+                        PriceDisplayPipeModule,
+                        ButtonModule,
+                        HtmlHeaderModule,
+                        InputTextModule,
+                        InputTextChipsModule,
+                        IconModule,
+                        FormsModule
+                    ],
+                    schemas: [
+                        NO_ERRORS_SCHEMA
+                    ],
+                    entryComponents: [LiteSelectorComponent],
+                    declarations: [
+                        LiteSelectorComponent,
+                        AnswerCardComponent,
+                        AnswersSlideoutComponent,
+                        SelectionsSummaryComponent,
+                        SelectionsSummaryLineComponent,
+                        ColorFilterComponent,
+                        ImageZoomComponent,
+                        TagFilterComponent,
+                        CustomizerComponent,
+                        AnimationComponent
+                    ],
+                    exports: [LiteSelectorComponent, AnimationComponent, CustomizerComponent],
+                    providers: [
+                        HomedecoratorIconCacheService,
+                        AnimationService
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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