@zdigambar/ngx-element 3.0.0 → 5.0.0

package/README.md

@@ -1,4 +1,4 @@
-# Supported version
+# Supported Version
 | ngx-element  | Angular  |
 | ------------ | -------  |
 | 1.x.x        | ^10.x.x  |

package/esm2020/lib/ngx-element.component.mjs

@@ -0,0 +1,105 @@
+import { Component, Input, ViewChild, ViewContainerRef, ReflectiveInjector } from '@angular/core';
+import { merge } from 'rxjs';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./ngx-element.service";
+export class NgxElementComponent {
+    constructor(ngxElementService, elementRef) {
+        this.ngxElementService = ngxElementService;
+        this.elementRef = elementRef;
+    }
+    /**
+     * Subscribe to event emitters of a lazy loaded and dynamically instantiated Angular component
+     * and dispatch them as Custom Events on the NgxElementComponent that is used in a template.
+     */
+    setProxiedOutputs(factory) {
+        const eventEmitters = factory.outputs.map(({ propName, templateName }) => {
+            const emitter = this.componentRef.instance[propName];
+            return emitter.pipe(map((value) => ({ name: templateName, value })));
+        });
+        const outputEvents = merge(...eventEmitters);
+        this.ngElementEventsSubscription = outputEvents.subscribe(subscription => {
+            const customEvent = document.createEvent('CustomEvent');
+            customEvent.initCustomEvent(subscription.name, false, false, subscription.value);
+            this.elementRef.nativeElement.dispatchEvent(customEvent);
+        });
+    }
+    ngOnInit() {
+        this.ngxElementService.getComponentToLoad(this.selector).subscribe(event => {
+            this.componentToLoad = event.componentClass;
+            this.componentFactoryResolver = this.ngxElementService.getComponentFactoryResolver(this.componentToLoad);
+            this.injector = this.ngxElementService.getInjector(this.componentToLoad);
+            const attributes = this.getElementAttributes();
+            this.createComponent(attributes);
+        });
+    }
+    createComponent(attributes) {
+        this.container.clear();
+        const factory = this.componentFactoryResolver.resolveComponentFactory(this.componentToLoad);
+        this.refInjector = ReflectiveInjector.resolveAndCreate([{ provide: this.componentToLoad, useValue: this.componentToLoad }], this.injector);
+        this.componentRef = this.container.createComponent(factory, 0, this.refInjector);
+        this.setAttributes(attributes);
+        this.listenToAttributeChanges();
+        this.setProxiedOutputs(factory);
+    }
+    setAttributes(attributes) {
+        attributes.forEach(attr => {
+            this.componentRef.instance[attr.name] = attr.value;
+        });
+    }
+    getElementAttributes() {
+        const attrs = this.elementRef.nativeElement.attributes;
+        const attributes = [];
+        for (let attr, i = 0; i < attrs.length; i++) {
+            attr = attrs[i];
+            if (attr.nodeName.match('^data-')) {
+                attributes.push({
+                    name: this.camelCaseAttribute(attr.nodeName),
+                    value: attr.nodeValue
+                });
+            }
+        }
+        return attributes;
+    }
+    camelCaseAttribute(attribute) {
+        const attr = attribute.replace('data-', '');
+        const chunks = attr.split('-');
+        if (chunks.length > 1) {
+            return chunks[0] + chunks.slice(1).map(chunk => chunk.replace(/^\w/, c => c.toUpperCase())).join('');
+        }
+        return attr;
+    }
+    listenToAttributeChanges() {
+        const observer = new MutationObserver(mutations => {
+            mutations.forEach(mutation => {
+                if (mutation.type === 'attributes') {
+                    const attributes = this.getElementAttributes();
+                    this.setAttributes(attributes);
+                }
+            });
+        });
+        observer.observe(this.elementRef.nativeElement, {
+            attributes: true
+        });
+    }
+    ngOnDestroy() {
+        this.componentRef.destroy();
+        this.ngElementEventsSubscription.unsubscribe();
+    }
+}
+NgxElementComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementComponent, deps: [{ token: i1.NgxElementService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+NgxElementComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: NgxElementComponent, selector: "lib-ngx-element", inputs: { selector: "selector" }, viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true, read: ViewContainerRef }], ngImport: i0, template: `
+    <ng-template #container></ng-template>
+  `, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-ngx-element', template: `
+    <ng-template #container></ng-template>
+  ` }]
+        }], ctorParameters: function () { return [{ type: i1.NgxElementService }, { type: i0.ElementRef }]; }, propDecorators: { selector: [{
+                type: Input
+            }], container: [{
+                type: ViewChild,
+                args: ['container', { read: ViewContainerRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngx-element.component.js","sourceRoot":"","sources":["../../../../projects/ngx-element/src/lib/ngx-element.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAIT,KAAK,EAGL,SAAS,EACT,gBAAgB,EAMhB,kBAAkB,EACnB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAC,KAAK,EAAe,MAAM,MAAM,CAAC;AACzC,OAAO,EAAC,GAAG,EAAC,MAAM,gBAAgB,CAAC;;;AASnC,MAAM,OAAO,mBAAmB;IAY9B,YACU,iBAAoC,EACpC,UAAsB;QADtB,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,eAAU,GAAV,UAAU,CAAY;IAC7B,CAAC;IAEJ;;;OAGG;IACK,iBAAiB,CAAC,OAA8B;QACtD,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAC,QAAQ,EAAE,YAAY,EAAC,EAAE,EAAE;YACrE,MAAM,OAAO,GAAI,IAAI,CAAC,YAAY,CAAC,QAAgB,CAAC,QAAQ,CAAsB,CAAC;YACnF,OAAO,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAU,EAAE,EAAE,CAAC,CAAC,EAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAC,CAAC,CAAC,CAAC,CAAC;QAC1E,CAAC,CAAC,CAAC;QACH,MAAM,YAAY,GAAG,KAAK,CAAC,GAAG,aAAa,CAAC,CAAC;QAC7C,IAAI,CAAC,2BAA2B,GAAG,YAAY,CAAC,SAAS,CAAC,YAAY,CAAC,EAAE;YACvE,MAAM,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;YACxD,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC;YACjF,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;QAC3D,CAAC,CAAC,CAAC;IACL,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,iBAAiB,CAAC,kBAAkB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;YACzE,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,cAAc,CAAC;YAC5C,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,iBAAiB,CAAC,2BAA2B,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;YACzG,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;YAEzE,MAAM,UAAU,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC/C,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,eAAe,CAAC,UAAU;QACxB,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QACvB,MAAM,OAAO,GAAG,IAAI,CAAC,wBAAwB,CAAC,uBAAuB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAE5F,IAAI,CAAC,WAAW,GAAG,kBAAkB,CAAC,gBAAgB,CACpD,CAAC,EAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,EAAE,IAAI,CAAC,eAAe,EAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,CACjF,CAAC;QACF,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAEjF,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;QAC/B,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAChC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAClC,CAAC;IAED,aAAa,CAAC,UAAU;QACtB,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACxB,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC;QACrD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,oBAAoB;QAClB,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,UAAU,CAAC;QACvD,MAAM,UAAU,GAAG,EAAE,CAAC;QAEtB,KAAK,IAAI,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC3C,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YAEhB,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE;gBACjC,UAAU,CAAC,IAAI,CAAC;oBACd,IAAI,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,QAAQ,CAAC;oBAC5C,KAAK,EAAE,IAAI,CAAC,SAAS;iBACtB,CAAC,CAAC;aACJ;SACF;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,kBAAkB,CAAC,SAAiB;QAClC,MAAM,IAAI,GAAG,SAAS,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QAC5C,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAE/B,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YACrB,OAAO,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;SACtG;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED,wBAAwB;QACtB,MAAM,QAAQ,GAAG,IAAI,gBAAgB,CAAC,SAAS,CAAC,EAAE;YAChD,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAC3B,IAAI,QAAQ,CAAC,IAAI,KAAK,YAAY,EAAE;oBAClC,MAAM,UAAU,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;oBAC/C,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;iBAChC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE;YAC9C,UAAU,EAAE,IAAI;SACjB,CAAC,CAAC;IACL,CAAC;IAED,WAAW;QACT,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;QAC5B,IAAI,CAAC,2BAA2B,CAAC,WAAW,EAAE,CAAC;IACjD,CAAC;;gHAhHU,mBAAmB;oGAAnB,mBAAmB,4KAIC,gBAAgB,6BATrC;;GAET;2FAGU,mBAAmB;kBAP/B,SAAS;+BACE,iBAAiB,YACjB;;GAET;iIAMQ,QAAQ;sBAAhB,KAAK;gBAC4C,SAAS;sBAA1D,SAAS;uBAAC,WAAW,EAAE,EAAC,IAAI,EAAE,gBAAgB,EAAC","sourcesContent":["import {\n  Component,\n  ComponentFactory,\n  ComponentRef,\n  OnInit,\n  Input,\n  Output,\n  Type,\n  ViewChild,\n  ViewContainerRef,\n  ComponentFactoryResolver,\n  OnDestroy,\n  EventEmitter,\n  ElementRef,\n  Injector,\n  ReflectiveInjector\n} from '@angular/core';\nimport {NgxElementService} from './ngx-element.service';\nimport {merge, Subscription} from 'rxjs';\nimport {map} from 'rxjs/operators';\n\n@Component({\n  selector: 'lib-ngx-element',\n  template: `\n    <ng-template #container></ng-template>\n  `,\n  styles: []\n})\nexport class NgxElementComponent implements OnInit, OnDestroy {\n\n  private ngElementEventsSubscription: Subscription;\n  @Input() selector: string;\n  @ViewChild('container', {read: ViewContainerRef}) container;\n\n  componentRef: ComponentRef<any>;\n  componentToLoad: Type<any>;\n  componentFactoryResolver: ComponentFactoryResolver;\n  injector: Injector;\n  refInjector: ReflectiveInjector;\n\n  constructor(\n    private ngxElementService: NgxElementService,\n    private elementRef: ElementRef\n  ) {}\n\n  /**\n   * Subscribe to event emitters of a lazy loaded and dynamically instantiated Angular component\n   * and dispatch them as Custom Events on the NgxElementComponent that is used in a template.\n   */\n  private setProxiedOutputs(factory: ComponentFactory<any>): void {\n    const eventEmitters = factory.outputs.map(({propName, templateName}) => {\n      const emitter = (this.componentRef.instance as any)[propName] as EventEmitter<any>;\n      return emitter.pipe(map((value: any) => ({name: templateName, value})));\n    });\n    const outputEvents = merge(...eventEmitters);\n    this.ngElementEventsSubscription = outputEvents.subscribe(subscription => {\n      const customEvent = document.createEvent('CustomEvent');\n      customEvent.initCustomEvent(subscription.name, false, false, subscription.value);\n      this.elementRef.nativeElement.dispatchEvent(customEvent);\n    });\n  }\n\n  ngOnInit(): void {\n    this.ngxElementService.getComponentToLoad(this.selector).subscribe(event => {\n      this.componentToLoad = event.componentClass;\n      this.componentFactoryResolver = this.ngxElementService.getComponentFactoryResolver(this.componentToLoad);\n      this.injector = this.ngxElementService.getInjector(this.componentToLoad);\n\n      const attributes = this.getElementAttributes();\n      this.createComponent(attributes);\n    });\n  }\n\n  createComponent(attributes) {\n    this.container.clear();\n    const factory = this.componentFactoryResolver.resolveComponentFactory(this.componentToLoad);\n\n    this.refInjector = ReflectiveInjector.resolveAndCreate(\n      [{provide: this.componentToLoad, useValue: this.componentToLoad}], this.injector\n    );\n    this.componentRef = this.container.createComponent(factory, 0, this.refInjector);\n\n    this.setAttributes(attributes);\n    this.listenToAttributeChanges();\n    this.setProxiedOutputs(factory);\n  }\n\n  setAttributes(attributes) {\n    attributes.forEach(attr => {\n      this.componentRef.instance[attr.name] = attr.value;\n    });\n  }\n\n  getElementAttributes() {\n    const attrs = this.elementRef.nativeElement.attributes;\n    const attributes = [];\n\n    for (let attr, i = 0; i < attrs.length; i++) {\n      attr = attrs[i];\n\n      if (attr.nodeName.match('^data-')) {\n        attributes.push({\n          name: this.camelCaseAttribute(attr.nodeName),\n          value: attr.nodeValue\n        });\n      }\n    }\n\n    return attributes;\n  }\n\n  camelCaseAttribute(attribute: string) {\n    const attr = attribute.replace('data-', '');\n    const chunks = attr.split('-');\n\n    if (chunks.length > 1) {\n      return chunks[0] + chunks.slice(1).map(chunk => chunk.replace(/^\\w/, c => c.toUpperCase())).join('');\n    }\n\n    return attr;\n  }\n\n  listenToAttributeChanges() {\n    const observer = new MutationObserver(mutations => {\n      mutations.forEach(mutation => {\n        if (mutation.type === 'attributes') {\n          const attributes = this.getElementAttributes();\n          this.setAttributes(attributes);\n        }\n      });\n    });\n\n    observer.observe(this.elementRef.nativeElement, {\n      attributes: true\n    });\n  }\n\n  ngOnDestroy() {\n    this.componentRef.destroy();\n    this.ngElementEventsSubscription.unsubscribe();\n  }\n}"]}

