@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/product-catalog/product-catalog/product-catalog.component.js

@@ -0,0 +1,428 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Component, HostBinding } from '@angular/core';
+import { ExternalCatalogStartupInfo } from '@colijnit/articleapi/build/model/external-catalog-startup-info';
+import { MessageType } from '../../../core/enum/message-type.enum';
+import { ExternalCatalogStartupInfoRequest } from '@colijnit/articleapi/build/model/external-catalog-startup-info-request';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/service/homedecorator-settings.service";
+import * as i2 from "../../../core/service/message-bus.service";
+import * as i3 from "../../../core/service/homedecorator-connector.service";
+import * as i4 from "../../../shared/screen-size-analysis/screen-size-analysis.service";
+import * as i5 from "../../core3d/service/scene.service";
+import * as i6 from "../../room-planner/components/floorplanner/service/floorplan.service";
+import * as i7 from "@colijnit/catalog";
+import * as i8 from "../../../service/dynamic-script.service";
+import * as i9 from "../../../core/service/homedecorator-connector-adapter.service";
+import * as i10 from "../../threedselector/threedselector/service/build-furniture.service";
+import * as i11 from "../../threedselector/threedselector/service/third-party-model.service";
+import * as i12 from "@angular/material/icon";
+import * as i13 from "../own-collection-catalog/product-own-collection.component";
+import * as i14 from "../../model-uploader/model-uploader/model-uploader.component";
+import * as i15 from "@colijnit/corecomponents_v12";
+import * as i16 from "@angular/material/button";
+import * as i17 from "@angular/common";
+import * as i18 from "../../../core/pipe/localize.pipe";
+import * as i19 from "../../../core/pipe/append.pipe";
+export class ProductCatalogComponent {
+    constructor(settingsService, _messageBus, _ioneController, _screenSizeService, _sceneService, _floorPlanService, _injector, _catalogService, _dynamicScriptService, _adapterService, _buildFurnitureService, _thirdPartyModelService) {
+        this.settingsService = settingsService;
+        this._messageBus = _messageBus;
+        this._ioneController = _ioneController;
+        this._screenSizeService = _screenSizeService;
+        this._sceneService = _sceneService;
+        this._floorPlanService = _floorPlanService;
+        this._injector = _injector;
+        this._catalogService = _catalogService;
+        this._dynamicScriptService = _dynamicScriptService;
+        this._adapterService = _adapterService;
+        this._buildFurnitureService = _buildFurnitureService;
+        this._thirdPartyModelService = _thirdPartyModelService;
+        this.showExternalCatalog = false;
+        this.showOwnCollection = false;
+        this.homeDecoHub = this.settingsService.settings.user3DModelUploadEnabled;
+        this._subs = [];
+    }
+    get shown() {
+        return this._showCatalog;
+    }
+    ngOnInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._subs.push(this._messageBus.subscribe(MessageType.ShowProductCatalog, () => this._handleShowProductCatalogMessageReceived()), this._messageBus.subscribe(MessageType.HideProductCatalog, () => this.hideCatalog()), this._messageBus.subscribe(MessageType.ViewModeChanged, () => this.hideCatalog()), this._ioneController.controllerInitialized.subscribe((loaded) => {
+                if (loaded) {
+                    this.settings = undefined;
+                    // this.loaded = false;
+                    setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                        this.settings = this.settingsService.settings;
+                        this._catalogService.init(this.settings);
+                        this.loaded = true;
+                    }), 200);
+                }
+            }), this._screenSizeService.screenSizeChanged.subscribe(info => this.phoneSizeScreen = info.isPhoneSize));
+        });
+    }
+    ngOnDestroy() {
+        this._subs.forEach(sub => sub.unsubscribe());
+    }
+    hideCatalog() {
+        this._showCatalog = false;
+    }
+    handleArticleClick(data, catalogInfo) {
+        if (data.article) {
+            if (catalogInfo && catalogInfo.externalSource) {
+                data.settings.externalSourceId = catalogInfo.externalSource.sourceId;
+                data.settings.schema = catalogInfo.externalSource.schema;
+                data.settings.settings.password = '';
+                data.settings.settings.username = '';
+            }
+            this._messageBus.emit(MessageType.LoadIOneFurnitureIntoSceneBySKU, {
+                sku: data.article.articleNumber,
+                settings: data.settings,
+                position: this._floorPlanService.getCenter(),
+                fullArticleObject: data.article
+            });
+            this._showCatalog = false;
+        }
+    }
+    handleArButtonClick(data) {
+        if (data.article) {
+            this._sceneService.arMode = true;
+            this._showCatalog = false;
+            this._messageBus.emit(MessageType.LoadIOneFurnitureIntoSceneBySKU, {
+                sku: data.article.articleNumber,
+                settings: data.settings,
+                position: { x: 0, y: 0 },
+                fullArticleObject: data.article
+            });
+        }
+    }
+    handleExternalSourceClick(source) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (source) {
+                this._source = source;
+                // reset connection to host
+                // @ts-ignore
+                yield this._adapterService.initConnector(this.settingsService.settings, undefined);
+                this.catalogDefinition = source.catalogDefinition;
+                this.externalSource = source.externalSource;
+                this.externalCatalogName = source.catalogDefinition.name;
+                let info = new ExternalCatalogStartupInfo();
+                const request = this._buildExternalCatalogRequest();
+                info = yield this._ioneController.getWebViewStartupInfo(request);
+                this.catalogInfo = info;
+                this.showExternalCatalog = true;
+            }
+            else {
+                this.showExternalCatalog = false;
+            }
+        });
+    }
+    handleShowOwnCollectionClick(event) {
+        this.showOwnCollection = true;
+    }
+    handleBackClick(event) {
+        this.showExternalCatalog = false;
+        this.showOwnCollection = false;
+    }
+    handleRefreshClick(event) {
+        this.handleExternalSourceClick(this._source);
+    }
+    handleIFrameFeedback(jsonString) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (jsonString) {
+                const jsonObj = JSON.parse(jsonString);
+                if (jsonObj['hash'] !== undefined) {
+                    const customerName = 'Linteloo';
+                    // three main api urls
+                    const modelUrl = this.catalogInfo.externalSource.domain + '/models/' + jsonObj['hash'] + '/glb';
+                    const configurationUrl = this.catalogInfo.externalSource.domain + '/configurationData/' + jsonObj['hash'];
+                    const priceDataUrl = this.catalogInfo.externalSource.domain + '/rules/api/' + customerName.toLowerCase() + '/' + jsonObj['hash'];
+                    try {
+                        const apiResponses = yield Promise.all([
+                            this._thirdPartyModelService.downloadModel(modelUrl),
+                            this._thirdPartyModelService.fetchJsonFile(configurationUrl),
+                            this._thirdPartyModelService.fetchJsonFile(priceDataUrl)
+                        ]);
+                        const modelResponse = apiResponses[0];
+                        const configurationResponse = apiResponses[1];
+                        const priceDataResponse = apiResponses[2];
+                        let configurationData;
+                        let priceData;
+                        if (modelResponse && modelResponse.ok) {
+                            modelResponse.arrayBuffer().then(data => {
+                                if (configurationResponse && configurationResponse.ok) {
+                                    configurationResponse.json().then(result => {
+                                        console.log(result);
+                                        configurationData = result;
+                                    }).catch(e => {
+                                        console.log(e);
+                                        configurationData = {};
+                                    });
+                                }
+                                if (priceDataResponse && priceDataResponse.ok) {
+                                    priceDataResponse.json().then(result => {
+                                        console.log(result);
+                                        priceData = result;
+                                    }).catch(e => {
+                                        console.log(e);
+                                        priceData = {};
+                                    });
+                                }
+                                this._thirdPartyModelService.parseModelToGLB(data, jsonObj['hash'], modelUrl, configurationData, priceData).then(result => {
+                                    this.hideCatalog();
+                                });
+                            });
+                        }
+                        else if (!modelResponse.ok) {
+                            throw new Error('Failed to fetch data');
+                        }
+                        // const response: Response = await this._thirdPartyModelService.downloadModel(urlToFetch);
+                        // if (!response.ok) {
+                        //   throw new Error('Failed to fetch data');
+                        // }
+                        // response.arrayBuffer().then(data => {
+                        //   this._thirdPartyModelService.parseModelToGLB(data, jsonObj['hash'], urlToFetch).then(result => {
+                        //     this.hideCatalog();
+                        //   });
+                        // });
+                    }
+                    catch (error) {
+                        console.error('Error fetching data:', error);
+                    }
+                }
+            }
+        });
+    }
+    iframeTest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // three main api urls
+            const modelUrl = 'https://linteloo.platformapi-accept.3dimerce.com/models/3920f50cbbdcb5980c8994746df0f62127ce1064108cd7bc1a27ea7d4c171dc8/glb';
+            const configurationUrl = 'https://linteloo.platformapi-accept.3dimerce.com/configurationData/3920f50cbbdcb5980c8994746df0f62127ce1064108cd7bc1a27ea7d4c171dc8';
+            const priceDataUrl = 'https://linteloo.platformapi-accept.3dimerce.com/rules/api/linteloo/3920f50cbbdcb5980c8994746df0f62127ce1064108cd7bc1a27ea7d4c171dc8';
+            const hash = '3920f50cbbdcb5980c8994746df0f62127ce1064108cd7bc1a27ea7d4c171dc8';
+            try {
+                const apiResponses = yield Promise.all([
+                    this._thirdPartyModelService.downloadModel(modelUrl),
+                    this._thirdPartyModelService.fetchJsonFile(configurationUrl),
+                    this._thirdPartyModelService.fetchJsonFile(priceDataUrl)
+                ]);
+                const modelResponse = apiResponses[0];
+                const configurationResponse = apiResponses[1];
+                const priceDataResponse = apiResponses[2];
+                let configurationData;
+                let priceData;
+                if (modelResponse && modelResponse.ok) {
+                    modelResponse.arrayBuffer().then(data => {
+                        if (configurationResponse && configurationResponse.ok) {
+                            configurationResponse.json().then(result => {
+                                console.log(result);
+                                configurationData = result;
+                            }).catch(e => {
+                                console.log(e);
+                                configurationData = {};
+                            });
+                        }
+                        if (priceDataResponse && priceDataResponse.ok) {
+                            priceDataResponse.json().then(result => {
+                                console.log(result);
+                                priceData = result;
+                            }).catch(e => {
+                                console.log(e);
+                                priceData = {};
+                            });
+                        }
+                        this._thirdPartyModelService.parseModelToGLB(data, hash, modelUrl, configurationData, priceData).then(result => {
+                            this.hideCatalog();
+                        });
+                    });
+                }
+                else if (!modelResponse.ok) {
+                    throw new Error('Failed to fetch data');
+                }
+            }
+            catch (error) {
+                console.error('Error fetching data:', error);
+            }
+            // let configurationData: any;
+            // let priceData: any;
+            //
+            // // get config data
+            // const configurationUrlResponse = await this._thirdPartyModelService.fetchJsonFile(configurationUrl).catch((e) => console.error(e));
+            // if (configurationUrlResponse && configurationUrlResponse.ok) {
+            //   configurationData = await configurationUrlResponse.json();
+            // }
+            //
+            // // get pricing data
+            // const priceDataResponse = await this._thirdPartyModelService.fetchJsonFile(priceDataUrl).catch((e) => console.error(e));
+            // if (priceDataResponse && priceDataResponse.ok) {
+            //   priceData = await priceDataResponse.json();
+            // }
+            // // get model and create the object
+            // this._thirdPartyModelService.downloadModel(modelUrl).then(result => {
+            //   if (result && result.ok) {
+            //     result.arrayBuffer().then(data => {
+            //       this._thirdPartyModelService.parseModelToGLB(data, hash, modelUrl, configurationData, priceData).then(status => {
+            //         this.hideCatalog();
+            //       });
+            //     });
+            //   }
+            // }).catch(e => {
+            //   console.log(e);
+            // });
+        });
+    }
+    _buildExternalCatalogRequest() {
+        const request = new ExternalCatalogStartupInfoRequest();
+        // @ts-ignore
+        request.catalogId = this.catalogDefinition.getId();
+        request.posName = 'NNB'; // Nog Niet Bepaald
+        return request;
+    }
+    _handleShowProductCatalogMessageReceived() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._showCatalog = true;
+        });
+    }
+}
+ProductCatalogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductCatalogComponent, deps: [{ token: i1.HomedecoratorSettingsService }, { token: i2.MessageBusService }, { token: i3.HomedecoratorConnectorService }, { token: i4.ScreenSizeAnalysisService }, { token: i5.SceneService }, { token: i6.FloorplanService }, { token: i0.Injector }, { token: i7.CatalogService }, { token: i8.DynamicScriptService }, { token: i9.HomedecoratorConnectorAdapterService }, { token: i10.BuildFurnitureService }, { token: i11.ThirdPartyModelService }], target: i0.ɵɵFactoryTarget.Component });
+ProductCatalogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ProductCatalogComponent, selector: "rp-product-catalog", host: { properties: { "class.shown": "this.shown", "class.no-offset": "this.phoneSizeScreen" } }, ngImport: i0, template: `
+      <div class="product-catalog-wrapper">
+        <div class="catalog-button-wrapper" *ngIf="showOwnCollection || showExternalCatalog">
+          <div class="back-button" (click)="handleBackClick($event)">
+            <mat-icon class="homedecorator-material-icons">arrow_back</mat-icon>
+            <span class="back-button-span">Terug</span>
+          </div>
+          <div class="button-spacer"></div>
+          <div class="refresh-button" (click)="handleRefreshClick($event)">
+            <mat-icon class="homedecorator-material-icons">refresh</mat-icon>
+            <span class="refresh-button-span">Verversen</span>
+          </div>
+
+          <div class="button-spacer"></div>
+          <div class="refresh-button" (click)="iframeTest()">
+            <mat-icon class="homedecorator-material-icons">refresh</mat-icon>
+            <span class="refresh-button-span">iframeTest</span>
+          </div>
+
+        </div>
+        <ng-container *ngIf="showOwnCollection">
+          <rp-product-own-collection
+            [settings]="settingsService.settings"
+            (articleClick)="handleArticleClick($event)"
+          ></rp-product-own-collection>
+        </ng-container>
+
+        <ng-container *ngIf="homeDecoHub && !showOwnCollection && !showExternalCatalog">
+          <rp-model-uploader>
+
+          </rp-model-uploader>
+        </ng-container>
+
+
+        <ng-container *ngIf="!showOwnCollection && loaded">
+          <div class="own-collection-button-wrapper" (click)="handleShowOwnCollectionClick($event)"
+               *ngIf="!showExternalCatalog && settingsService.settings.options.showOwnCatalogButton">
+            <div class="own-collection-description" [textContent]="'OWN_COLLECTION' | localize"></div>
+            <co-image [source]="'assets/images/logo.svg'"></co-image>
+          </div>
+          <co-catalog-external-sources *ngIf="!showExternalCatalog"
+                                       (externalSourceClick)="handleExternalSourceClick($event)"></co-catalog-external-sources>
+          <co-catalog-external-source *ngIf="showExternalCatalog"
+                                      [options]="{searchOnStart: true}"
+                                      [externalCatalogStartupInfo]="catalogInfo"
+                                      [title]="'CATALOG' | localize | append: ' ' | append: externalCatalogName"
+                                      [subTitle]="'Zoeken naar artikelen'"
+                                      [searchPlaceholder]="'Zoek naar artikelen'"
+                                      [name]="externalCatalogName"
+                                      [showFilter]="false"
+                                      (articleClick)="handleArticleClick($event, catalogInfo)"
+                                      [class.hide-filter]="settingsService.settings.options.showOnlyHomeDecoFilter"
+                                      (iFrameFeedbackReceived)="handleIFrameFeedback($event)"
+          ></co-catalog-external-source>
+        </ng-container>
+        <button mat-icon-button class="hide-catalog" (click)="hideCatalog()">
+          <mat-icon class="homedecorator-material-icons" aria-hidden="true">close</mat-icon>
+        </button>
+      </div>
+  `, isInline: true, styles: [":host{display:none;z-index:99;overflow:hidden}:host .layer{pointer-events:all!important;overflow-y:hidden;display:flex;flex-direction:column}:host .product-catalog-wrapper{display:flex;flex-direction:column;height:100%;padding:30px}:host .product-catalog-wrapper .catalog-button-wrapper{font-size:16px;margin-bottom:20px}:host .product-catalog-wrapper .co-catalog-external-source{display:flex;flex-basis:100%}:host .own-collection-button-wrapper{cursor:pointer}:host .own-collection-button-wrapper .own-collection-description{font-size:12px;font-weight:bold;text-shadow:none;text-transform:capitalize;margin:10px 0}:host .own-collection-button-wrapper .co-image{padding:25px;background:#3760a1;border-radius:10px}:host.shown{display:inline-block;position:relative;top:64px;left:64px;width:calc(100% - 64px);height:calc(100vh - 64px);background-color:#fff}:host.no-offset{left:0;width:100%;z-index:100}:host .ione-catalog{display:block;overflow:hidden}:host .ione-catalog ::ng-deep app-catalog{overflow:hidden}:host .catalog-button-wrapper .back-button,:host .catalog-button-wrapper .refresh-button{cursor:pointer;display:inline-block;font-weight:bold}:host .catalog-button-wrapper .back-button .refresh-button-span,:host .catalog-button-wrapper .back-button .back-button-span,:host .catalog-button-wrapper .refresh-button .refresh-button-span,:host .catalog-button-wrapper .refresh-button .back-button-span{vertical-align:top;line-height:25px;margin:10px 5px 0}:host .catalog-button-wrapper .button-spacer{display:inline-block;margin:0 10px}:host .product-catalog-wrapper{overflow:auto}:host .hide-catalog{position:absolute;top:6px;right:0px;z-index:100}.co-catalog-external-sources .external-source-item .co-image img{object-fit:cover}::ng-deep .co-catalog-navigation{position:relative}::ng-deep .co-catalog-navigation .navigation-overlay-wrapper{position:absolute!important;left:-40px!important;padding:20px 40px;grid-column-gap:60px}\n"], components: [{ type: i12.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i13.ProductOwnCollectionComponent, selector: "rp-product-own-collection", inputs: ["settings"], outputs: ["articleClick", "arButtonClick"] }, { type: i14.ModelUploaderComponent, selector: "rp-model-uploader" }, { type: i15.ImageComponent, selector: "co-image", inputs: ["source", "placeHolder"] }, { type: i7.ɵt, selector: "co-catalog-external-sources", outputs: ["externalSourceClick"] }, { type: i7.ɵbg, selector: "co-catalog-external-source", inputs: ["showFilter", "showNavigation", "catalogDefinitionId", "externalCatalogStartupInfo", "user", "title", "subTitle", "searchPlaceholder", "options", "name"], outputs: ["articleClick", "addArticleClick", "iFrameFeedbackReceived"] }, { type: i16.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }], directives: [{ type: i17.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "localize": i18.LocalizePipe, "append": i19.AppendPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductCatalogComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'rp-product-catalog',
+                    template: `
+      <div class="product-catalog-wrapper">
+        <div class="catalog-button-wrapper" *ngIf="showOwnCollection || showExternalCatalog">
+          <div class="back-button" (click)="handleBackClick($event)">
+            <mat-icon class="homedecorator-material-icons">arrow_back</mat-icon>
+            <span class="back-button-span">Terug</span>
+          </div>
+          <div class="button-spacer"></div>
+          <div class="refresh-button" (click)="handleRefreshClick($event)">
+            <mat-icon class="homedecorator-material-icons">refresh</mat-icon>
+            <span class="refresh-button-span">Verversen</span>
+          </div>
+
+          <div class="button-spacer"></div>
+          <div class="refresh-button" (click)="iframeTest()">
+            <mat-icon class="homedecorator-material-icons">refresh</mat-icon>
+            <span class="refresh-button-span">iframeTest</span>
+          </div>
+
+        </div>
+        <ng-container *ngIf="showOwnCollection">
+          <rp-product-own-collection
+            [settings]="settingsService.settings"
+            (articleClick)="handleArticleClick($event)"
+          ></rp-product-own-collection>
+        </ng-container>
+
+        <ng-container *ngIf="homeDecoHub && !showOwnCollection && !showExternalCatalog">
+          <rp-model-uploader>
+
+          </rp-model-uploader>
+        </ng-container>
+
+
+        <ng-container *ngIf="!showOwnCollection && loaded">
+          <div class="own-collection-button-wrapper" (click)="handleShowOwnCollectionClick($event)"
+               *ngIf="!showExternalCatalog && settingsService.settings.options.showOwnCatalogButton">
+            <div class="own-collection-description" [textContent]="'OWN_COLLECTION' | localize"></div>
+            <co-image [source]="'assets/images/logo.svg'"></co-image>
+          </div>
+          <co-catalog-external-sources *ngIf="!showExternalCatalog"
+                                       (externalSourceClick)="handleExternalSourceClick($event)"></co-catalog-external-sources>
+          <co-catalog-external-source *ngIf="showExternalCatalog"
+                                      [options]="{searchOnStart: true}"
+                                      [externalCatalogStartupInfo]="catalogInfo"
+                                      [title]="'CATALOG' | localize | append: ' ' | append: externalCatalogName"
+                                      [subTitle]="'Zoeken naar artikelen'"
+                                      [searchPlaceholder]="'Zoek naar artikelen'"
+                                      [name]="externalCatalogName"
+                                      [showFilter]="false"
+                                      (articleClick)="handleArticleClick($event, catalogInfo)"
+                                      [class.hide-filter]="settingsService.settings.options.showOnlyHomeDecoFilter"
+                                      (iFrameFeedbackReceived)="handleIFrameFeedback($event)"
+          ></co-catalog-external-source>
+        </ng-container>
+        <button mat-icon-button class="hide-catalog" (click)="hideCatalog()">
+          <mat-icon class="homedecorator-material-icons" aria-hidden="true">close</mat-icon>
+        </button>
+      </div>
+  `,
+                    styleUrls: ['./product-catalog.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HomedecoratorSettingsService }, { type: i2.MessageBusService }, { type: i3.HomedecoratorConnectorService }, { type: i4.ScreenSizeAnalysisService }, { type: i5.SceneService }, { type: i6.FloorplanService }, { type: i0.Injector }, { type: i7.CatalogService }, { type: i8.DynamicScriptService }, { type: i9.HomedecoratorConnectorAdapterService }, { type: i10.BuildFurnitureService }, { type: i11.ThirdPartyModelService }]; }, propDecorators: { shown: [{
+                type: HostBinding,
+                args: ['class.shown']
+            }], phoneSizeScreen: [{
+                type: HostBinding,
+                args: ['class.no-offset']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"product-catalog.component.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/product-catalog/product-catalog/product-catalog.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, HostBinding, Injector, OnDestroy, OnInit} from '@angular/core';\r\nimport {Subscription} from 'rxjs';\r\nimport {ExternalSource} from '@colijnit/articleapi/build/model/external-source.bo';\r\nimport {ExternalCatalogStartupInfo} from '@colijnit/articleapi/build/model/external-catalog-startup-info';\r\nimport {CatalogDefinition} from '@colijnit/articleapi/build/model/catalog-definition.bo';\r\nimport {HomedecoratorSettings} from '../../../core/model/homedecorator-settings';\r\nimport {ExternalSourceViewmodel} from '@colijnit/catalog/lib/model/external-source-viewmodel';\r\nimport {HomedecoratorSettingsService} from '../../../core/service/homedecorator-settings.service';\r\nimport {MessageBusService} from '../../../core/service/message-bus.service';\r\nimport {ScreenSizeAnalysisService} from '../../../shared/screen-size-analysis/screen-size-analysis.service';\r\nimport {SceneService} from '../../core3d/service/scene.service';\r\nimport {BuildFurnitureService} from '../../threedselector/threedselector/service/build-furniture.service';\r\nimport {FloorplanService} from '../../room-planner/components/floorplanner/service/floorplan.service';\r\nimport {CatalogService} from '@colijnit/catalog';\r\nimport {DynamicScriptService} from '../../../service/dynamic-script.service';\r\nimport {MessageType} from '../../../core/enum/message-type.enum';\r\nimport {HomedecoratorConnectorService} from '../../../core/service/homedecorator-connector.service';\r\nimport {HomedecoratorConnectorAdapterService} from '../../../core/service/homedecorator-connector-adapter.service';\r\nimport {ExternalCatalogStartupInfoRequest} from '@colijnit/articleapi/build/model/external-catalog-startup-info-request';\r\nimport {ExternalSettingsInterface} from '../../../core/interface/external-settings.interface';\r\nimport {ArticleListObjectExtended} from '@colijnit/configuratorapi/build/model/article-list-object-extended';\r\nimport {ThirdPartyModelService} from '../../threedselector/threedselector/service/third-party-model.service';\r\n\r\n@Component({\r\n    selector: 'rp-product-catalog',\r\n    template: `\r\n      <div class=\"product-catalog-wrapper\">\r\n        <div class=\"catalog-button-wrapper\" *ngIf=\"showOwnCollection || showExternalCatalog\">\r\n          <div class=\"back-button\" (click)=\"handleBackClick($event)\">\r\n            <mat-icon class=\"homedecorator-material-icons\">arrow_back</mat-icon>\r\n            <span class=\"back-button-span\">Terug</span>\r\n          </div>\r\n          <div class=\"button-spacer\"></div>\r\n          <div class=\"refresh-button\" (click)=\"handleRefreshClick($event)\">\r\n            <mat-icon class=\"homedecorator-material-icons\">refresh</mat-icon>\r\n            <span class=\"refresh-button-span\">Verversen</span>\r\n          </div>\r\n\r\n          <div class=\"button-spacer\"></div>\r\n          <div class=\"refresh-button\" (click)=\"iframeTest()\">\r\n            <mat-icon class=\"homedecorator-material-icons\">refresh</mat-icon>\r\n            <span class=\"refresh-button-span\">iframeTest</span>\r\n          </div>\r\n\r\n        </div>\r\n        <ng-container *ngIf=\"showOwnCollection\">\r\n          <rp-product-own-collection\r\n            [settings]=\"settingsService.settings\"\r\n            (articleClick)=\"handleArticleClick($event)\"\r\n          ></rp-product-own-collection>\r\n        </ng-container>\r\n\r\n        <ng-container *ngIf=\"homeDecoHub && !showOwnCollection && !showExternalCatalog\">\r\n          <rp-model-uploader>\r\n\r\n          </rp-model-uploader>\r\n        </ng-container>\r\n\r\n\r\n        <ng-container *ngIf=\"!showOwnCollection && loaded\">\r\n          <div class=\"own-collection-button-wrapper\" (click)=\"handleShowOwnCollectionClick($event)\"\r\n               *ngIf=\"!showExternalCatalog && settingsService.settings.options.showOwnCatalogButton\">\r\n            <div class=\"own-collection-description\" [textContent]=\"'OWN_COLLECTION' | localize\"></div>\r\n            <co-image [source]=\"'assets/images/logo.svg'\"></co-image>\r\n          </div>\r\n          <co-catalog-external-sources *ngIf=\"!showExternalCatalog\"\r\n                                       (externalSourceClick)=\"handleExternalSourceClick($event)\"></co-catalog-external-sources>\r\n          <co-catalog-external-source *ngIf=\"showExternalCatalog\"\r\n                                      [options]=\"{searchOnStart: true}\"\r\n                                      [externalCatalogStartupInfo]=\"catalogInfo\"\r\n                                      [title]=\"'CATALOG' | localize | append: ' ' | append: externalCatalogName\"\r\n                                      [subTitle]=\"'Zoeken naar artikelen'\"\r\n                                      [searchPlaceholder]=\"'Zoek naar artikelen'\"\r\n                                      [name]=\"externalCatalogName\"\r\n                                      [showFilter]=\"false\"\r\n                                      (articleClick)=\"handleArticleClick($event, catalogInfo)\"\r\n                                      [class.hide-filter]=\"settingsService.settings.options.showOnlyHomeDecoFilter\"\r\n                                      (iFrameFeedbackReceived)=\"handleIFrameFeedback($event)\"\r\n          ></co-catalog-external-source>\r\n        </ng-container>\r\n        <button mat-icon-button class=\"hide-catalog\" (click)=\"hideCatalog()\">\r\n          <mat-icon class=\"homedecorator-material-icons\" aria-hidden=\"true\">close</mat-icon>\r\n        </button>\r\n      </div>\r\n  `,\r\n  styleUrls: ['./product-catalog.component.scss']\r\n})\r\nexport class ProductCatalogComponent implements OnInit, OnDestroy {\r\n    @HostBinding('class.shown')\r\n    public get shown(): boolean {\r\n        return this._showCatalog;\r\n    }\r\n\r\n    public loaded: boolean;\r\n    public settings: HomedecoratorSettings;\r\n    @HostBinding('class.no-offset')\r\n    public phoneSizeScreen: boolean;\r\n\r\n    public externalCatalogName: string;\r\n    public showExternalCatalog: boolean = false;\r\n    public showOwnCollection: boolean = false;\r\n    public externalSource: ExternalSource;\r\n    public catalogDefinition: CatalogDefinition;\r\n    public catalogInfo: ExternalCatalogStartupInfo;\r\n\r\n    public homeDecoHub = this.settingsService.settings.user3DModelUploadEnabled;\r\n\r\n    private _showCatalog: boolean;\r\n    private _subs: Subscription[] = [];\r\n\r\n  private _source: ExternalSourceViewmodel;\r\n\r\n  constructor(\r\n    public settingsService: HomedecoratorSettingsService,\r\n    private _messageBus: MessageBusService,\r\n    private _ioneController: HomedecoratorConnectorService,\r\n    private _screenSizeService: ScreenSizeAnalysisService,\r\n    private _sceneService: SceneService,\r\n    private _floorPlanService: FloorplanService,\r\n    private _injector: Injector,\r\n    private _catalogService: CatalogService,\r\n    private _dynamicScriptService: DynamicScriptService,\r\n    private _adapterService: HomedecoratorConnectorAdapterService,\r\n    private _buildFurnitureService: BuildFurnitureService,\r\n    private _thirdPartyModelService: ThirdPartyModelService\r\n  ) {\r\n  }\r\n\r\n  async ngOnInit(): Promise<void> {\r\n    this._subs.push(\r\n      this._messageBus.subscribe(\r\n        MessageType.ShowProductCatalog, () => this._handleShowProductCatalogMessageReceived()\r\n      ),\r\n      this._messageBus.subscribe(\r\n        MessageType.HideProductCatalog, () => this.hideCatalog()\r\n      ),\r\n      this._messageBus.subscribe(\r\n        MessageType.ViewModeChanged, () => this.hideCatalog()\r\n      ),\r\n      this._ioneController.controllerInitialized.subscribe((loaded: boolean) => {\r\n        if (loaded) {\r\n          this.settings = undefined;\r\n          // this.loaded = false;\r\n          setTimeout(async () => {\r\n            this.settings = this.settingsService.settings;\r\n            this._catalogService.init(this.settings);\r\n            this.loaded = true;\r\n          }, 200);\r\n        }\r\n      }),\r\n      this._screenSizeService.screenSizeChanged.subscribe(info => this.phoneSizeScreen = info.isPhoneSize)\r\n    );\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(sub => sub.unsubscribe());\r\n  }\r\n\r\n  public hideCatalog(): void {\r\n    this._showCatalog = false;\r\n  }\r\n\r\n  public handleArticleClick(data: {\r\n    article: ArticleListObjectExtended,\r\n    settings: ExternalSettingsInterface\r\n  }, catalogInfo?: ExternalCatalogStartupInfo): void {\r\n    if (data.article) {\r\n      if (catalogInfo && catalogInfo.externalSource) {\r\n        data.settings.externalSourceId = catalogInfo.externalSource.sourceId;\r\n        data.settings.schema = catalogInfo.externalSource.schema;\r\n        data.settings.settings.password = '';\r\n        data.settings.settings.username = '';\r\n      }\r\n      this._messageBus.emit(MessageType.LoadIOneFurnitureIntoSceneBySKU, {\r\n        sku: data.article.articleNumber,\r\n        settings: data.settings,\r\n        position: this._floorPlanService.getCenter(),\r\n        fullArticleObject: data.article\r\n      });\r\n      this._showCatalog = false;\r\n    }\r\n  }\r\n\r\n  public handleArButtonClick(data: { article: ArticleListObjectExtended, settings: ExternalSettingsInterface }): void {\r\n    if (data.article) {\r\n      this._sceneService.arMode = true;\r\n      this._showCatalog = false;\r\n      this._messageBus.emit(MessageType.LoadIOneFurnitureIntoSceneBySKU, {\r\n        sku: data.article.articleNumber,\r\n        settings: data.settings,\r\n        position: {x: 0, y: 0},\r\n        fullArticleObject: data.article\r\n      });\r\n    }\r\n  }\r\n\r\n  public async handleExternalSourceClick(source?: ExternalSourceViewmodel): Promise<void> {\r\n    if (source) {\r\n      this._source = source;\r\n      // reset connection to host\r\n      // @ts-ignore\r\n      await this._adapterService.initConnector(this.settingsService.settings, undefined);\r\n\r\n      this.catalogDefinition = source.catalogDefinition;\r\n      this.externalSource = source.externalSource;\r\n      this.externalCatalogName = source.catalogDefinition.name;\r\n      let info: ExternalCatalogStartupInfo = new ExternalCatalogStartupInfo();\r\n\r\n      const request: ExternalCatalogStartupInfoRequest = this._buildExternalCatalogRequest();\r\n\r\n      info = await this._ioneController.getWebViewStartupInfo(request);\r\n      this.catalogInfo = info;\r\n      this.showExternalCatalog = true;\r\n    } else {\r\n      this.showExternalCatalog = false;\r\n    }\r\n  }\r\n\r\n  public handleShowOwnCollectionClick(event: MouseEvent): void {\r\n    this.showOwnCollection = true;\r\n  }\r\n\r\n  public handleBackClick(event: MouseEvent): void {\r\n    this.showExternalCatalog = false;\r\n    this.showOwnCollection = false;\r\n  }\r\n\r\n  public handleRefreshClick(event: MouseEvent): void {\r\n    this.handleExternalSourceClick(this._source);\r\n  }\r\n\r\n  public async handleIFrameFeedback(jsonString: string): Promise<void> {\r\n    if (jsonString) {\r\n      const jsonObj = JSON.parse(jsonString);\r\n      if (jsonObj['hash'] !== undefined) {\r\n        const customerName: string = 'Linteloo';\r\n        // three main api urls\r\n        const modelUrl: string = this.catalogInfo.externalSource.domain + '/models/' + jsonObj['hash'] + '/glb';\r\n        const configurationUrl: string = this.catalogInfo.externalSource.domain + '/configurationData/' + jsonObj['hash'];\r\n        const priceDataUrl: string = this.catalogInfo.externalSource.domain + '/rules/api/' + customerName.toLowerCase() + '/' + jsonObj['hash'];\r\n\r\n        try {\r\n          const apiResponses: Response[] = await Promise.all([\r\n            this._thirdPartyModelService.downloadModel(modelUrl),\r\n            this._thirdPartyModelService.fetchJsonFile(configurationUrl),\r\n            this._thirdPartyModelService.fetchJsonFile(priceDataUrl)\r\n          ]);\r\n          const modelResponse: Response = apiResponses[0];\r\n          const configurationResponse: Response = apiResponses[1];\r\n          const priceDataResponse: Response = apiResponses[2];\r\n\r\n          let configurationData: any;\r\n          let priceData: any;\r\n\r\n          if (modelResponse && modelResponse.ok) {\r\n            modelResponse.arrayBuffer().then(data => {\r\n              if (configurationResponse && configurationResponse.ok) {\r\n                configurationResponse.json().then(result => {\r\n                  console.log(result);\r\n                  configurationData = result;\r\n                }).catch(e => {\r\n                  console.log(e);\r\n                  configurationData = {};\r\n                });\r\n              }\r\n              if (priceDataResponse && priceDataResponse.ok) {\r\n                priceDataResponse.json().then(result => {\r\n                  console.log(result);\r\n                  priceData = result;\r\n                }).catch(e => {\r\n                  console.log(e);\r\n                  priceData = {};\r\n                });\r\n              }\r\n              this._thirdPartyModelService.parseModelToGLB(data, jsonObj['hash'], modelUrl, configurationData, priceData).then(result => {\r\n                this.hideCatalog();\r\n              });\r\n            });\r\n          } else if (!modelResponse.ok) {\r\n            throw new Error('Failed to fetch data');\r\n          }\r\n\r\n          // const response: Response = await this._thirdPartyModelService.downloadModel(urlToFetch);\r\n          // if (!response.ok) {\r\n          //   throw new Error('Failed to fetch data');\r\n          // }\r\n          // response.arrayBuffer().then(data => {\r\n          //   this._thirdPartyModelService.parseModelToGLB(data, jsonObj['hash'], urlToFetch).then(result => {\r\n          //     this.hideCatalog();\r\n          //   });\r\n          // });\r\n        } catch (error) {\r\n          console.error('Error fetching data:', error);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  public async iframeTest(): Promise<void> {\r\n\r\n    // three main api urls\r\n    const modelUrl: string = 'https://linteloo.platformapi-accept.3dimerce.com/models/3920f50cbbdcb5980c8994746df0f62127ce1064108cd7bc1a27ea7d4c171dc8/glb';\r\n    const configurationUrl: string = 'https://linteloo.platformapi-accept.3dimerce.com/configurationData/3920f50cbbdcb5980c8994746df0f62127ce1064108cd7bc1a27ea7d4c171dc8';\r\n    const priceDataUrl: string = 'https://linteloo.platformapi-accept.3dimerce.com/rules/api/linteloo/3920f50cbbdcb5980c8994746df0f62127ce1064108cd7bc1a27ea7d4c171dc8';\r\n    const hash: string = '3920f50cbbdcb5980c8994746df0f62127ce1064108cd7bc1a27ea7d4c171dc8';\r\n\r\n    try {\r\n      const apiResponses: Response[] = await Promise.all([\r\n        this._thirdPartyModelService.downloadModel(modelUrl),\r\n        this._thirdPartyModelService.fetchJsonFile(configurationUrl),\r\n        this._thirdPartyModelService.fetchJsonFile(priceDataUrl)\r\n      ]);\r\n      const modelResponse: Response = apiResponses[0];\r\n      const configurationResponse: Response = apiResponses[1];\r\n      const priceDataResponse: Response = apiResponses[2];\r\n\r\n      let configurationData: any;\r\n      let priceData: any;\r\n\r\n      if (modelResponse && modelResponse.ok) {\r\n        modelResponse.arrayBuffer().then(data => {\r\n          if (configurationResponse && configurationResponse.ok) {\r\n            configurationResponse.json().then(result => {\r\n              console.log(result);\r\n              configurationData = result;\r\n            }).catch(e => {\r\n              console.log(e);\r\n              configurationData = {};\r\n            });\r\n          }\r\n          if (priceDataResponse && priceDataResponse.ok) {\r\n            priceDataResponse.json().then(result => {\r\n              console.log(result);\r\n              priceData = result;\r\n            }).catch(e => {\r\n              console.log(e);\r\n              priceData = {};\r\n            });\r\n          }\r\n          this._thirdPartyModelService.parseModelToGLB(data, hash, modelUrl, configurationData, priceData).then(result => {\r\n            this.hideCatalog();\r\n          });\r\n        });\r\n      } else if (!modelResponse.ok) {\r\n        throw new Error('Failed to fetch data');\r\n      }\r\n    } catch (error) {\r\n      console.error('Error fetching data:', error);\r\n    }\r\n\r\n    // let configurationData: any;\r\n    // let priceData: any;\r\n    //\r\n    // // get config data\r\n    // const configurationUrlResponse = await this._thirdPartyModelService.fetchJsonFile(configurationUrl).catch((e) => console.error(e));\r\n    // if (configurationUrlResponse && configurationUrlResponse.ok) {\r\n    //   configurationData = await configurationUrlResponse.json();\r\n    // }\r\n    //\r\n    // // get pricing data\r\n    // const priceDataResponse = await this._thirdPartyModelService.fetchJsonFile(priceDataUrl).catch((e) => console.error(e));\r\n    // if (priceDataResponse && priceDataResponse.ok) {\r\n    //   priceData = await priceDataResponse.json();\r\n    // }\r\n    // // get model and create the object\r\n    // this._thirdPartyModelService.downloadModel(modelUrl).then(result => {\r\n    //   if (result && result.ok) {\r\n    //     result.arrayBuffer().then(data => {\r\n    //       this._thirdPartyModelService.parseModelToGLB(data, hash, modelUrl, configurationData, priceData).then(status => {\r\n    //         this.hideCatalog();\r\n    //       });\r\n    //     });\r\n    //   }\r\n    // }).catch(e => {\r\n    //   console.log(e);\r\n    // });\r\n  }\r\n\r\n  private _buildExternalCatalogRequest(): ExternalCatalogStartupInfoRequest {\r\n    const request: ExternalCatalogStartupInfoRequest = new ExternalCatalogStartupInfoRequest();\r\n    // @ts-ignore\r\n    request.catalogId = this.catalogDefinition.getId();\r\n    request.posName = 'NNB'; // Nog Niet Bepaald\r\n    return request;\r\n  }\r\n\r\n  private async _handleShowProductCatalogMessageReceived(): Promise<void> {\r\n    this._showCatalog = true;\r\n  }\r\n}\r\n"]}

package/esm2015/app/plugins/product-catalog/product-catalog.module.js

@@ -0,0 +1,61 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { ButtonModule } from '@colijnit/corecomponents';
+import { CatalogExternalSourceModule, CatalogExternalSourcesModule } from '@colijnit/catalog';
+import { ImageModule } from '@colijnit/corecomponents_v12';
+import { CoreModule } from '../../core/core.module';
+import { ProductOwnCollectionModule } from './own-collection-catalog/product-own-collection.module';
+import { ProductCatalogComponent } from './product-catalog/product-catalog.component';
+import { ModelUploaderModule } from '../model-uploader/model-uploader.module';
+import * as i0 from "@angular/core";
+export class ProductCatalogModule {
+}
+ProductCatalogModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductCatalogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ProductCatalogModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductCatalogModule, declarations: [ProductCatalogComponent], imports: [CommonModule,
+        CoreModule,
+        MatIconModule,
+        MatButtonModule,
+        ButtonModule,
+        ImageModule,
+        CatalogExternalSourcesModule,
+        ProductOwnCollectionModule,
+        CatalogExternalSourceModule,
+        ModelUploaderModule], exports: [ProductCatalogComponent] });
+ProductCatalogModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductCatalogModule, imports: [[
+            CommonModule,
+            CoreModule,
+            MatIconModule,
+            MatButtonModule,
+            ButtonModule,
+            ImageModule,
+            CatalogExternalSourcesModule,
+            ProductOwnCollectionModule,
+            CatalogExternalSourceModule,
+            ModelUploaderModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ProductCatalogModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        CoreModule,
+                        MatIconModule,
+                        MatButtonModule,
+                        ButtonModule,
+                        ImageModule,
+                        CatalogExternalSourcesModule,
+                        ProductOwnCollectionModule,
+                        CatalogExternalSourceModule,
+                        ModelUploaderModule
+                    ],
+                    exports: [
+                        ProductCatalogComponent
+                    ],
+                    declarations: [
+                        ProductCatalogComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/plugins/render/enum/connection-status.js

@@ -0,0 +1,8 @@
+export var ConnectionStatus;
+(function (ConnectionStatus) {
+    ConnectionStatus[ConnectionStatus["IsUndefined"] = 0] = "IsUndefined";
+    ConnectionStatus[ConnectionStatus["IsConnected"] = 1] = "IsConnected";
+    ConnectionStatus[ConnectionStatus["TryingToConnect"] = 2] = "TryingToConnect";
+    ConnectionStatus[ConnectionStatus["IsDisConnected"] = 3] = "IsDisConnected";
+})(ConnectionStatus || (ConnectionStatus = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGlvbi1zdGF0dXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2xpZW50L2FwcC9wbHVnaW5zL3JlbmRlci9lbnVtL2Nvbm5lY3Rpb24tc3RhdHVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLGdCQUtYO0FBTEQsV0FBWSxnQkFBZ0I7SUFDMUIscUVBQWUsQ0FBQTtJQUNmLHFFQUFlLENBQUE7SUFDZiw2RUFBbUIsQ0FBQTtJQUNuQiwyRUFBa0IsQ0FBQTtBQUNwQixDQUFDLEVBTFcsZ0JBQWdCLEtBQWhCLGdCQUFnQixRQUszQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIENvbm5lY3Rpb25TdGF0dXMge1xyXG4gIElzVW5kZWZpbmVkID0gMCxcclxuICBJc0Nvbm5lY3RlZCA9IDEsXHJcbiAgVHJ5aW5nVG9Db25uZWN0ID0gMixcclxuICBJc0Rpc0Nvbm5lY3RlZCA9IDNcclxufVxyXG4iXX0=

package/esm2015/app/plugins/render/enum/render-modes.js

@@ -0,0 +1,7 @@
+export var RenderModes;
+(function (RenderModes) {
+    RenderModes["RenderRoom"] = "render_room";
+    RenderModes["RenderShop"] = "render_shop";
+    RenderModes["RenderIone"] = "render_ione";
+})(RenderModes || (RenderModes = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVuZGVyLW1vZGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2NsaWVudC9hcHAvcGx1Z2lucy9yZW5kZXIvZW51bS9yZW5kZXItbW9kZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksV0FJWDtBQUpELFdBQVksV0FBVztJQUNyQix5Q0FBMEIsQ0FBQTtJQUMxQix5Q0FBMEIsQ0FBQTtJQUMxQix5Q0FBMEIsQ0FBQTtBQUM1QixDQUFDLEVBSlcsV0FBVyxLQUFYLFdBQVcsUUFJdEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBSZW5kZXJNb2RlcyB7XHJcbiAgUmVuZGVyUm9vbSA9ICdyZW5kZXJfcm9vbScsXHJcbiAgUmVuZGVyU2hvcCA9ICdyZW5kZXJfc2hvcCcsXHJcbiAgUmVuZGVySW9uZSA9ICdyZW5kZXJfaW9uZSdcclxufVxyXG4iXX0=

package/esm2015/app/plugins/render/enum/render-status.js

@@ -0,0 +1,9 @@
+export var RenderStatus;
+(function (RenderStatus) {
+    RenderStatus[RenderStatus["IsUndefined"] = 0] = "IsUndefined";
+    RenderStatus[RenderStatus["IsRunning"] = 1] = "IsRunning";
+    RenderStatus[RenderStatus["IsSuccess"] = 2] = "IsSuccess";
+    RenderStatus[RenderStatus["IsStopped"] = 3] = "IsStopped";
+    RenderStatus[RenderStatus["IsWaiting"] = 4] = "IsWaiting";
+})(RenderStatus || (RenderStatus = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVuZGVyLXN0YXR1cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jbGllbnQvYXBwL3BsdWdpbnMvcmVuZGVyL2VudW0vcmVuZGVyLXN0YXR1cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxZQU1YO0FBTkQsV0FBWSxZQUFZO0lBQ3RCLDZEQUFlLENBQUE7SUFDZix5REFBYSxDQUFBO0lBQ2IseURBQWEsQ0FBQTtJQUNiLHlEQUFhLENBQUE7SUFDYix5REFBYSxDQUFBO0FBQ2YsQ0FBQyxFQU5XLFlBQVksS0FBWixZQUFZLFFBTXZCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gUmVuZGVyU3RhdHVzIHtcclxuICBJc1VuZGVmaW5lZCA9IDAsXHJcbiAgSXNSdW5uaW5nID0gMSxcclxuICBJc1N1Y2Nlc3MgPSAyLFxyXG4gIElzU3RvcHBlZCA9IDMsXHJcbiAgSXNXYWl0aW5nID0gNFxyXG59XHJcbiJdfQ==

package/esm2015/app/plugins/render/model/camera-position.js

@@ -0,0 +1,6 @@
+export class CameraPosition {
+    constructor() {
+        this.angle = 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FtZXJhLXBvc2l0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2NsaWVudC9hcHAvcGx1Z2lucy9yZW5kZXIvbW9kZWwvY2FtZXJhLXBvc2l0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxjQUFjO0lBQTNCO1FBS1MsVUFBSyxHQUFXLENBQUMsQ0FBQztJQUMzQixDQUFDO0NBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgQ2FtZXJhUG9zaXRpb24ge1xyXG4gIHB1YmxpYyBpZDogbnVtYmVyO1xyXG4gIHB1YmxpYyBuYW1lOiBzdHJpbmc7XHJcbiAgcHVibGljIHBvc2l0aW9uOiBudW1iZXI7XHJcbiAgcHVibGljIHR5cGU6IHN0cmluZztcclxuICBwdWJsaWMgYW5nbGU6IG51bWJlciA9IDA7XHJcbn1cclxuIl19

package/esm2015/app/plugins/render/model/image-size.js

@@ -0,0 +1,3 @@
+export class ImageSize {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1hZ2Utc2l6ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jbGllbnQvYXBwL3BsdWdpbnMvcmVuZGVyL21vZGVsL2ltYWdlLXNpemUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFNBQVM7Q0FLckIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgSW1hZ2VTaXplIHtcclxuICBwdWJsaWMgaWQ6IG51bWJlcjtcclxuICBwdWJsaWMgbmFtZTogc3RyaW5nO1xyXG4gIHB1YmxpYyB3aWR0aDogbnVtYmVyO1xyXG4gIHB1YmxpYyBoZWlnaHQ6IG51bWJlcjtcclxufVxyXG4iXX0=

package/esm2015/app/plugins/render/model/lightning.js

@@ -0,0 +1,3 @@
+export class Lightning {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlnaHRuaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2NsaWVudC9hcHAvcGx1Z2lucy9yZW5kZXIvbW9kZWwvbGlnaHRuaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxTQUFTO0NBSXJCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIExpZ2h0bmluZyB7XHJcbiAgcHVibGljIGlkOiBudW1iZXI7XHJcbiAgcHVibGljIG5hbWU6IHN0cmluZztcclxuICBwdWJsaWMgc2V0dGluZ3M6IGFueTtcclxufVxyXG4iXX0=