@vgip/meta-ui 1.1.6 → 1.2.2

package/esm2020/lib/index.mjs

@@ -0,0 +1,165 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2019-09-19 17:34:34
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2021-02-09 16:57:29
+ */
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { HttpClientModule } from '@angular/common/http';
+import { QuillModule } from 'ngx-quill';
+import { MetaField, MetaFieldContentDirective } from './field';
+// import { MetaRefDialog } from './refDialog';
+import { MetaRefDialog } from './field';
+// import { MetaLayout } from './layout';
+import { MetaLayout } from './field';
+// import { MetaResource } from './resource';
+import { MetaResource } from './field';
+// import { MetaResourceCard } from './resourceCard';
+import { MetaResourceCard } from './field';
+import { FieldUnknown } from './fieldUnknown';
+import { FieldInput } from './fieldInput';
+import { FieldText } from './fieldText';
+// import { FieldSelect } from './fieldSelect';
+import { FieldSelect } from './field';
+// import { FieldReference } from './fieldReference';
+import { FieldReference } from './field';
+// import { FieldComposite } from './fieldComposite';
+import { FieldComposite } from './field';
+import { FieldBoolean } from './fieldBoolean';
+import { FieldRadio } from './fieldRadio';
+// import { FieldList } from './fieldList';
+import { FieldList } from './field';
+import { FieldRichtext } from './fieldRichtext';
+import { FieldDatetime } from './fieldDatetime';
+import { MetaIconsPipe } from './common/metaIcons.pipe';
+import { MetaModelPipe } from './common/metaModel.pipe';
+import { MetaStripHtmlPipe } from './common/metaStripHtml.pipe';
+import { MetaAutofocusDirective } from './common/metaAutofocus.directive';
+import { MetaContextService } from './services/metaContext';
+import { MetaTrackerService } from './services/metaTracker';
+import { ResourceDraftsService } from './services/resourceDrafts';
+import { MetaMsgService } from './services/metaMsg';
+import { MetaReferenceService } from './services/metaReference';
+import { MetaResourceService } from './services/metaResource';
+import { MetaHttpClient } from './services/metaResource/metaHttpClient';
+import { relativeTimeBuilder } from './common/utils/relativeTimeBuilder';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-quill";
+export * from './common/utils/colorThemes';
+export * from './common/metaNormalizer';
+export class MetaModule {
+    static withProviders(customProviders) {
+        return {
+            ngModule: MetaModule,
+            providers: customProviders
+        };
+    }
+}
+MetaModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MetaModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaModule, declarations: [MetaIconsPipe,
+        MetaModelPipe,
+        MetaStripHtmlPipe,
+        MetaField,
+        MetaRefDialog,
+        MetaFieldContentDirective,
+        MetaLayout,
+        MetaResource,
+        MetaResourceCard,
+        FieldUnknown,
+        FieldInput,
+        FieldText,
+        FieldSelect,
+        FieldReference,
+        FieldComposite,
+        FieldBoolean,
+        FieldRadio,
+        FieldList,
+        FieldRichtext,
+        FieldDatetime,
+        MetaAutofocusDirective], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        HttpClientModule, i1.QuillModule], exports: [MetaIconsPipe,
+        MetaModelPipe,
+        MetaStripHtmlPipe,
+        MetaField,
+        MetaLayout,
+        MetaResource,
+        MetaResourceCard,
+        MetaAutofocusDirective] });
+MetaModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaModule, imports: [[
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            HttpClientModule,
+            QuillModule.forRoot({
+                modules: {
+                    toolbar: [
+                        ['bold', 'italic', 'underline'],
+                        [{ list: 'bullet' }],
+                        [{ header: [1, 2, 3, 4, 5, 6, false] }],
+                        [{ font: [] }],
+                        [{ align: [] }]
+                    ]
+                }
+            })
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        MetaIconsPipe,
+                        MetaModelPipe,
+                        MetaStripHtmlPipe,
+                        MetaField,
+                        MetaRefDialog,
+                        MetaFieldContentDirective,
+                        MetaLayout,
+                        MetaResource,
+                        MetaResourceCard,
+                        FieldUnknown,
+                        FieldInput,
+                        FieldText,
+                        FieldSelect,
+                        FieldReference,
+                        FieldComposite,
+                        FieldBoolean,
+                        FieldRadio,
+                        FieldList,
+                        FieldRichtext,
+                        FieldDatetime,
+                        MetaAutofocusDirective
+                    ],
+                    exports: [
+                        MetaIconsPipe,
+                        MetaModelPipe,
+                        MetaStripHtmlPipe,
+                        MetaField,
+                        MetaLayout,
+                        MetaResource,
+                        MetaResourceCard,
+                        MetaAutofocusDirective
+                    ],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        HttpClientModule,
+                        QuillModule.forRoot({
+                            modules: {
+                                toolbar: [
+                                    ['bold', 'italic', 'underline'],
+                                    [{ list: 'bullet' }],
+                                    [{ header: [1, 2, 3, 4, 5, 6, false] }],
+                                    [{ font: [] }],
+                                    [{ align: [] }]
+                                ]
+                            }
+                        })
+                    ]
+                }]
+        }] });
+export { MetaField, MetaFieldContentDirective, MetaRefDialog, MetaResourceCard, MetaIconsPipe, MetaModelPipe, MetaStripHtmlPipe, MetaAutofocusDirective, FieldUnknown, FieldInput, FieldText, FieldSelect, MetaLayout, MetaResource, FieldBoolean, FieldRadio, FieldList, FieldComposite, FieldReference, FieldRichtext, FieldDatetime, MetaContextService, MetaTrackerService, ResourceDraftsService, MetaMsgService, MetaReferenceService, MetaResourceService, MetaHttpClient, relativeTimeBuilder };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../projects/meta-ui/src/lib/index.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * @Author: Alexander.Vangelov@vonage.com \n * @Date: 2019-09-19 17:34:34 \n * @Last Modified by: Alexander.Vangelov@vonage.com\n * @Last Modified time: 2021-02-09 16:57:29\n */\n\nimport { NgModule, ModuleWithProviders } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\nimport { HttpClientModule } from '@angular/common/http';\n\nimport { QuillModule } from 'ngx-quill';\n\nimport { MetaField, MetaFieldContentDirective } from './field';\n\n// import { MetaRefDialog } from './refDialog';\nimport { MetaRefDialog } from './field';\n\n// import { MetaLayout } from './layout';\nimport { MetaLayout } from './field';\n\n// import { MetaResource } from './resource';\nimport { MetaResource } from './field';\n\n// import { MetaResourceCard } from './resourceCard';\nimport { MetaResourceCard } from './field';\n\nimport { FieldUnknown } from './fieldUnknown';\nimport { FieldInput } from './fieldInput';\nimport { FieldText } from './fieldText';\n\n// import { FieldSelect } from './fieldSelect';\nimport { FieldSelect } from './field';\n\n// import { FieldReference } from './fieldReference';\nimport { FieldReference } from './field';\n\n// import { FieldComposite } from './fieldComposite';\nimport { FieldComposite } from './field';\n\nimport { FieldBoolean } from './fieldBoolean';\nimport { FieldRadio } from './fieldRadio';\n\n// import { FieldList } from './fieldList';\nimport { FieldList } from './field';\n\nimport { FieldRichtext } from './fieldRichtext';\nimport { FieldDatetime } from './fieldDatetime';\n\nimport { MetaIconsPipe } from './common/metaIcons.pipe';\nimport { MetaModelPipe } from './common/metaModel.pipe';\nimport { MetaStripHtmlPipe } from './common/metaStripHtml.pipe';\nimport { MetaAutofocusDirective } from './common/metaAutofocus.directive';\nimport { MetaContextService } from './services/metaContext';\nimport { MetaTrackerService } from './services/metaTracker';\nimport { ResourceDraftsService } from './services/resourceDrafts';\nimport { MetaMsgService } from './services/metaMsg';\nimport { MetaReferenceService } from './services/metaReference';\nimport { MetaResourceService } from './services/metaResource';\nimport { MetaHttpClient } from './services/metaResource/metaHttpClient';\nimport { relativeTimeBuilder } from './common/utils/relativeTimeBuilder';\n\nexport * from './common/utils/colorThemes';\nexport * from './common/metaNormalizer';\n\n@NgModule({\n  declarations: [\n    MetaIconsPipe,\n    MetaModelPipe,\n    MetaStripHtmlPipe,\n    MetaField, \n    MetaRefDialog,\n    MetaFieldContentDirective,\n    MetaLayout,\n    MetaResource,\n    MetaResourceCard,\n    FieldUnknown,\n    FieldInput,\n    FieldText,\n    FieldSelect,\n    FieldReference,\n    FieldComposite,\n    FieldBoolean,\n    FieldRadio,\n    FieldList,\n    FieldRichtext,\n    FieldDatetime,\n    MetaAutofocusDirective\n  ],\n  exports: [\n    MetaIconsPipe,\n    MetaModelPipe,\n    MetaStripHtmlPipe,\n    MetaField,\n    MetaLayout,\n    MetaResource,\n    MetaResourceCard,\n    MetaAutofocusDirective\n  ],\n  imports: [\n    CommonModule,\n    FormsModule, \n    ReactiveFormsModule,\n    HttpClientModule,\n    QuillModule.forRoot({\n      modules: {\n        toolbar: [\n          ['bold', 'italic', 'underline'],\n          [{ list: 'bullet' }],\n          [{ header: [1, 2, 3, 4, 5, 6, false] }],\n          [{ font: [] }],\n          [{ align: [] }]\n        ]\n      }\n    })\n  ]\n})\nexport class MetaModule {\n  static withProviders(customProviders: any): ModuleWithProviders<MetaModule> {\n    return {\n      ngModule: MetaModule,\n      providers: customProviders\n    };\n  }\n}\n\nexport { \n  MetaField, MetaFieldContentDirective, MetaRefDialog, MetaResourceCard,\n  MetaIconsPipe, MetaModelPipe, MetaStripHtmlPipe, MetaAutofocusDirective,\n  FieldUnknown, FieldInput, FieldText, FieldSelect, MetaLayout, MetaResource,\n  FieldBoolean, FieldRadio, FieldList, FieldComposite, FieldReference,\n  FieldRichtext, FieldDatetime, MetaContextService, MetaTrackerService, ResourceDraftsService,\n  MetaMsgService, MetaReferenceService, MetaResourceService, MetaHttpClient,\n  relativeTimeBuilder\n};\n"]}