package/esm2020/lib/ngx-element.module.mjs

@@ -0,0 +1,34 @@
+import { NgModule } from '@angular/core';
+import { createCustomElement } from '@angular/elements';
+import { NgxElementComponent } from './ngx-element.component';
+import { LAZY_CMPS_PATH_TOKEN } from './tokens';
+import * as i0 from "@angular/core";
+export class NgxElementModule {
+    constructor(injector) {
+        this.injector = injector;
+        const ngxElement = createCustomElement(NgxElementComponent, { injector });
+        customElements.define('ngx-element', ngxElement);
+    }
+    static forRoot(modulePaths) {
+        return {
+            ngModule: NgxElementModule,
+            providers: [
+                {
+                    provide: LAZY_CMPS_PATH_TOKEN,
+                    useValue: modulePaths
+                }
+            ]
+        };
+    }
+    ngDoBootstrap() { }
+}
+NgxElementModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementModule, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule });
+NgxElementModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: NgxElementModule, declarations: [NgxElementComponent] });
+NgxElementModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [NgxElementComponent]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/ngx-element.service.mjs

@@ -0,0 +1,135 @@
+import { Injectable, Inject, NgModuleFactory, ComponentFactoryResolver } from '@angular/core';
+import { LAZY_CMPS_PATH_TOKEN } from './tokens';
+import { from } from 'rxjs';
+import * as i0 from "@angular/core";
+export class NgxElementService {
+    constructor(modulePaths, compiler, injector) {
+        this.compiler = compiler;
+        this.injector = injector;
+        this.loadedComponents = new Map();
+        this.elementsLoading = new Map();
+        this.injectors = new Map();
+        this.componentFactoryResolvers = new Map();
+        const ELEMENT_MODULE_PATHS = new Map();
+        modulePaths.forEach(route => {
+            ELEMENT_MODULE_PATHS.set(route.selector, route);
+        });
+        this.componentsToLoad = ELEMENT_MODULE_PATHS;
+    }
+    receiveContext(component, injector) {
+        this.injectors.set(component, injector);
+        this.componentFactoryResolvers.set(component, injector.get(ComponentFactoryResolver));
+    }
+    getInjector(component) {
+        return this.injectors.get(component);
+    }
+    getComponentFactoryResolver(component) {
+        return this.componentFactoryResolvers.get(component);
+    }
+    getComponentsToLoad() {
+        return this.componentsToLoad;
+    }
+    getComponentToLoad(selector) {
+        // Returns observable that completes when the lazy module has been loaded.
+        const registered = this.loadComponent(selector);
+        return from(registered);
+    }
+    /**
+     * Allows to lazy load a component given its selector.
+     * If the component selector has been registered, it's according module
+     * will be fetched lazily
+     * @param componentTag selector of the component to load
+     */
+    loadComponent(componentSelector) {
+        if (this.elementsLoading.has(componentSelector)) {
+            return this.elementsLoading.get(componentSelector);
+        }
+        if (this.componentsToLoad.has(componentSelector)) {
+            const cmpRegistryEntry = this.componentsToLoad.get(componentSelector);
+            const path = cmpRegistryEntry.loadChildren;
+            const loadPromise = new Promise((resolve, reject) => {
+                path()
+                    .then(elementModuleOrFactory => {
+                    /**
+                     * With View Engine, the NgModule factory is created and provided when loaded.
+                     * With Ivy, only the NgModule class is provided loaded and must be compiled.
+                     * This uses the same mechanism as the deprecated `SystemJsNgModuleLoader` in
+                     * in `packages/core/src/linker/system_js_ng_module_factory_loader.ts`
+                     * to pass on the NgModuleFactory, or compile the NgModule and return its NgModuleFactory.
+                     */
+                    if (elementModuleOrFactory instanceof NgModuleFactory) {
+                        return elementModuleOrFactory;
+                    }
+                    else {
+                        try {
+                            return this.compiler.compileModuleAsync(elementModuleOrFactory);
+                        }
+                        catch (err) {
+                            // return the error
+                            reject(err);
+                            // break the promise chain
+                            throw err;
+                        }
+                    }
+                })
+                    .then(moduleFactory => {
+                    const elementModuleRef = moduleFactory.create(this.injector);
+                    let componentClass;
+                    if (typeof elementModuleRef.instance.customElementComponent === 'object') {
+                        componentClass = elementModuleRef.instance.customElementComponent[componentSelector];
+                        if (!componentClass) {
+                            // tslint:disable-next-line: no-string-throw
+                            throw `You specified multiple component elements in module ${elementModuleRef} but there was no match for tag
+                        ${componentSelector} in ${JSON.stringify(elementModuleRef.instance.customElementComponent)}.
+                         Make sure the selector in the module is aligned with the one specified in the lazy module definition.`;
+                        }
+                    }
+                    else {
+                        componentClass = elementModuleRef.instance.customElementComponent;
+                    }
+                    // Register injector of the lazy module.
+                    // This is needed to share the entryComponents between the lazy module and the application
+                    const moduleInjector = elementModuleRef.injector;
+                    this.receiveContext(componentClass, moduleInjector);
+                    this.loadedComponents.set(componentSelector, componentClass);
+                    this.elementsLoading.delete(componentSelector);
+                    this.componentsToLoad.delete(componentSelector);
+                    resolve({
+                        selector: componentSelector,
+                        componentClass
+                    });
+                })
+                    .catch(err => {
+                    this.elementsLoading.delete(componentSelector);
+                    return Promise.reject(err);
+                });
+            });
+            this.elementsLoading.set(componentSelector, loadPromise);
+            return loadPromise;
+        }
+        else if (this.loadedComponents.has(componentSelector)) {
+            // component already loaded
+            return new Promise(resolve => {
+                resolve({
+                    selector: componentSelector,
+                    componentClass: this.loadedComponents.get(componentSelector)
+                });
+            });
+        }
+        else {
+            throw new Error(`Unrecognized component "${componentSelector}". Make sure it is registered in the component registry`);
+        }
+    }
+}
+NgxElementService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementService, deps: [{ token: LAZY_CMPS_PATH_TOKEN }, { token: i0.Compiler }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+NgxElementService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LAZY_CMPS_PATH_TOKEN]
+                }] }, { type: i0.Compiler }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngx-element.service.js","sourceRoot":"","sources":["../../../../projects/ngx-element/src/lib/ngx-element.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,eAAe,EAA4B,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACxH,OAAO,EAAE,oBAAoB,EAAoB,MAAM,UAAU,CAAC;AAElE,OAAO,EAAc,IAAI,EAAE,MAAM,MAAM,CAAC;;AAKxC,MAAM,OAAO,iBAAiB;IAQ5B,YAEE,WAEG,EACK,QAAkB,EAClB,QAAkB;QADlB,aAAQ,GAAR,QAAQ,CAAU;QAClB,aAAQ,GAAR,QAAQ,CAAU;QAZpB,qBAAgB,GAAG,IAAI,GAAG,EAAqB,CAAC;QAChD,oBAAe,GAAG,IAAI,GAAG,EAAuC,CAAC;QAEzE,cAAS,GAAG,IAAI,GAAG,EAAuB,CAAC;QAC3C,8BAAyB,GAAG,IAAI,GAAG,EAAuC,CAAC;QAUzE,MAAM,oBAAoB,GAAG,IAAI,GAAG,EAAe,CAAC;QACpD,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YAC1B,oBAAoB,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,gBAAgB,GAAG,oBAAoB,CAAC;IAC/C,CAAC;IAED,cAAc,CAAC,SAAoB,EAAE,QAAkB;QACrD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QACxC,IAAI,CAAC,yBAAyB,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC,CAAC;IACxF,CAAC;IAED,WAAW,CAAC,SAAoB;QAC9B,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IAED,2BAA2B,CAAC,SAAoB;QAC9C,OAAO,IAAI,CAAC,yBAAyB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACvD,CAAC;IAED,mBAAmB;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAED,kBAAkB,CAAC,QAAgB;QACjC,0EAA0E;QAC1E,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAChD,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC;IAC1B,CAAC;IAED;;;;;OAKG;IACH,aAAa,CAAC,iBAAyB;QACrC,IAAI,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,iBAAiB,CAAC,EAAE;YAC/C,OAAO,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;SACpD;QAED,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,iBAAiB,CAAC,EAAE;YAChD,MAAM,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;YACtE,MAAM,IAAI,GAAG,gBAAgB,CAAC,YAAY,CAAC;YAE3C,MAAM,WAAW,GAAG,IAAI,OAAO,CAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACrE,IAAI,EAAgD;qBAClD,IAAI,CAAC,sBAAsB,CAAC,EAAE;oBAC7B;;;;;;uBAMG;oBACH,IAAI,sBAAsB,YAAY,eAAe,EAAE;wBACrD,OAAO,sBAAsB,CAAC;qBAC/B;yBAAM;wBACL,IAAI;4BACF,OAAO,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;yBACjE;wBAAC,OAAO,GAAG,EAAE;4BACZ,mBAAmB;4BACnB,MAAM,CAAC,GAAG,CAAC,CAAC;4BAEZ,0BAA0B;4BAC1B,MAAM,GAAG,CAAC;yBACX;qBACF;gBACH,CAAC,CAAC;qBACD,IAAI,CAAC,aAAa,CAAC,EAAE;oBAClB,MAAM,gBAAgB,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;oBAC7D,IAAI,cAAc,CAAC;oBAEnB,IAAI,OAAO,gBAAgB,CAAC,QAAQ,CAAC,sBAAsB,KAAK,QAAQ,EAAE;wBACxE,cAAc,GAAG,gBAAgB,CAAC,QAAQ,CAAC,sBAAsB,CAAC,iBAAiB,CAAC,CAAC;wBAErF,IAAI,CAAC,cAAc,EAAE;4BACnB,4CAA4C;4BAC5C,MAAM,uDAAuD,gBAAgB;0BACrE,iBAAiB,OAAO,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,QAAQ,CAAC,sBAAsB,CAAC;+HACa,CAAC;yBAC/G;qBACF;yBAAM;wBACL,cAAc,GAAG,gBAAgB,CAAC,QAAQ,CAAC,sBAAsB,CAAC;qBACnE;oBAED,wCAAwC;oBACxC,0FAA0F;oBAC1F,MAAM,cAAc,GAAG,gBAAgB,CAAC,QAAQ,CAAC;oBACjD,IAAI,CAAC,cAAc,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC;oBAEpD,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,iBAAiB,EAAE,cAAc,CAAC,CAAC;oBAC7D,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;oBAC/C,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;oBAEhD,OAAO,CAAC;wBACN,QAAQ,EAAE,iBAAiB;wBAC3B,cAAc;qBACf,CAAC,CAAC;gBACP,CAAC,CAAC;qBACD,KAAK,CAAC,GAAG,CAAC,EAAE;oBACX,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;oBAC/C,OAAO,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBAC7B,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,CAAC;YAEH,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,iBAAiB,EAAE,WAAW,CAAC,CAAC;YACzD,OAAO,WAAW,CAAC;SAEpB;aAAM,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,iBAAiB,CAAC,EAAE;YACvD,2BAA2B;YAC3B,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;gBAC3B,OAAO,CAAC;oBACN,QAAQ,EAAE,iBAAiB;oBAC3B,cAAc,EAAE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,iBAAiB,CAAC;iBAC7D,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;SACJ;aAAM;YACL,MAAM,IAAI,KAAK,CACb,2BAA2B,iBAAiB,yDAAyD,CACtG,CAAC;SACH;IACH,CAAC;;8GA3IU,iBAAiB,kBASlB,oBAAoB;kHATnB,iBAAiB,cAFhB,MAAM;2FAEP,iBAAiB;kBAH7B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAUI,MAAM;2BAAC,oBAAoB","sourcesContent":["import { Injectable, Inject, NgModuleFactory, Type, Compiler, Injector, ComponentFactoryResolver } from '@angular/core';\nimport { LAZY_CMPS_PATH_TOKEN, LazyComponentDef } from './tokens';\nimport { LazyCmpLoadedEvent } from './lazy-component-loaded-event';\nimport { Observable, from } from 'rxjs';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class NgxElementService {\n  private componentsToLoad: Map<string, LazyComponentDef>;\n  private loadedComponents = new Map<string, Type<any>>();\n  private elementsLoading = new Map<string, Promise<LazyCmpLoadedEvent>>();\n\n  injectors = new Map<Type<any>, Injector>();\n  componentFactoryResolvers = new Map<Type<any>, ComponentFactoryResolver>();\n\n  constructor(\n    @Inject(LAZY_CMPS_PATH_TOKEN)\n    modulePaths: {\n      selector: string\n    }[],\n    private compiler: Compiler,\n    private injector: Injector\n  ) {\n    const ELEMENT_MODULE_PATHS = new Map<string, any>();\n    modulePaths.forEach(route => {\n      ELEMENT_MODULE_PATHS.set(route.selector, route);\n    });\n\n    this.componentsToLoad = ELEMENT_MODULE_PATHS;\n  }\n\n  receiveContext(component: Type<any>, injector: Injector) {\n    this.injectors.set(component, injector);\n    this.componentFactoryResolvers.set(component, injector.get(ComponentFactoryResolver));\n  }\n\n  getInjector(component: Type<any>): Injector {\n    return this.injectors.get(component);\n  }\n\n  getComponentFactoryResolver(component: Type<any>): ComponentFactoryResolver {\n    return this.componentFactoryResolvers.get(component);\n  }\n\n  getComponentsToLoad() {\n    return this.componentsToLoad;\n  }\n\n  getComponentToLoad(selector: string): Observable<LazyCmpLoadedEvent> {\n    // Returns observable that completes when the lazy module has been loaded.\n    const registered = this.loadComponent(selector);\n    return from(registered);\n  }\n\n  /**\n   * Allows to lazy load a component given its selector.\n   * If the component selector has been registered, it's according module\n   * will be fetched lazily\n   * @param componentTag selector of the component to load\n   */\n  loadComponent(componentSelector: string): Promise<LazyCmpLoadedEvent> {\n    if (this.elementsLoading.has(componentSelector)) {\n      return this.elementsLoading.get(componentSelector);\n    }\n\n    if (this.componentsToLoad.has(componentSelector)) {\n      const cmpRegistryEntry = this.componentsToLoad.get(componentSelector);\n      const path = cmpRegistryEntry.loadChildren;\n\n      const loadPromise = new Promise<LazyCmpLoadedEvent>((resolve, reject) => {\n        (path() as Promise<NgModuleFactory<any> | Type<any>>)\n          .then(elementModuleOrFactory => {\n            /**\n             * With View Engine, the NgModule factory is created and provided when loaded.\n             * With Ivy, only the NgModule class is provided loaded and must be compiled.\n             * This uses the same mechanism as the deprecated `SystemJsNgModuleLoader` in\n             * in `packages/core/src/linker/system_js_ng_module_factory_loader.ts`\n             * to pass on the NgModuleFactory, or compile the NgModule and return its NgModuleFactory.\n             */\n            if (elementModuleOrFactory instanceof NgModuleFactory) {\n              return elementModuleOrFactory;\n            } else {\n              try {\n                return this.compiler.compileModuleAsync(elementModuleOrFactory);\n              } catch (err) {\n                // return the error\n                reject(err);\n\n                // break the promise chain\n                throw err;\n              }\n            }\n          })\n          .then(moduleFactory => {\n              const elementModuleRef = moduleFactory.create(this.injector);\n              let componentClass;\n\n              if (typeof elementModuleRef.instance.customElementComponent === 'object') {\n                componentClass = elementModuleRef.instance.customElementComponent[componentSelector];\n\n                if (!componentClass) {\n                  // tslint:disable-next-line: no-string-throw\n                  throw `You specified multiple component elements in module ${elementModuleRef} but there was no match for tag\n                        ${componentSelector} in ${JSON.stringify(elementModuleRef.instance.customElementComponent)}.\n                         Make sure the selector in the module is aligned with the one specified in the lazy module definition.`;\n                }\n              } else {\n                componentClass = elementModuleRef.instance.customElementComponent;\n              }\n\n              // Register injector of the lazy module.\n              // This is needed to share the entryComponents between the lazy module and the application\n              const moduleInjector = elementModuleRef.injector;\n              this.receiveContext(componentClass, moduleInjector);\n\n              this.loadedComponents.set(componentSelector, componentClass);\n              this.elementsLoading.delete(componentSelector);\n              this.componentsToLoad.delete(componentSelector);\n\n              resolve({\n                selector: componentSelector,\n                componentClass\n              });\n          })\n          .catch(err => {\n            this.elementsLoading.delete(componentSelector);\n            return Promise.reject(err);\n          });\n      });\n\n      this.elementsLoading.set(componentSelector, loadPromise);\n      return loadPromise;\n\n    } else if (this.loadedComponents.has(componentSelector)) {\n      // component already loaded\n      return new Promise(resolve => {\n        resolve({\n          selector: componentSelector,\n          componentClass: this.loadedComponents.get(componentSelector)\n        });\n      });\n    } else {\n      throw new Error(\n        `Unrecognized component \"${componentSelector}\". Make sure it is registered in the component registry`\n      );\n    }\n  }\n}"]}

package/esm2020/zdigambar-ngx-element.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiemRpZ2FtYmFyLW5neC1lbGVtZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvbmd4LWVsZW1lbnQvc3JjL3pkaWdhbWJhci1uZ3gtZWxlbWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/fesm2015/zdigambar-ngx-element.mjs

@@ -0,0 +1,281 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, ComponentFactoryResolver, NgModuleFactory, Injectable, Inject, ReflectiveInjector, ViewContainerRef, Component, Input, ViewChild, NgModule } from '@angular/core';
+import { createCustomElement } from '@angular/elements';
+import { from, merge } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+/* Injection token to provide the element path modules. */
+const LAZY_CMPS_PATH_TOKEN = new InjectionToken('ngx-lazy-cmp-registry');
+
+class NgxElementService {
+    constructor(modulePaths, compiler, injector) {
+        this.compiler = compiler;
+        this.injector = injector;
+        this.loadedComponents = new Map();
+        this.elementsLoading = new Map();
+        this.injectors = new Map();
+        this.componentFactoryResolvers = new Map();
+        const ELEMENT_MODULE_PATHS = new Map();
+        modulePaths.forEach(route => {
+            ELEMENT_MODULE_PATHS.set(route.selector, route);
+        });
+        this.componentsToLoad = ELEMENT_MODULE_PATHS;
+    }
+    receiveContext(component, injector) {
+        this.injectors.set(component, injector);
+        this.componentFactoryResolvers.set(component, injector.get(ComponentFactoryResolver));
+    }
+    getInjector(component) {
+        return this.injectors.get(component);
+    }
+    getComponentFactoryResolver(component) {
+        return this.componentFactoryResolvers.get(component);
+    }
+    getComponentsToLoad() {
+        return this.componentsToLoad;
+    }
+    getComponentToLoad(selector) {
+        // Returns observable that completes when the lazy module has been loaded.
+        const registered = this.loadComponent(selector);
+        return from(registered);
+    }
+    /**
+     * Allows to lazy load a component given its selector.
+     * If the component selector has been registered, it's according module
+     * will be fetched lazily
+     * @param componentTag selector of the component to load
+     */
+    loadComponent(componentSelector) {
+        if (this.elementsLoading.has(componentSelector)) {
+            return this.elementsLoading.get(componentSelector);
+        }
+        if (this.componentsToLoad.has(componentSelector)) {
+            const cmpRegistryEntry = this.componentsToLoad.get(componentSelector);
+            const path = cmpRegistryEntry.loadChildren;
+            const loadPromise = new Promise((resolve, reject) => {
+                path()
+                    .then(elementModuleOrFactory => {
+                    /**
+                     * With View Engine, the NgModule factory is created and provided when loaded.
+                     * With Ivy, only the NgModule class is provided loaded and must be compiled.
+                     * This uses the same mechanism as the deprecated `SystemJsNgModuleLoader` in
+                     * in `packages/core/src/linker/system_js_ng_module_factory_loader.ts`
+                     * to pass on the NgModuleFactory, or compile the NgModule and return its NgModuleFactory.
+                     */
+                    if (elementModuleOrFactory instanceof NgModuleFactory) {
+                        return elementModuleOrFactory;
+                    }
+                    else {
+                        try {
+                            return this.compiler.compileModuleAsync(elementModuleOrFactory);
+                        }
+                        catch (err) {
+                            // return the error
+                            reject(err);
+                            // break the promise chain
+                            throw err;
+                        }
+                    }
+                })
+                    .then(moduleFactory => {
+                    const elementModuleRef = moduleFactory.create(this.injector);
+                    let componentClass;
+                    if (typeof elementModuleRef.instance.customElementComponent === 'object') {
+                        componentClass = elementModuleRef.instance.customElementComponent[componentSelector];
+                        if (!componentClass) {
+                            // tslint:disable-next-line: no-string-throw
+                            throw `You specified multiple component elements in module ${elementModuleRef} but there was no match for tag
+                        ${componentSelector} in ${JSON.stringify(elementModuleRef.instance.customElementComponent)}.
+                         Make sure the selector in the module is aligned with the one specified in the lazy module definition.`;
+                        }
+                    }
+                    else {
+                        componentClass = elementModuleRef.instance.customElementComponent;
+                    }
+                    // Register injector of the lazy module.
+                    // This is needed to share the entryComponents between the lazy module and the application
+                    const moduleInjector = elementModuleRef.injector;
+                    this.receiveContext(componentClass, moduleInjector);
+                    this.loadedComponents.set(componentSelector, componentClass);
+                    this.elementsLoading.delete(componentSelector);
+                    this.componentsToLoad.delete(componentSelector);
+                    resolve({
+                        selector: componentSelector,
+                        componentClass
+                    });
+                })
+                    .catch(err => {
+                    this.elementsLoading.delete(componentSelector);
+                    return Promise.reject(err);
+                });
+            });
+            this.elementsLoading.set(componentSelector, loadPromise);
+            return loadPromise;
+        }
+        else if (this.loadedComponents.has(componentSelector)) {
+            // component already loaded
+            return new Promise(resolve => {
+                resolve({
+                    selector: componentSelector,
+                    componentClass: this.loadedComponents.get(componentSelector)
+                });
+            });
+        }
+        else {
+            throw new Error(`Unrecognized component "${componentSelector}". Make sure it is registered in the component registry`);
+        }
+    }
+}
+NgxElementService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementService, deps: [{ token: LAZY_CMPS_PATH_TOKEN }, { token: i0.Compiler }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+NgxElementService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [LAZY_CMPS_PATH_TOKEN]
+                    }] }, { type: i0.Compiler }, { type: i0.Injector }];
+    } });
+
+class NgxElementComponent {
+    constructor(ngxElementService, elementRef) {
+        this.ngxElementService = ngxElementService;
+        this.elementRef = elementRef;
+    }
+    /**
+     * Subscribe to event emitters of a lazy loaded and dynamically instantiated Angular component
+     * and dispatch them as Custom Events on the NgxElementComponent that is used in a template.
+     */
+    setProxiedOutputs(factory) {
+        const eventEmitters = factory.outputs.map(({ propName, templateName }) => {
+            const emitter = this.componentRef.instance[propName];
+            return emitter.pipe(map((value) => ({ name: templateName, value })));
+        });
+        const outputEvents = merge(...eventEmitters);
+        this.ngElementEventsSubscription = outputEvents.subscribe(subscription => {
+            const customEvent = document.createEvent('CustomEvent');
+            customEvent.initCustomEvent(subscription.name, false, false, subscription.value);
+            this.elementRef.nativeElement.dispatchEvent(customEvent);
+        });
+    }
+    ngOnInit() {
+        this.ngxElementService.getComponentToLoad(this.selector).subscribe(event => {
+            this.componentToLoad = event.componentClass;
+            this.componentFactoryResolver = this.ngxElementService.getComponentFactoryResolver(this.componentToLoad);
+            this.injector = this.ngxElementService.getInjector(this.componentToLoad);
+            const attributes = this.getElementAttributes();
+            this.createComponent(attributes);
+        });
+    }
+    createComponent(attributes) {
+        this.container.clear();
+        const factory = this.componentFactoryResolver.resolveComponentFactory(this.componentToLoad);
+        this.refInjector = ReflectiveInjector.resolveAndCreate([{ provide: this.componentToLoad, useValue: this.componentToLoad }], this.injector);
+        this.componentRef = this.container.createComponent(factory, 0, this.refInjector);
+        this.setAttributes(attributes);
+        this.listenToAttributeChanges();
+        this.setProxiedOutputs(factory);
+    }
+    setAttributes(attributes) {
+        attributes.forEach(attr => {
+            this.componentRef.instance[attr.name] = attr.value;
+        });
+    }
+    getElementAttributes() {
+        const attrs = this.elementRef.nativeElement.attributes;
+        const attributes = [];
+        for (let attr, i = 0; i < attrs.length; i++) {
+            attr = attrs[i];
+            if (attr.nodeName.match('^data-')) {
+                attributes.push({
+                    name: this.camelCaseAttribute(attr.nodeName),
+                    value: attr.nodeValue
+                });
+            }
+        }
+        return attributes;
+    }
+    camelCaseAttribute(attribute) {
+        const attr = attribute.replace('data-', '');
+        const chunks = attr.split('-');
+        if (chunks.length > 1) {
+            return chunks[0] + chunks.slice(1).map(chunk => chunk.replace(/^\w/, c => c.toUpperCase())).join('');
+        }
+        return attr;
+    }
+    listenToAttributeChanges() {
+        const observer = new MutationObserver(mutations => {
+            mutations.forEach(mutation => {
+                if (mutation.type === 'attributes') {
+                    const attributes = this.getElementAttributes();
+                    this.setAttributes(attributes);
+                }
+            });
+        });
+        observer.observe(this.elementRef.nativeElement, {
+            attributes: true
+        });
+    }
+    ngOnDestroy() {
+        this.componentRef.destroy();
+        this.ngElementEventsSubscription.unsubscribe();
+    }
+}
+NgxElementComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementComponent, deps: [{ token: NgxElementService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+NgxElementComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: NgxElementComponent, selector: "lib-ngx-element", inputs: { selector: "selector" }, viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true, read: ViewContainerRef }], ngImport: i0, template: `
+    <ng-template #container></ng-template>
+  `, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-ngx-element', template: `
+    <ng-template #container></ng-template>
+  ` }]
+        }], ctorParameters: function () { return [{ type: NgxElementService }, { type: i0.ElementRef }]; }, propDecorators: { selector: [{
+                type: Input
+            }], container: [{
+                type: ViewChild,
+                args: ['container', { read: ViewContainerRef }]
+            }] } });
+
+class NgxElementModule {
+    constructor(injector) {
+        this.injector = injector;
+        const ngxElement = createCustomElement(NgxElementComponent, { injector });
+        customElements.define('ngx-element', ngxElement);
+    }
+    static forRoot(modulePaths) {
+        return {
+            ngModule: NgxElementModule,
+            providers: [
+                {
+                    provide: LAZY_CMPS_PATH_TOKEN,
+                    useValue: modulePaths
+                }
+            ]
+        };
+    }
+    ngDoBootstrap() { }
+}
+NgxElementModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementModule, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule });
+NgxElementModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: NgxElementModule, declarations: [NgxElementComponent] });
+NgxElementModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgxElementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [NgxElementComponent]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+
+/*
+ * Public API Surface of ngx-element
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { NgxElementModule };
+//# sourceMappingURL=zdigambar-ngx-element.mjs.map