@colijnit/homedecorator 255.1.1

package/esm2015/app/core/service/homedecorator-dictionary.service.js

@@ -0,0 +1,73 @@
+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 { Injectable } from '@angular/core';
+import { StringUtils } from '@colijnit/ioneconnector/build/utils/string-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./json-utils.service";
+export class HomedecoratorDictionaryService {
+    constructor(_jsonUtilsService) {
+        this._jsonUtilsService = _jsonUtilsService;
+        // Some dictionary values have one or more '|~' texts in them, meant to be replaced with client-side given texts.
+        this._placeholder = '|~';
+        this._client = 'homedecorator';
+        this._language = 'NL';
+    }
+    get(key, upperCaseFirst = true, ...replacementTexts) {
+        let text = this._dictionary && this._dictionary.hasOwnProperty(key.toUpperCase()) ? this._dictionary[key.toUpperCase()] : key;
+        if (upperCaseFirst) {
+            text = text.charAt(0).toUpperCase() + text.slice(1);
+        }
+        else {
+            text = text.charAt(0).toLowerCase() + text.slice(1);
+        }
+        if (replacementTexts.length > 0) {
+            text = StringUtils.ReplaceOccurrencesIn(text, this._placeholder, ...replacementTexts);
+        }
+        return text ? text : key;
+    }
+    setDictionary(path, client, languageCode, additionalTranslationFile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._language = languageCode ? languageCode : this._language;
+            let dictionaryData;
+            if (additionalTranslationFile) {
+                dictionaryData = yield this._getDictionaryData(additionalTranslationFile);
+            }
+            if (!dictionaryData && client) {
+                const fileName = `${client}_${this._language.toLowerCase()}_${this._language.toUpperCase()}.json`;
+                dictionaryData = yield this._getDictionaryData(path + 'assets/' + fileName);
+            }
+            if (!client || !dictionaryData) {
+                const fileName = `${this._client}_${this._language.toLowerCase()}_${this._language.toUpperCase()}.json`;
+                dictionaryData = yield this._getDictionaryData(path + 'assets/' + fileName);
+            }
+            else {
+                this._client = client;
+            }
+            this._dictionary = dictionaryData ? dictionaryData : this._dictionary;
+        });
+    }
+    _getDictionaryData(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._jsonUtilsService.readJsonFile(path, false)
+                .catch(() => {
+                return null;
+            });
+        });
+    }
+}
+HomedecoratorDictionaryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorDictionaryService, deps: [{ token: i1.JsonUtilsService }], target: i0.ɵɵFactoryTarget.Injectable });
+HomedecoratorDictionaryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorDictionaryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorDictionaryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.JsonUtilsService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/core/service/homedecorator-icon-cache.service.js

@@ -0,0 +1,43 @@
+import { Injectable } from '@angular/core';
+import { IconSvg } from '../model/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+export class HomedecoratorIconCacheService {
+    constructor(_sanitizer) {
+        this._sanitizer = _sanitizer;
+        this._iconCache = {};
+        this._allIcons = IconSvg;
+        this.setIconCache();
+    }
+    /**
+     * All the icons as a large JSON object, from the all-icons.json file.
+     * The object has property keys that are the icon names, and property values with the data string of the actual svg icon.
+     */
+    get iconCache() {
+        return this._iconCache;
+    }
+    getIcon(iconName) {
+        return this._iconCache[iconName.toLowerCase()];
+    }
+    getIconAsBase64(iconName) {
+        const icon = this._allIcons[iconName];
+        const base64Data = window.btoa(icon);
+        return this._sanitizer.bypassSecurityTrustUrl(`data:image/svg+xml;base64,${base64Data}`);
+    }
+    setIconCache() {
+        for (const key in this._allIcons) {
+            if (this._allIcons.hasOwnProperty(key)) {
+                this._iconCache[key.toLowerCase()] = this._sanitizer.bypassSecurityTrustHtml(this._allIcons[key]);
+            }
+        }
+    }
+}
+HomedecoratorIconCacheService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorIconCacheService, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Injectable });
+HomedecoratorIconCacheService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorIconCacheService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorIconCacheService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/core/service/homedecorator-settings.service.js