package/esm2020/lib/services/metaContext/index.mjs

@@ -0,0 +1,35 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2019-09-19 17:35:19
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2020-03-06 10:10:09
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MetaContextService {
+    constructor() {
+        this.defaultContactables = {};
+        this.workers = {};
+        this.contactables = {};
+        this.profiles = {};
+    }
+    set(context) {
+        if (context) {
+            if (context.phoneNumber) {
+                this.phoneNumber = context.phoneNumber;
+            }
+            if (context.displayName) {
+                this.displayName = context.displayName;
+            }
+        }
+    }
+}
+MetaContextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaContextService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MetaContextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaContextService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaContextService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/metaMsg/index.mjs

@@ -0,0 +1,84 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2019-09-19 17:35:19
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2020-05-03 21:31:16
+ */
+/*
+* Worker messages systems. Every integration may extend the base functionality by registering an integration worker.
+* This service provides single response for the worker message requests as a callback.
+*/
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../metaContext";
+export class MetaMsgService {
+    constructor(metaContext) {
+        this.metaContext = metaContext;
+        this.msgCallbacks = {}; // message subscribers holder
+        this.msgListeneres = []; // ensure listener is registerd only once
+        this.workerMsgListener = (msg) => {
+            if (msg && msg.data && msg.data.action && msg.data.$state) {
+                const state = msg.data.$state;
+                const callback = this.msgCallbacks[state]; // original requester callback
+                if (callback) {
+                    delete msg.data.$state;
+                    callback(msg.data);
+                }
+                delete this.msgCallbacks[state]; // get rid of the listener callback when done
+            }
+            this.removeExpiredListeners(); // wipe out the expired listeners if any
+        };
+    }
+    sendMessage(provider, msg, callback, isLong = false) {
+        provider = (provider || '').toUpperCase();
+        const providerWorker = this.metaContext.workers[provider];
+        if (providerWorker) {
+            if (this.msgListeneres.indexOf(provider)) {
+                this.msgListeneres.push(provider);
+                providerWorker.addEventListener('message', this.workerMsgListener, false); // register a short time listener
+            }
+            let state; // message unique identifier
+            do {
+                state = new Date().getTime();
+            } while (!!this.msgCallbacks[state]);
+            this.msgCallbacks[state] = callback; // register message callback
+            msg.$state = state;
+            providerWorker.postMessage(msg);
+            setTimeout(() => {
+                this.cancelMsgListener(msg.action, state); // give up, worker does not replied on time
+                const listenerIndex = this.msgListeneres.indexOf(provider);
+                if (listenerIndex !== -1) {
+                    this.msgListeneres.splice(listenerIndex, 1);
+                }
+                providerWorker.removeEventListener('message', this.workerMsgListener); // remove listener when done
+            }, isLong ? 60000 : 2000);
+        }
+        else {
+            callback({ action: msg.action, error: `Worker ${provider} is not registered` });
+        }
+    }
+    cancelMsgListener(action, storedState) {
+        const storedCallback = this.msgCallbacks[storedState];
+        if (storedCallback) {
+            storedCallback({ action, error: 'Timeout', state: storedState }); // always reply with something
+        }
+        delete this.msgCallbacks[storedState];
+    }
+    removeExpiredListeners() {
+        const now = new Date();
+        for (const state in this.msgCallbacks) { // cleanup expired listeners (< 1 min ago);
+            if (parseInt(state, 10) < now.setMinutes(now.getMinutes() - 1)) {
+                delete this.msgCallbacks[state];
+            }
+        }
+    }
+}
+MetaMsgService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaMsgService, deps: [{ token: i1.MetaContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+MetaMsgService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaMsgService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaMsgService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MetaContextService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tZXRhLXVpL3NyYy9saWIvc2VydmljZXMvbWV0YU1zZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUVGOzs7RUFHRTtBQUNILE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7OztBQU8zQyxNQUFNLE9BQU8sY0FBYztJQUd6QixZQUFvQixXQUErQjtRQUEvQixnQkFBVyxHQUFYLFdBQVcsQ0FBb0I7UUFGM0MsaUJBQVksR0FBMkIsRUFBRSxDQUFDLENBQUMsNkJBQTZCO1FBQ3hFLGtCQUFhLEdBQWtCLEVBQUUsQ0FBQyxDQUFDLHlDQUF5QztRQTBDNUUsc0JBQWlCLEdBQUcsQ0FBQyxHQUFHLEVBQUUsRUFBRTtZQUNsQyxJQUFJLEdBQUcsSUFBSSxHQUFHLENBQUMsSUFBSSxJQUFJLEdBQUcsQ0FBQyxJQUFJLENBQUMsTUFBTSxJQUFJLEdBQUcsQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFO2dCQUN6RCxNQUFNLEtBQUssR0FBRyxHQUFHLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQztnQkFDOUIsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLDhCQUE4QjtnQkFDekUsSUFBSSxRQUFRLEVBQUU7b0JBQ1osT0FBTyxHQUFHLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQztvQkFDdkIsUUFBUSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztpQkFDcEI7Z0JBQ0QsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsNkNBQTZDO2FBQy9FO1lBQ0QsSUFBSSxDQUFDLHNCQUFzQixFQUFFLENBQUMsQ0FBQyx3Q0FBd0M7UUFDekUsQ0FBQyxDQUFDO0lBbkRGLENBQUM7SUFFRCxXQUFXLENBQUMsUUFBZ0IsRUFBRSxHQUFRLEVBQUUsUUFBNEIsRUFBRSxNQUFNLEdBQUcsS0FBSztRQUNsRixRQUFRLEdBQUcsQ0FBQyxRQUFRLElBQUksRUFBRSxDQUFDLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDMUMsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDMUQsSUFBSSxjQUFjLEVBQUU7WUFDbEIsSUFBSSxJQUFJLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsRUFBRTtnQkFDeEMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7Z0JBQ2xDLGNBQWMsQ0FBQyxnQkFBZ0IsQ0FBQyxTQUFTLEVBQUUsSUFBSSxDQUFDLGlCQUFpQixFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUMsaUNBQWlDO2FBQzdHO1lBQ0QsSUFBSSxLQUFLLENBQUMsQ0FBQyw0QkFBNEI7WUFDdkMsR0FBRztnQkFDRCxLQUFLLEdBQUcsSUFBSSxJQUFJLEVBQUUsQ0FBQyxPQUFPLEVBQUUsQ0FBQzthQUM5QixRQUFRLENBQUMsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBRXJDLElBQUksQ0FBQyxZQUFZLENBQUMsS0FBSyxDQUFDLEdBQUcsUUFBUSxDQUFDLENBQUMsNEJBQTRCO1lBQ2pFLEdBQUcsQ0FBQyxNQUFNLEdBQUcsS0FBSyxDQUFDO1lBQ25CLGNBQWMsQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLENBQUM7WUFFaEMsVUFBVSxDQUFDLEdBQUcsRUFBRTtnQkFDZCxJQUFJLENBQUMsaUJBQWlCLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDLDJDQUEyQztnQkFDdEYsTUFBTSxhQUFhLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7Z0JBQzNELElBQUksYUFBYSxLQUFLLENBQUMsQ0FBQyxFQUFFO29CQUN4QixJQUFJLENBQUMsYUFBYSxDQUFDLE1BQU0sQ0FBQyxhQUFhLEVBQUUsQ0FBQyxDQUFDLENBQUM7aUJBQzdDO2dCQUNELGNBQWMsQ0FBQyxtQkFBbUIsQ0FBQyxTQUFTLEVBQUUsSUFBSSxDQUFDLGlCQUFpQixDQUFDLENBQUMsQ0FBQyw0QkFBNEI7WUFDckcsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQztTQUMzQjthQUFNO1lBQ0wsUUFBUSxDQUFDLEVBQUUsTUFBTSxFQUFFLEdBQUcsQ0FBQyxNQUFNLEVBQUUsS0FBSyxFQUFFLFVBQVUsUUFBUSxvQkFBb0IsRUFBRSxDQUFDLENBQUM7U0FDakY7SUFDSCxDQUFDO0lBRU8saUJBQWlCLENBQUMsTUFBTSxFQUFFLFdBQVc7UUFDM0MsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUN0RCxJQUFJLGNBQWMsRUFBRTtZQUNsQixjQUFjLENBQUMsRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsV0FBVyxFQUFFLENBQUMsQ0FBQyxDQUFDLDhCQUE4QjtTQUNqRztRQUNELE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUN4QyxDQUFDO0lBZU8sc0JBQXNCO1FBQzVCLE1BQU0sR0FBRyxHQUFHLElBQUksSUFBSSxFQUFFLENBQUM7UUFDdkIsS0FBSyxNQUFNLEtBQUssSUFBSSxJQUFJLENBQUMsWUFBWSxFQUFFLEVBQUUsMkNBQTJDO1lBQ2xGLElBQUksUUFBUSxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsR0FBRyxHQUFHLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxVQUFVLEVBQUUsR0FBRyxDQUFDLENBQUMsRUFBRTtnQkFDOUQsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDO2FBQ2pDO1NBQ0Y7SUFDSCxDQUFDOzsyR0FoRVUsY0FBYzsrR0FBZCxjQUFjLGNBRmIsTUFBTTsyRkFFUCxjQUFjO2tCQUgxQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBAQXV0aG9yOiBBbGV4YW5kZXIuVmFuZ2Vsb3ZAdm9uYWdlLmNvbVxuICogQERhdGU6IDIwMTktMDktMTkgMTc6MzU6MTlcbiAqIEBMYXN0IE1vZGlmaWVkIGJ5OiBBbGV4YW5kZXIuVmFuZ2Vsb3ZAdm9uYWdlLmNvbVxuICogQExhc3QgTW9kaWZpZWQgdGltZTogMjAyMC0wNS0wMyAyMTozMToxNlxuICovXG5cbiAvKlxuICogV29ya2VyIG1lc3NhZ2VzIHN5c3RlbXMuIEV2ZXJ5IGludGVncmF0aW9uIG1heSBleHRlbmQgdGhlIGJhc2UgZnVuY3Rpb25hbGl0eSBieSByZWdpc3RlcmluZyBhbiBpbnRlZ3JhdGlvbiB3b3JrZXIuXG4gKiBUaGlzIHNlcnZpY2UgcHJvdmlkZXMgc2luZ2xlIHJlc3BvbnNlIGZvciB0aGUgd29ya2VyIG1lc3NhZ2UgcmVxdWVzdHMgYXMgYSBjYWxsYmFjay5cbiAqL1xuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBNZXRhQ29udGV4dFNlcnZpY2UgfSBmcm9tICcuLi9tZXRhQ29udGV4dCc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIE1ldGFNc2dTZXJ2aWNlIHtcbiAgcHJpdmF0ZSBtc2dDYWxsYmFja3M6IHtbc3RhdGU6IG51bWJlcl06IGFueX0gPSB7fTsgLy8gbWVzc2FnZSBzdWJzY3JpYmVycyBob2xkZXJcbiAgcHJpdmF0ZSBtc2dMaXN0ZW5lcmVzOiBBcnJheTxzdHJpbmc+ID0gW107IC8vIGVuc3VyZSBsaXN0ZW5lciBpcyByZWdpc3RlcmQgb25seSBvbmNlXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgbWV0YUNvbnRleHQ6IE1ldGFDb250ZXh0U2VydmljZSkge1xuICB9XG5cbiAgc2VuZE1lc3NhZ2UocHJvdmlkZXI6IHN0cmluZywgbXNnOiBhbnksIGNhbGxiYWNrOiAocmVzcG9uc2UpID0+IHZvaWQsIGlzTG9uZyA9IGZhbHNlKSB7XG4gICAgcHJvdmlkZXIgPSAocHJvdmlkZXIgfHwgJycpLnRvVXBwZXJDYXNlKCk7XG4gICAgY29uc3QgcHJvdmlkZXJXb3JrZXIgPSB0aGlzLm1ldGFDb250ZXh0LndvcmtlcnNbcHJvdmlkZXJdO1xuICAgIGlmIChwcm92aWRlcldvcmtlcikge1xuICAgICAgaWYgKHRoaXMubXNnTGlzdGVuZXJlcy5pbmRleE9mKHByb3ZpZGVyKSkge1xuICAgICAgICB0aGlzLm1zZ0xpc3RlbmVyZXMucHVzaChwcm92aWRlcik7XG4gICAgICAgIHByb3ZpZGVyV29ya2VyLmFkZEV2ZW50TGlzdGVuZXIoJ21lc3NhZ2UnLCB0aGlzLndvcmtlck1zZ0xpc3RlbmVyLCBmYWxzZSk7IC8vIHJlZ2lzdGVyIGEgc2hvcnQgdGltZSBsaXN0ZW5lclxuICAgICAgfVxuICAgICAgbGV0IHN0YXRlOyAvLyBtZXNzYWdlIHVuaXF1ZSBpZGVudGlmaWVyXG4gICAgICBkbyB7XG4gICAgICAgIHN0YXRlID0gbmV3IERhdGUoKS5nZXRUaW1lKCk7XG4gICAgICB9IHdoaWxlICghIXRoaXMubXNnQ2FsbGJhY2tzW3N0YXRlXSk7XG5cbiAgICAgIHRoaXMubXNnQ2FsbGJhY2tzW3N0YXRlXSA9IGNhbGxiYWNrOyAvLyByZWdpc3RlciBtZXNzYWdlIGNhbGxiYWNrXG4gICAgICBtc2cuJHN0YXRlID0gc3RhdGU7XG4gICAgICBwcm92aWRlcldvcmtlci5wb3N0TWVzc2FnZShtc2cpO1xuXG4gICAgICBzZXRUaW1lb3V0KCgpID0+IHtcbiAgICAgICAgdGhpcy5jYW5jZWxNc2dMaXN0ZW5lcihtc2cuYWN0aW9uLCBzdGF0ZSk7IC8vIGdpdmUgdXAsIHdvcmtlciBkb2VzIG5vdCByZXBsaWVkIG9uIHRpbWVcbiAgICAgICAgY29uc3QgbGlzdGVuZXJJbmRleCA9IHRoaXMubXNnTGlzdGVuZXJlcy5pbmRleE9mKHByb3ZpZGVyKTtcbiAgICAgICAgaWYgKGxpc3RlbmVySW5kZXggIT09IC0xKSB7XG4gICAgICAgICAgdGhpcy5tc2dMaXN0ZW5lcmVzLnNwbGljZShsaXN0ZW5lckluZGV4LCAxKTtcbiAgICAgICAgfVxuICAgICAgICBwcm92aWRlcldvcmtlci5yZW1vdmVFdmVudExpc3RlbmVyKCdtZXNzYWdlJywgdGhpcy53b3JrZXJNc2dMaXN0ZW5lcik7IC8vIHJlbW92ZSBsaXN0ZW5lciB3aGVuIGRvbmVcbiAgICAgIH0sIGlzTG9uZyA/IDYwMDAwIDogMjAwMCk7XG4gICAgfSBlbHNlIHtcbiAgICAgIGNhbGxiYWNrKHsgYWN0aW9uOiBtc2cuYWN0aW9uLCBlcnJvcjogYFdvcmtlciAke3Byb3ZpZGVyfSBpcyBub3QgcmVnaXN0ZXJlZGAgfSk7XG4gICAgfVxuICB9XG5cbiAgcHJpdmF0ZSBjYW5jZWxNc2dMaXN0ZW5lcihhY3Rpb24sIHN0b3JlZFN0YXRlKSB7XG4gICAgY29uc3Qgc3RvcmVkQ2FsbGJhY2sgPSB0aGlzLm1zZ0NhbGxiYWNrc1tzdG9yZWRTdGF0ZV07XG4gICAgaWYgKHN0b3JlZENhbGxiYWNrKSB7XG4gICAgICBzdG9yZWRDYWxsYmFjayh7IGFjdGlvbiwgZXJyb3I6ICdUaW1lb3V0Jywgc3RhdGU6IHN0b3JlZFN0YXRlIH0pOyAvLyBhbHdheXMgcmVwbHkgd2l0aCBzb21ldGhpbmdcbiAgICB9XG4gICAgZGVsZXRlIHRoaXMubXNnQ2FsbGJhY2tzW3N0b3JlZFN0YXRlXTtcbiAgfVxuXG4gIHByaXZhdGUgd29ya2VyTXNnTGlzdGVuZXIgPSAobXNnKSA9PiB7XG4gICAgaWYgKG1zZyAmJiBtc2cuZGF0YSAmJiBtc2cuZGF0YS5hY3Rpb24gJiYgbXNnLmRhdGEuJHN0YXRlKSB7XG4gICAgICBjb25zdCBzdGF0ZSA9IG1zZy5kYXRhLiRzdGF0ZTtcbiAgICAgIGNvbnN0IGNhbGxiYWNrID0gdGhpcy5tc2dDYWxsYmFja3Nbc3RhdGVdOyAvLyBvcmlnaW5hbCByZXF1ZXN0ZXIgY2FsbGJhY2tcbiAgICAgIGlmIChjYWxsYmFjaykge1xuICAgICAgICBkZWxldGUgbXNnLmRhdGEuJHN0YXRlO1xuICAgICAgICBjYWxsYmFjayhtc2cuZGF0YSk7XG4gICAgICB9XG4gICAgICBkZWxldGUgdGhpcy5tc2dDYWxsYmFja3Nbc3RhdGVdOyAvLyBnZXQgcmlkIG9mIHRoZSBsaXN0ZW5lciBjYWxsYmFjayB3aGVuIGRvbmVcbiAgICB9XG4gICAgdGhpcy5yZW1vdmVFeHBpcmVkTGlzdGVuZXJzKCk7IC8vIHdpcGUgb3V0IHRoZSBleHBpcmVkIGxpc3RlbmVycyBpZiBhbnlcbiAgfTtcblxuICBwcml2YXRlIHJlbW92ZUV4cGlyZWRMaXN0ZW5lcnMoKSB7XG4gICAgY29uc3Qgbm93ID0gbmV3IERhdGUoKTtcbiAgICBmb3IgKGNvbnN0IHN0YXRlIGluIHRoaXMubXNnQ2FsbGJhY2tzKSB7IC8vIGNsZWFudXAgZXhwaXJlZCBsaXN0ZW5lcnMgKDwgMSBtaW4gYWdvKTtcbiAgICAgIGlmIChwYXJzZUludChzdGF0ZSwgMTApIDwgbm93LnNldE1pbnV0ZXMobm93LmdldE1pbnV0ZXMoKSAtIDEpKSB7XG4gICAgICAgIGRlbGV0ZSB0aGlzLm1zZ0NhbGxiYWNrc1tzdGF0ZV07XG4gICAgICB9XG4gICAgfVxuICB9XG59XG4iXX0=

package/esm2020/lib/services/metaReference/index.mjs

@@ -0,0 +1,94 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2019-09-19 17:35:19
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2020-05-03 21:31:44
+ */
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class MetaReferenceService {
+    constructor(appRef, injector, router) {
+        this.appRef = appRef;
+        this.injector = injector;
+        this.router = router;
+        this.dialogs = [];
+        this.router.events.subscribe((e) => {
+            if (this.dialogs.length) {
+                for (let d = (this.dialogs.length - 1); d >= 0; d--) {
+                    this.dialogs[d].onComplete();
+                }
+            }
+        });
+    }
+    openDialog(refDialogFactory, metaResource, integrationCode, reference, resource, preview, preferResourceType, theme) {
+        const references = !(reference instanceof Array) ? [reference] : reference.filter((r) => r.creatable !== false);
+        if (resource && resource.type) {
+            if (!references.find((f) => (f.name || f.resourceType) === (resource.resourceType || resource.type))) {
+                references.push({
+                    name: resource.resourceType || resource.type,
+                    resourceType: resource.resourceType || resource.type,
+                    label: resource.label || resource.resourceType || resource.type
+                });
+            }
+        }
+        const modalObservable = new Observable(observer => {
+            const componentRef = refDialogFactory.create(this.injector);
+            this.appRef.attachView(componentRef.hostView);
+            const refDialog = componentRef.instance;
+            refDialog.integrationCode = integrationCode;
+            refDialog.reference = references;
+            refDialog.resource = resource;
+            refDialog.metaResource = metaResource;
+            refDialog.edit = !preview;
+            refDialog.preferResourceType = preferResourceType;
+            refDialog.theme = theme;
+            const domElem = componentRef.hostView.rootNodes[0];
+            const dialogIndex = this.dialogs.push(refDialog);
+            if (dialogIndex > 1) {
+                const modalPanel = domElem.querySelector('.Vlt-modal__panel');
+                if (modalPanel) {
+                    modalPanel.style.marginLeft = `${(dialogIndex * 5)}px`;
+                    modalPanel.style.marginTop = `${(dialogIndex * 10)}px`;
+                    modalPanel.style.marginBottom = `${((dialogIndex - 1) * 8)}px`;
+                }
+            }
+            document.body.appendChild(domElem);
+            refDialog.onComplete = (result) => {
+                if (result) {
+                    /* eslint-disable no-underscore-dangle */
+                    if (result._vgis) {
+                        observer.next({
+                            id: result._vgis.externalId || result._vgis.id,
+                            label: result._vgis.label,
+                            type: result._vgis.resourceType,
+                            raw: result
+                        });
+                    }
+                    else {
+                        console.log('onComplete non VGIS result', result);
+                    }
+                    /* eslint-enable no-underscore-dangle */
+                }
+                else {
+                    observer.next();
+                }
+                observer.complete();
+                this.appRef.detachView(componentRef.hostView);
+                componentRef.destroy();
+                this.dialogs.splice(dialogIndex - 1, 1);
+            };
+        });
+        return modalObservable;
+    }
+}
+MetaReferenceService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaReferenceService, deps: [{ token: i0.ApplicationRef }, { token: i0.Injector }, { token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+MetaReferenceService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaReferenceService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaReferenceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ApplicationRef }, { type: i0.Injector }, { type: i1.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../projects/meta-ui/src/lib/services/metaReference/index.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * @Author: Alexander.Vangelov@vonage.com\n * @Date: 2019-09-19 17:35:19\n * @Last Modified by: Alexander.Vangelov@vonage.com\n * @Last Modified time: 2020-05-03 21:31:44\n */\n\nimport { Injectable, ApplicationRef, Injector } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { Observable } from 'rxjs';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class MetaReferenceService {\n  dialogs: Array<any>;\n  constructor(\n    private appRef: ApplicationRef,\n    private injector: Injector,\n    private router: Router) {\n      this.dialogs = [];\n      this.router.events.subscribe((e) => {\n        if (this.dialogs.length) {\n          for (let d = (this.dialogs.length - 1); d >= 0; d--) {\n            this.dialogs[d].onComplete();\n          }\n        }\n      });\n    }\n\n  openDialog(refDialogFactory, metaResource, integrationCode, reference, resource, preview?: boolean, preferResourceType?, theme?: string) {\n    const references = !(reference instanceof Array) ? [reference] : reference.filter((r) => r.creatable !== false);\n    if (resource && resource.type) {\n      if (!references.find((f) => (f.name || f.resourceType) === (resource.resourceType || resource.type))) {\n        references.push({\n          name: resource.resourceType || resource.type,\n          resourceType: resource.resourceType || resource.type,\n          label: resource.label || resource.resourceType || resource.type\n        });\n      }\n    }\n\n    const modalObservable = new Observable(observer => {\n      const componentRef = refDialogFactory.create(this.injector);\n      this.appRef.attachView(componentRef.hostView);\n      const refDialog = componentRef.instance;\n      refDialog.integrationCode = integrationCode;\n      refDialog.reference = references;\n      refDialog.resource = resource;\n      refDialog.metaResource = metaResource;\n      refDialog.edit = !preview;\n      refDialog.preferResourceType = preferResourceType;\n      refDialog.theme = theme;\n\n      const domElem = (componentRef.hostView as any).rootNodes[0] as HTMLElement;\n      \n      const dialogIndex = this.dialogs.push(refDialog);\n\n      if (dialogIndex > 1) {\n        const modalPanel: HTMLElement = domElem.querySelector('.Vlt-modal__panel');\n        if (modalPanel) {\n          modalPanel.style.marginLeft = `${(dialogIndex * 5)}px`;\n          modalPanel.style.marginTop = `${(dialogIndex * 10)}px`;\n          modalPanel.style.marginBottom = `${((dialogIndex - 1) * 8)}px`;\n        }\n      }\n\n      document.body.appendChild(domElem);\n\n      refDialog.onComplete = (result) => {\n        if (result) {\n          /* eslint-disable no-underscore-dangle */\n          if (result._vgis) {\n            observer.next({\n              id: result._vgis.externalId || result._vgis.id,\n              label: result._vgis.label,\n              type: result._vgis.resourceType,\n              raw: result\n            });\n          } else {\n            console.log('onComplete non VGIS result', result);\n          }\n          /* eslint-enable no-underscore-dangle */\n        } else {\n          observer.next();\n        }\n        observer.complete();\n        this.appRef.detachView(componentRef.hostView);\n        componentRef.destroy();\n        this.dialogs.splice(dialogIndex - 1, 1);\n      };\n    });\n\n    return modalObservable;\n  }\n}\n"]}

package/esm2020/lib/services/metaResource/index.mjs

@@ -0,0 +1,139 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2019-09-19 17:35:19
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2020-08-10 22:35:31
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./metaHttpClient";
+const STORAGE_PARAMS_REGEXES = {
+    localStorage: /^localStorage\.(.*)/,
+    sessionStorage: /^sessionStorage\.(.*)/,
+};
+const INTEGRATION_URL_TEMPLATE = '/extensions/v2/accounts/${localStorage.vgis.accountId}/users/${localStorage.vgis.userId}/connectors/${integrationCode}';
+const RESOURCE_URL_TEMPLATE = INTEGRATION_URL_TEMPLATE + '${parentsPath}/${resourceType}';
+const NEW_RESOURCE_URL_TEMPLATE = INTEGRATION_URL_TEMPLATE + '${parentsPath}/resources/${resourceType}';
+export class IMetaParentConfig {
+}
+export class IMetaResourceConfig {
+}
+export class MetaResourceService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    setConfig(config) {
+        this.baseIntegrationUrl = INTEGRATION_URL_TEMPLATE.replace(/\${\s*([\w\.]+)\s*}/g, (m, value) => {
+            for (const storage of Object.keys(STORAGE_PARAMS_REGEXES)) {
+                const match = value.match(STORAGE_PARAMS_REGEXES[storage]);
+                if (match) {
+                    return window[storage].getItem(match[1]) || window[storage].getItem(`cti.${match[1]}`);
+                }
+            }
+            return config[value];
+        });
+        this.baseResourceUrl = RESOURCE_URL_TEMPLATE.replace(/\${\s*([\w\.]+)\s*}/g, (m, value) => {
+            for (const storage of Object.keys(STORAGE_PARAMS_REGEXES)) {
+                const match = value.match(STORAGE_PARAMS_REGEXES[storage]);
+                if (match) {
+                    return window[storage].getItem(match[1]) || window[storage].getItem(`cti.${match[1]}`);
+                }
+            }
+            if (value === 'parentsPath') {
+                let parentsPath = '';
+                if (config.parent) { // config.parent: { resourceType: '...', id: '...', parent: {...} }
+                    let rootParent = config.parent;
+                    while (rootParent) {
+                        parentsPath += `/${rootParent.resourceType || rootParent.type}/${rootParent.externalId || rootParent.id}`;
+                        rootParent = rootParent.parent;
+                    }
+                }
+                return parentsPath;
+            }
+            else {
+                return config[value];
+            }
+        });
+        this.newResourceUrl = NEW_RESOURCE_URL_TEMPLATE.replace(/\${\s*([\w\.]+)\s*}/g, (m, value) => {
+            for (const storage of Object.keys(STORAGE_PARAMS_REGEXES)) {
+                const match = value.match(STORAGE_PARAMS_REGEXES[storage]);
+                if (match) {
+                    return window[storage].getItem(match[1]);
+                }
+            }
+            if (value === 'parentsPath') {
+                let parentsPath = '';
+                if (config.parent) { // config.parent: { resourceType: '...', id: '...', parent: {...} }
+                    let rootParent = config.parent;
+                    while (rootParent) {
+                        parentsPath += `/${rootParent.resourceType || rootParent.type}/${rootParent.externalId || rootParent.id}`;
+                        rootParent = rootParent.parent;
+                    }
+                }
+                return parentsPath;
+            }
+            else {
+                return config[value];
+            }
+        });
+        this.id = config.externalId;
+    }
+    new(config) {
+        const s = new MetaResourceService(this.httpClient);
+        s.setConfig(config);
+        return s;
+    }
+    searchIntegration(query, scope) {
+        let searchUrl = `${this.baseIntegrationUrl}/search?q=${encodeURIComponent(query)}`;
+        if (scope) {
+            searchUrl += `&scope=${encodeURIComponent(scope)}`;
+        }
+        return this.httpClient.get(searchUrl);
+    }
+    getMetadata(layoutId, refresh) {
+        let url = `${this.baseResourceUrl.replace('/v2/', '/v3/')}/metadata`;
+        url += `?t=${new Date().getTime()}`;
+        if (refresh) {
+            url += '&refresh=true';
+        }
+        if (layoutId) {
+            url += `&layoutId=${layoutId}`;
+        }
+        return this.httpClient.get(url);
+    }
+    getDetails(externalId, extraParams) {
+        let params = 'referenceDetails=true';
+        if (extraParams) {
+            for (const p in extraParams) {
+                if (extraParams[p]) {
+                    params += `&${p}=${extraParams[p]}`;
+                }
+            }
+        }
+        return this.httpClient.get(`${this.baseResourceUrl}/${externalId}?${params}`);
+    }
+    getByPath(path) {
+        let fullPath = `${this.newResourceUrl}${path}`;
+        if (/^..\//.test(path)) {
+            fullPath = `${this.baseIntegrationUrl}${path.substring(2)}`;
+        }
+        return this.httpClient.get(fullPath);
+    }
+    save(payload) {
+        if (this.id) {
+            return this.httpClient.put(`${this.baseResourceUrl}/${this.id}`, payload);
+        }
+        else {
+            return this.httpClient.post(`${this.baseResourceUrl}`, payload);
+        }
+    }
+}
+MetaResourceService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaResourceService, deps: [{ token: i1.MetaHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+MetaResourceService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaResourceService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaResourceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MetaHttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../projects/meta-ui/src/lib/services/metaResource/index.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * @Author: Alexander.Vangelov@vonage.com \n * @Date: 2019-09-19 17:35:19 \n * @Last Modified by: Alexander.Vangelov@vonage.com\n * @Last Modified time: 2020-08-10 22:35:31\n */\n\nimport { Injectable } from '@angular/core';\n\nimport { MetaHttpClient } from './metaHttpClient';\n\nconst STORAGE_PARAMS_REGEXES = {\n  localStorage: /^localStorage\\.(.*)/,\n  sessionStorage: /^sessionStorage\\.(.*)/,\n};\n\nconst INTEGRATION_URL_TEMPLATE =\n  '/extensions/v2/accounts/${localStorage.vgis.accountId}/users/${localStorage.vgis.userId}/connectors/${integrationCode}';\nconst RESOURCE_URL_TEMPLATE = INTEGRATION_URL_TEMPLATE + '${parentsPath}/${resourceType}';\nconst NEW_RESOURCE_URL_TEMPLATE = INTEGRATION_URL_TEMPLATE + '${parentsPath}/resources/${resourceType}';\n\nexport class IMetaParentConfig {\n  resourceType: string;\n  externalId: string;\n  parent?: IMetaParentConfig;\n}\nexport class IMetaResourceConfig {\n  integrationCode: string;\n  resourceType: string;\n  externalId?: string;\n  parent?: IMetaParentConfig;\n  urlTemplate?: string;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class MetaResourceService {\n  baseIntegrationUrl: string;\n  baseResourceUrl: string;\n  newResourceUrl: string;\n  id: string;\n\n  constructor(private httpClient: MetaHttpClient) { }\n\n  setConfig(config: IMetaResourceConfig) {\n    this.baseIntegrationUrl = INTEGRATION_URL_TEMPLATE.replace(/\\${\\s*([\\w\\.]+)\\s*}/g, (m, value) => {\n      for (const storage of Object.keys(STORAGE_PARAMS_REGEXES)) {\n        const match = value.match(STORAGE_PARAMS_REGEXES[storage]);\n        if (match) {\n          return window[storage].getItem(match[1]) || window[storage].getItem(`cti.${match[1]}`);\n        }\n      }\n      return config[value];\n    });\n    this.baseResourceUrl = RESOURCE_URL_TEMPLATE.replace(/\\${\\s*([\\w\\.]+)\\s*}/g, (m, value) => {\n      for (const storage of Object.keys(STORAGE_PARAMS_REGEXES)) {\n        const match = value.match(STORAGE_PARAMS_REGEXES[storage]);\n        if (match) {\n          return window[storage].getItem(match[1]) || window[storage].getItem(`cti.${match[1]}`);\n        }\n      }\n      if (value === 'parentsPath') {\n        let parentsPath = '';\n        if (config.parent) { // config.parent: { resourceType: '...', id: '...', parent: {...} }\n          let rootParent: any = config.parent;\n          while (rootParent) {\n            parentsPath += `/${rootParent.resourceType || rootParent.type}/${rootParent.externalId || rootParent.id}`;\n            rootParent = rootParent.parent;\n          }\n        }\n        return parentsPath;\n      } else {\n        return config[value];\n      }\n    });\n    this.newResourceUrl = NEW_RESOURCE_URL_TEMPLATE.replace(/\\${\\s*([\\w\\.]+)\\s*}/g, (m, value) => {\n      for (const storage of Object.keys(STORAGE_PARAMS_REGEXES)) {\n        const match = value.match(STORAGE_PARAMS_REGEXES[storage]);\n        if (match) {\n          return window[storage].getItem(match[1]);\n        }\n      }\n      if (value === 'parentsPath') {\n        let parentsPath = '';\n        if (config.parent) { // config.parent: { resourceType: '...', id: '...', parent: {...} }\n          let rootParent: any = config.parent;\n          while (rootParent) {\n            parentsPath += `/${rootParent.resourceType || rootParent.type}/${rootParent.externalId || rootParent.id}`;\n            rootParent = rootParent.parent;\n          }\n        }\n        return parentsPath;\n      } else {\n        return config[value];\n      }\n    });\n    this.id = config.externalId;\n  }\n\n  new(config: IMetaResourceConfig) {\n    const s = new MetaResourceService(this.httpClient);\n    s.setConfig(config);\n    return s;\n  }\n\n  searchIntegration(query, scope?: string) {\n    let searchUrl = `${this.baseIntegrationUrl}/search?q=${encodeURIComponent(query)}`;\n    if (scope) {\n      searchUrl += `&scope=${encodeURIComponent(scope)}`;\n    }\n    return this.httpClient.get(searchUrl);\n  }\n\n  getMetadata(layoutId?, refresh?) {\n    let url = `${this.baseResourceUrl.replace('/v2/', '/v3/')}/metadata`;\n    url += `?t=${new Date().getTime()}`;\n    if (refresh) {\n      url += '&refresh=true';\n    }\n    if (layoutId) {\n      url += `&layoutId=${layoutId}`;\n    }\n    return this.httpClient.get(url);\n  }\n\n  getDetails(externalId, extraParams?) {\n    let params = 'referenceDetails=true';\n    if (extraParams) {\n      for (const p in extraParams) {\n        if (extraParams[p]) {\n          params += `&${p}=${extraParams[p]}`;\n        }\n      }\n    }\n    return this.httpClient.get(`${this.baseResourceUrl}/${externalId}?${params}`);\n  }\n\n  getByPath(path) { // TODO not universal!\n    let fullPath = `${this.newResourceUrl}${path}`;\n    if (/^..\\//.test(path)) {\n      fullPath = `${this.baseIntegrationUrl}${path.substring(2)}`;\n    }\n    return this.httpClient.get(fullPath);\n  }\n\n  save(payload) {\n    if (this.id) {\n      return this.httpClient.put(\n        `${this.baseResourceUrl}/${this.id}`,\n        payload\n      );\n    } else {\n      return this.httpClient.post(\n        `${this.baseResourceUrl}`,\n        payload\n      );\n    }\n  }\n}\n"]}