@@ -0,0 +1,146 @@
+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 { Injectable } from '@angular/core';
+import { HomedecoratorSettings } from '../model/homedecorator-settings';
+import { BehaviorSubject } from 'rxjs';
+import { environment } from '../../../environments/environment';
+import { isEmpty } from '../utils/function/is-empty.function';
+import { HomedecoratorSettingsOptions } from '../model/homedecorator-settings-options';
+import { InternalParam } from '@colijnit/mainapi/build/enum/internal-param.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "./json-utils.service";
+import * as i2 from "./homedecorator-dictionary.service";
+import * as i3 from "./homedecorator-connector-adapter.service";
+export class HomedecoratorSettingsService {
+    constructor(_jsonUtilsService, _dictionaryService, _connectorService) {
+        this._jsonUtilsService = _jsonUtilsService;
+        this._dictionaryService = _dictionaryService;
+        this._connectorService = _connectorService;
+        this.settingsLoaded = new BehaviorSubject(false);
+        this._settings = new HomedecoratorSettings();
+        // this._initializeSettings();
+    }
+    set settings(value) {
+        this._settings = value;
+    }
+    get settings() {
+        return this._settings;
+    }
+    get isPrivate() {
+        return !isEmpty(this.settings.username) && !isEmpty(this.settings.password);
+    }
+    createSettingsFromObject(obj) {
+        if (!this.settings) {
+            this.settings = new HomedecoratorSettings();
+        }
+        const ownOptions = Object.assign({}, this.settings.options);
+        const ownRenderParameters = Object.assign({}, this.settings.renderParameters);
+        this.settings = Object.assign({}, this.settings, obj);
+        if (obj.renderParameters) {
+            this.settings.renderParameters = Object.assign({}, ownRenderParameters, obj.renderParameters);
+        }
+        if (obj.options) {
+            this.settings.options = Object.assign({}, ownOptions, obj.options);
+        }
+        if (obj.hasOwnProperty('assetPath')) {
+            this.settings.assetPath = obj['assetPath'];
+            if (this.settings.assetPath[this.settings.assetPath.length - 1] !== '/') {
+                this.settings.assetPath += '/';
+            }
+            this.settings.threeDAssetPath = this.settings.assetPath;
+        }
+        if (obj.hasOwnProperty('threeDAssetPath')) {
+            this.settings.threeDAssetPath = obj['threeDAssetPath'];
+            if (this.settings.threeDAssetPath[this.settings.threeDAssetPath.length - 1] !== '/') {
+                this.settings.threeDAssetPath += '/';
+            }
+        }
+        if (obj.hasOwnProperty('blenderRenderService')) {
+            this.settings.blenderRenderService = obj['blenderRenderService'];
+        }
+        if (obj.hasOwnProperty('user3DModelUploadEnabled')) {
+            this.settings.user3DModelUploadEnabled = obj['user3DModelUploadEnabled'];
+        }
+        if (obj.hasOwnProperty('productRenderSceneAssetId')) {
+            this.settings.productRenderSceneAssetId = obj['productRenderSceneAssetId'];
+        }
+        else {
+            // set fallback, just to be sure.
+            this.settings.productRenderSceneAssetId = 'scene_studio_eevee';
+        }
+    }
+    initializeSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (environment.useSettings) {
+                // see if there's a json file for application settings
+                const jsonSettings = yield this._jsonUtilsService.readJsonFile('./settings/ione-connector.json', true);
+                if (jsonSettings) {
+                    yield this.initialize(jsonSettings);
+                }
+            }
+            yield this._checkUrlParameters();
+            this.settingsLoaded.next(true);
+        });
+    }
+    initialize(settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (settings) {
+                yield this.createSettingsFromObject(settings);
+            }
+            if (!this.settings.assetPath) {
+                try {
+                    let path = yield this._connectorService.getInternalParameter(InternalParam.GeneralAssetUrl);
+                    if (!path.endsWith('/')) {
+                        path += '/';
+                    }
+                    this.settings.assetPath = path;
+                }
+                catch (e) {
+                }
+            }
+            if (!this.settings.threeDAssetPath) {
+                let path = yield this._connectorService.getInternalParameter(InternalParam.AssetUrl);
+                if (!path.endsWith('/')) {
+                    path += '/';
+                }
+                this.settings.threeDAssetPath = path;
+            }
+            if (!this.settings.user3DModelUploadEnabled) {
+                const uploadSetting = yield this._connectorService.getInternalParameter(InternalParam.UPLOAD_3D_MODEL);
+                if (uploadSetting === 'J') {
+                    this.settings.user3DModelUploadEnabled = true;
+                }
+            }
+            yield this._dictionaryService.setDictionary(this.settings.assetPath, this.settings.client, this.settings.languageCode, this.settings.additionalTranslationFile);
+            this.settingsLoaded.next(true);
+        });
+    }
+    _checkUrlParameters() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const urlParams = new URLSearchParams(window.location.search);
+            const client = urlParams.get('client');
+            if (client) {
+                const jsonSettings = yield this._jsonUtilsService.readJsonFile(this.settings.assetPath + `assets/${client}-settings.json`, false);
+                this.settings = Object.assign(new HomedecoratorSettings(), jsonSettings);
+                this.settings.options = Object.assign(new HomedecoratorSettingsOptions(), this.settings.options);
+                this.settings.client = client;
+            }
+        });
+    }
+}
+HomedecoratorSettingsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorSettingsService, deps: [{ token: i1.JsonUtilsService }, { token: i2.HomedecoratorDictionaryService }, { token: i3.HomedecoratorConnectorAdapterService }], target: i0.ɵɵFactoryTarget.Injectable });
+HomedecoratorSettingsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorSettingsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorSettingsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.JsonUtilsService }, { type: i2.HomedecoratorDictionaryService }, { type: i3.HomedecoratorConnectorAdapterService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"homedecorator-settings.service.js","sourceRoot":"","sources":["../../../../../../src/client/app/core/service/homedecorator-settings.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\r\nimport {HomedecoratorSettings} from '../model/homedecorator-settings';\r\nimport {JsonUtilsService} from './json-utils.service';\r\nimport {BehaviorSubject} from 'rxjs';\r\nimport {environment} from '../../../environments/environment';\r\nimport {isEmpty} from '../utils/function/is-empty.function';\r\nimport {HomedecoratorSettingsOptions} from '../model/homedecorator-settings-options';\r\nimport {InternalParam} from '@colijnit/mainapi/build/enum/internal-param.enum';\r\nimport {HomedecoratorDictionaryService} from './homedecorator-dictionary.service';\r\nimport {HomedecoratorConnectorAdapterService} from './homedecorator-connector-adapter.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class HomedecoratorSettingsService {\r\n\r\n  public set settings(value: HomedecoratorSettings) {\r\n    this._settings = value;\r\n  }\r\n\r\n  public get settings(): HomedecoratorSettings {\r\n    return this._settings;\r\n  }\r\n\r\n  public get isPrivate(): boolean {\r\n    return !isEmpty(this.settings.username) && !isEmpty(this.settings.password);\r\n  }\r\n\r\n  public settingsLoaded: BehaviorSubject<boolean> = new BehaviorSubject(false);\r\n\r\n  private _settings: HomedecoratorSettings = new HomedecoratorSettings();\r\n\r\n  constructor(\r\n    private _jsonUtilsService: JsonUtilsService,\r\n    private _dictionaryService: HomedecoratorDictionaryService,\r\n    private _connectorService: HomedecoratorConnectorAdapterService\r\n  ) {\r\n    // this._initializeSettings();\r\n  }\r\n\r\n  public createSettingsFromObject(obj: any): void {\r\n    if (!this.settings) {\r\n      this.settings = new HomedecoratorSettings();\r\n    }\r\n    const ownOptions = Object.assign({}, this.settings.options);\r\n    const ownRenderParameters = Object.assign({}, this.settings.renderParameters);\r\n    this.settings = Object.assign({}, this.settings, obj);\r\n    if (obj.renderParameters) {\r\n      this.settings.renderParameters = Object.assign({}, ownRenderParameters, obj.renderParameters);\r\n    }\r\n    if (obj.options) {\r\n      this.settings.options = Object.assign({}, ownOptions, obj.options);\r\n    }\r\n    if (obj.hasOwnProperty('assetPath')) {\r\n      this.settings.assetPath = obj['assetPath'];\r\n      if (this.settings.assetPath[this.settings.assetPath.length - 1] !== '/') {\r\n        this.settings.assetPath += '/';\r\n      }\r\n      this.settings.threeDAssetPath = this.settings.assetPath;\r\n    }\r\n    if (obj.hasOwnProperty('threeDAssetPath')) {\r\n      this.settings.threeDAssetPath = obj['threeDAssetPath'];\r\n      if (this.settings.threeDAssetPath[this.settings.threeDAssetPath.length - 1] !== '/') {\r\n        this.settings.threeDAssetPath += '/';\r\n      }\r\n    }\r\n    if (obj.hasOwnProperty('blenderRenderService')) {\r\n      this.settings.blenderRenderService = obj['blenderRenderService'];\r\n    }\r\n    if (obj.hasOwnProperty('user3DModelUploadEnabled')) {\r\n      this.settings.user3DModelUploadEnabled = obj['user3DModelUploadEnabled'];\r\n    }\r\n    if (obj.hasOwnProperty('productRenderSceneAssetId')) {\r\n      this.settings.productRenderSceneAssetId = obj['productRenderSceneAssetId'];\r\n    } else {\r\n      // set fallback, just to be sure.\r\n      this.settings.productRenderSceneAssetId = 'scene_studio_eevee';\r\n    }\r\n  }\r\n\r\n  public async initializeSettings(): Promise<void> {\r\n    if (environment.useSettings) {\r\n      // see if there's a json file for application settings\r\n      const jsonSettings: any = await this._jsonUtilsService.readJsonFile('./settings/ione-connector.json', true);\r\n      if (jsonSettings) {\r\n        await this.initialize(jsonSettings);\r\n      }\r\n    }\r\n    await this._checkUrlParameters();\r\n    this.settingsLoaded.next(true);\r\n  }\r\n\r\n  public async initialize(settings: HomedecoratorSettings): Promise<void> {\r\n    if (settings) {\r\n      await this.createSettingsFromObject(settings);\r\n    }\r\n    if (!this.settings.assetPath) {\r\n      try {\r\n        let path = await this._connectorService.getInternalParameter(InternalParam.GeneralAssetUrl);\r\n        if (!path.endsWith('/')) {\r\n          path += '/';\r\n        }\r\n        this.settings.assetPath = path;\r\n      } catch (e) {\r\n      }\r\n    }\r\n    if (!this.settings.threeDAssetPath) {\r\n      let path = await this._connectorService.getInternalParameter(InternalParam.AssetUrl);\r\n      if (!path.endsWith('/')) {\r\n        path += '/';\r\n      }\r\n      this.settings.threeDAssetPath = path;\r\n    }\r\n    if (!this.settings.user3DModelUploadEnabled) {\r\n      const uploadSetting = await this._connectorService.getInternalParameter(InternalParam.UPLOAD_3D_MODEL);\r\n      if (uploadSetting === 'J') {\r\n        this.settings.user3DModelUploadEnabled = true;\r\n      }\r\n    }\r\n    await this._dictionaryService.setDictionary(\r\n      this.settings.assetPath, this.settings.client, this.settings.languageCode, this.settings.additionalTranslationFile);\r\n    this.settingsLoaded.next(true);\r\n  }\r\n\r\n  private async _checkUrlParameters(): Promise<void> {\r\n    const urlParams = new URLSearchParams(window.location.search);\r\n    const client = urlParams.get('client');\r\n    if (client) {\r\n      const jsonSettings: any =\r\n        await this._jsonUtilsService.readJsonFile(this.settings.assetPath + `assets/${client}-settings.json`, false);\r\n      this.settings = Object.assign(new HomedecoratorSettings(), jsonSettings);\r\n      this.settings.options = Object.assign(new HomedecoratorSettingsOptions(), this.settings.options);\r\n      this.settings.client = client;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2015/app/core/service/homedecorator.service.js

@@ -0,0 +1,37 @@
+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 { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./homedecorator-settings.service";
+import * as i2 from "./homedecorator-connector.service";
+export class HomedecoratorService {
+    constructor(_settingsService, _connectorService) {
+        this._settingsService = _settingsService;
+        this._connectorService = _connectorService;
+        this.loaded = new BehaviorSubject(false);
+    }
+    init(settings, forceReload = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._settingsService.initialize(settings);
+            yield this._connectorService.initConnection(forceReload);
+            this.loaded.next(true);
+        });
+    }
+}
+HomedecoratorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorService, deps: [{ token: i1.HomedecoratorSettingsService }, { token: i2.HomedecoratorConnectorService }], target: i0.ɵɵFactoryTarget.Injectable });
+HomedecoratorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: HomedecoratorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HomedecoratorSettingsService }, { type: i2.HomedecoratorConnectorService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/core/service/integration.service.js

@@ -0,0 +1,56 @@
+import { Injectable } from '@angular/core';
+import { MessageType } from '../enum/message-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "./message-bus.service";
+import * as i2 from "./homedecorator-app-event.service";
+var PostMessageType;
+(function (PostMessageType) {
+    PostMessageType["UpdateShoppingCartSelections"] = "updateShoppingCartSelections";
+    PostMessageType["ArticleCreated"] = "articleCreated";
+})(PostMessageType || (PostMessageType = {}));
+export class IntegrationService {
+    constructor(_messageBus, _appEventService) {
+        this._messageBus = _messageBus;
+        this._appEventService = _appEventService;
+        this._subs = [];
+        this._enabled = false;
+        window.addEventListener('message', (event) => this._handleMessage(event), false);
+        this._subs.push(this._messageBus.subscribe(MessageType.ArticleCreated, article => this._postTheMessage(PostMessageType.ArticleCreated, article)), this._messageBus.subscribe(MessageType.ConfigurationChanged, config => this._postTheMessage(PostMessageType.UpdateShoppingCartSelections, config)));
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+        window.removeEventListener('message', (event) => this._handleMessage(event), false);
+    }
+    _handleMessage(event) {
+        try {
+            const data = JSON.parse(event.data);
+            if (data && data.method === 'initCommunication') {
+                this._appEventService.enableIntegration.next(true);
+                this._enabled = true;
+            }
+            if (data && data.method === 'addToCart') {
+                this._messageBus.emit(MessageType.AddToCart);
+            }
+        }
+        catch (e) {
+            return;
+        }
+    }
+    _postTheMessage(method, config) {
+        if (this._enabled) {
+            window.parent.postMessage(JSON.stringify({
+                method: method,
+                data: config
+            }), '*');
+        }
+    }
+}
+IntegrationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: IntegrationService, deps: [{ token: i1.MessageBusService }, { token: i2.HomedecoratorAppEventService }], target: i0.ɵɵFactoryTarget.Injectable });
+IntegrationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: IntegrationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: IntegrationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBusService }, { type: i2.HomedecoratorAppEventService }]; } });
+//# sourceMappingURL=data:application/json;base64,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