@dotglitch/ngx-common 1.0.2

package/esm2020/components/dynamic-html/dynamic-html.module.mjs

@@ -0,0 +1,27 @@
+import { NgModule } from '@angular/core';
+import { DynamicHTMLComponent } from './dynamic-html.component';
+import { NGX_DYNAMIC_CONFIG } from './types';
+import { DynamicHTMLRenderer } from './dynamic-html.service';
+import * as i0 from "@angular/core";
+export class NgxDynamicHTMLModule {
+    static forRoot(config) {
+        return {
+            ngModule: NgxDynamicHTMLModule,
+            providers: [
+                DynamicHTMLRenderer,
+                { provide: NGX_DYNAMIC_CONFIG, useValue: config }
+            ],
+        };
+    }
+}
+NgxDynamicHTMLModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: NgxDynamicHTMLModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgxDynamicHTMLModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: NgxDynamicHTMLModule, imports: [DynamicHTMLComponent], exports: [DynamicHTMLComponent] });
+NgxDynamicHTMLModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: NgxDynamicHTMLModule, imports: [DynamicHTMLComponent] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: NgxDynamicHTMLModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [DynamicHTMLComponent],
+                    exports: [DynamicHTMLComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy1odG1sLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbW1vbi9zcmMvY29tcG9uZW50cy9keW5hbWljLWh0bWwvZHluYW1pYy1odG1sLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUF1QixNQUFNLGVBQWUsQ0FBQztBQUM5RCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUNoRSxPQUFPLEVBQXNCLGtCQUFrQixFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQ2pFLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDOztBQU03RCxNQUFNLE9BQU8sb0JBQW9CO0lBQ3RCLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBMEI7UUFDNUMsT0FBTztZQUNILFFBQVEsRUFBRSxvQkFBb0I7WUFDOUIsU0FBUyxFQUFFO2dCQUNQLG1CQUFtQjtnQkFDbkIsRUFBRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRTthQUNwRDtTQUNKLENBQUM7SUFDTixDQUFDOztpSEFUUSxvQkFBb0I7a0hBQXBCLG9CQUFvQixZQUhuQixvQkFBb0IsYUFDcEIsb0JBQW9CO2tIQUVyQixvQkFBb0IsWUFIbkIsb0JBQW9COzJGQUdyQixvQkFBb0I7a0JBSmhDLFFBQVE7bUJBQUM7b0JBQ04sT0FBTyxFQUFFLENBQUMsb0JBQW9CLENBQUM7b0JBQy9CLE9BQU8sRUFBRSxDQUFDLG9CQUFvQixDQUFDO2lCQUNsQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlLCBNb2R1bGVXaXRoUHJvdmlkZXJzIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEeW5hbWljSFRNTENvbXBvbmVudCB9IGZyb20gJy4vZHluYW1pYy1odG1sLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBEeW5hbWljSFRNTE9wdGlvbnMsIE5HWF9EWU5BTUlDX0NPTkZJRyB9IGZyb20gJy4vdHlwZXMnO1xuaW1wb3J0IHsgRHluYW1pY0hUTUxSZW5kZXJlciB9IGZyb20gJy4vZHluYW1pYy1odG1sLnNlcnZpY2UnO1xuXG5ATmdNb2R1bGUoe1xuICAgIGltcG9ydHM6IFtEeW5hbWljSFRNTENvbXBvbmVudF0sXG4gICAgZXhwb3J0czogW0R5bmFtaWNIVE1MQ29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgTmd4RHluYW1pY0hUTUxNb2R1bGUge1xuICAgIHB1YmxpYyBzdGF0aWMgZm9yUm9vdChjb25maWc6IER5bmFtaWNIVE1MT3B0aW9ucyk6IE1vZHVsZVdpdGhQcm92aWRlcnM8Tmd4RHluYW1pY0hUTUxNb2R1bGU+IHtcbiAgICAgICAgcmV0dXJuIHtcbiAgICAgICAgICAgIG5nTW9kdWxlOiBOZ3hEeW5hbWljSFRNTE1vZHVsZSxcbiAgICAgICAgICAgIHByb3ZpZGVyczogW1xuICAgICAgICAgICAgICAgIER5bmFtaWNIVE1MUmVuZGVyZXIsXG4gICAgICAgICAgICAgICAgeyBwcm92aWRlOiBOR1hfRFlOQU1JQ19DT05GSUcsIHVzZVZhbHVlOiBjb25maWcgfVxuICAgICAgICAgICAgXSxcbiAgICAgICAgfTtcbiAgICB9XG59XG4iXX0=

package/esm2020/components/dynamic-html/dynamic-html.service.mjs

@@ -0,0 +1,66 @@
+import { Injectable, Inject } from '@angular/core';
+import { NGX_DYNAMIC_CONFIG } from './types';
+import * as i0 from "@angular/core";
+import * as i1 from "./types";
+function isBrowserPlatform() {
+    return window != null && window.document != null;
+}
+export class DynamicHTMLRenderer {
+    constructor(config, cfr, injector) {
+        this.config = config;
+        this.cfr = cfr;
+        this.injector = injector;
+        this.componentFactories = new Map();
+        this.componentRefs = new Map();
+        this.config.components.forEach(({ selector, component }) => {
+            let cf;
+            cf = this.cfr.resolveComponentFactory(component);
+            this.componentFactories.set(selector, cf);
+        });
+    }
+    renderInnerHTML(elementRef, html) {
+        if (!isBrowserPlatform()) {
+            return {
+                check: () => { },
+                destroy: () => { },
+            };
+        }
+        elementRef.nativeElement.innerHTML = html;
+        const componentRefs = [];
+        this.config.components.forEach(({ selector }) => {
+            const elements = elementRef.nativeElement.querySelectorAll(selector);
+            Array.prototype.forEach.call(elements, (el) => {
+                const content = el.innerHTML;
+                const cmpRef = this.componentFactories.get(selector).create(this.injector, [], el);
+                el.removeAttribute('ng-version');
+                if (cmpRef.instance.dynamicOnMount) {
+                    const attrsMap = new Map();
+                    if (el.hasAttributes()) {
+                        Array.prototype.forEach.call(el.attributes, (attr) => {
+                            attrsMap.set(attr.name, attr.value);
+                        });
+                    }
+                    cmpRef.instance.dynamicOnMount(attrsMap, content, el);
+                }
+                componentRefs.push(cmpRef);
+            });
+        });
+        this.componentRefs.set(elementRef, componentRefs);
+        return {
+            check: () => componentRefs.forEach(ref => ref.changeDetectorRef.detectChanges()),
+            destroy: () => {
+                componentRefs.forEach(ref => ref.destroy());
+                this.componentRefs.delete(elementRef);
+            },
+        };
+    }
+}
+DynamicHTMLRenderer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DynamicHTMLRenderer, deps: [{ token: NGX_DYNAMIC_CONFIG }, { token: i0.ComponentFactoryResolver }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicHTMLRenderer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DynamicHTMLRenderer });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DynamicHTMLRenderer, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DynamicHTMLOptions, decorators: [{
+                    type: Inject,
+                    args: [NGX_DYNAMIC_CONFIG]
+                }] }, { type: i0.ComponentFactoryResolver }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/components/dynamic-html/types.mjs

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+export class OnMount {
+}
+export class DynamicHTMLOptions {
+}
+export const NGX_DYNAMIC_CONFIG = new InjectionToken('config');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vc3JjL2NvbXBvbmVudHMvZHluYW1pYy1odG1sL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQVEsTUFBTSxlQUFlLENBQUM7QUFFckQsTUFBTSxPQUFnQixPQUFPO0NBRTVCO0FBTUQsTUFBTSxPQUFPLGtCQUFrQjtDQUU5QjtBQUVELE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLElBQUksY0FBYyxDQUFxQixRQUFRLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuLCBUeXBlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBPbk1vdW50IHtcbiAgICBhYnN0cmFjdCBkeW5hbWljT25Nb3VudChhdHRycz86IE1hcDxzdHJpbmcsIHN0cmluZz4sIGNvbnRlbnQ/OiBzdHJpbmcsIGVsZW1lbnQ/OiBFbGVtZW50KTogdm9pZDtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBDb21wb25lbnRXaXRoU2VsZWN0b3Ige1xuICAgIHNlbGVjdG9yOiBzdHJpbmc7XG4gICAgY29tcG9uZW50OiBUeXBlPGFueT47XG59XG5leHBvcnQgY2xhc3MgRHluYW1pY0hUTUxPcHRpb25zIHtcbiAgICBjb21wb25lbnRzOiBBcnJheTxDb21wb25lbnRXaXRoU2VsZWN0b3I+O1xufVxuXG5leHBvcnQgY29uc3QgTkdYX0RZTkFNSUNfQ09ORklHID0gbmV3IEluamVjdGlvblRva2VuPER5bmFtaWNIVE1MT3B0aW9ucz4oJ2NvbmZpZycpO1xuXG4iXX0=

package/esm2020/components/lazy-loader/lazy-loader.component.mjs

@@ -0,0 +1,360 @@
+import { Input, ViewContainerRef, isDevMode, EventEmitter, Optional, ViewChild, Component, Inject, Output } from '@angular/core';
+import { NgComponentOutlet, NgIf, NgTemplateOutlet } from '@angular/common';
+import { MAT_DIALOG_DATA, } from '@angular/material/dialog';
+import { debounceTime } from 'rxjs';
+import { LazyLoaderService } from './lazy-loader.service';
+import { stringToSlug } from '../../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./lazy-loader.service";
+import * as i2 from "@angular/cdk/dialog";
+export class LazyLoaderComponent {
+    /**
+     * The id of the component that will be lazy loaded
+     */
+    set id(data) {
+        const id = stringToSlug(data);
+        // Check if there is a change to the loaded component's id
+        // if it's updated, we destroy and rehydrate the entire container
+        if (this.initialized && this._id != id) {
+            this._id = id;
+            this.ngAfterViewInit();
+        }
+        else {
+            this._id = id;
+        }
+    }
+    ;
+    set group(data) {
+        const group = stringToSlug(data);
+        if (typeof group != "string" || !group)
+            return;
+        // If the group was updated, retry to bootstrap something into the container.
+        if (this.initialized && this._group != group) {
+            this._group = group;
+            this.ngAfterViewInit();
+            return;
+        }
+        this._group = group;
+    }
+    get group() { return this._group; }
+    /**
+     * A map of inputs to bind to the child.
+     * Supports change detection. (May fail on deep JSON changes)
+     *
+     * ```html
+     * <lazy-loader component="MyLazyComponent"
+     *       [inputs]="{
+     *          prop1: true,
+     *          prop2: false,
+     *          complex: {
+     *              a: true,
+     *              b: 0
+     *          }
+     *       }"
+     * >
+     * </lazy-loader>
+     * ```
+     */
+    set inputs(data) {
+        if (data == undefined)
+            return;
+        let previous = this._inputs;
+        this._inputs = data;
+        if (data == undefined)
+            console.trace(data);
+        if (this.targetComponentFactory) {
+            const { inputs } = this.targetComponentFactory.ɵcmp;
+            const currentKeys = Object.keys(inputs);
+            const oldKeys = Object.keys(previous).filter(key => currentKeys.includes(key));
+            const newKeys = Object.keys(data).filter(key => currentKeys.includes(key));
+            const removed = oldKeys.filter(key => !newKeys.includes(key));
+            // ? perhaps set to null or undefined instead
+            removed.forEach(k => this.targetComponentInstance[k] = null);
+            this.bindInputs();
+        }
+    }
+    /**
+     * A map of outputs to bind from the child.
+     * Should support change detection.
+     * ```html
+     * <lazy-loader component="MyLazyComponent"
+     *       [outputs]="{
+     *           prop3: onOutputFire
+     *       }"
+     * >
+     * </lazy-loader>
+     * ```
+     */
+    set outputs(data) {
+        let previous = this._outputs;
+        this._outputs = data;
+        if (this.targetComponentFactory) {
+            const { inputs } = this.targetComponentFactory.ɵcmp;
+            const currentKeys = Object.keys(inputs);
+            const removed = Object.keys(previous).filter(key => !currentKeys.includes(key));
+            removed.forEach(k => {
+                // Unsubscribe from observable
+                this.outputSubscriptions[k]?.unsubscribe();
+                delete this.targetComponentInstance[k];
+            });
+            this.bindOutputs();
+        }
+    }
+    constructor(service, viewContainerRef, dialog, dialogArguments) {
+        this.service = service;
+        this.viewContainerRef = viewContainerRef;
+        this.dialog = dialog;
+        this.dialogArguments = dialogArguments;
+        this._group = "default";
+        this.outputSubscriptions = {};
+        /**
+         * Emits errors encountered when loading components
+         */
+        this.componentLoadError = new EventEmitter();
+        /**
+         * Emits when the component is fully constructed
+         * and had it's inputs and outputs bound
+         * > before `OnInit`
+         *
+         * Returns the active class instance of the lazy-loaded component
+         */
+        this.componentLoaded = new EventEmitter();
+        // Force 500ms delay before revealing the spinner
+        this.loaderEmitter = new EventEmitter();
+        this.clearLoader$ = this.loaderEmitter.pipe(debounceTime(300));
+        this.showLoader = true; // whether we render the DOM for the spinner
+        this.isClearingLoader = false; // should the spinner start fading out
+        this.initialized = false;
+        this.config = LazyLoaderService.config;
+        this.err = LazyLoaderService.config.logger.err;
+        this.warn = LazyLoaderService.config.logger.warn;
+        this.log = LazyLoaderService.config.logger.log;
+        // First, check for dialog arguments
+        if (this.dialogArguments) {
+            this.inputs = this.dialogArguments.inputs || this.dialogArguments.data;
+            this.outputs = this.dialogArguments.outputs;
+            this.id = this.dialogArguments.id;
+            this.group = this.dialogArguments.group;
+        }
+        this.loaderSub = this.clearLoader$.subscribe(() => {
+            this.showLoader = false;
+        });
+    }
+    async ngAfterViewInit() {
+        this.ngOnDestroy(false);
+        this.isClearingLoader = false;
+        this.showLoader = true;
+        this.initialized = true;
+        if (!this._id) {
+            this.warn("No component was specified!");
+            return this.loadDefault();
+        }
+        try {
+            const _entry = this.service.resolveRegistrationEntry(this._id, this._group);
+            if (!_entry || !_entry.entry) {
+                this.err(`Failed to find Component '${this._id}' in group '${this._group}' in registry!`);
+                return this.loadDefault();
+            }
+            const { entry, matchGroups } = _entry;
+            this._matchGroups = matchGroups;
+            // Download the "module" (the standalone component)
+            const bundle = this.targetModule = await entry.load();
+            // Check if there is some corruption on the bundle.
+            if (!bundle || typeof bundle != 'object' || bundle['__esModule'] !== true || bundle.toString() != "[object Module]") {
+                this.err(`Failed to load component/module for '${this._id}'! Parsed resource is invalid.`);
+                return this.loadError();
+            }
+            const modules = Object.keys(bundle)
+                .map(k => {
+                const entry = bundle[k];
+                // Strictly check for exported modules or standalone components
+                if (typeof entry == "function" && typeof entry["ɵfac"] == "function")
+                    return entry;
+                return null;
+            })
+                .filter(e => e != null)
+                .filter(entry => {
+                entry['_isModule'] = !!entry['ɵmod']; // module
+                entry['_isComponent'] = !!entry['ɵcmp']; // component
+                return (entry['_isModule'] || entry['_isComponent']);
+            });
+            if (modules.length == 0) {
+                this.err(`Component/Module loaded for '${this._id}' has no exported components or modules!`);
+                return this.loadError();
+            }
+            const component = this.targetComponentFactory = this.service.resolveComponent(this._id, "default", modules);
+            if (!component) {
+                this.err(`Component '${this._id}' is invalid or corrupted!`);
+                return this.loadError();
+            }
+            // Bootstrap the component into the container
+            const componentRef = this.targetComponentContainerRef = this.targetContainer.createComponent(component);
+            this.targetRef = this.targetContainer.insert(this.targetComponentContainerRef.hostView);
+            const instance = this.targetComponentInstance = componentRef['instance'];
+            this.bindInputs();
+            this.bindOutputs();
+            this.componentLoaded.next(instance);
+            this.instance = instance;
+            // Look for an observable called isLoading$ that will make us show/hide
+            // the same distractor that is used on basic loading
+            const isLoading$ = instance['ngxShowDistractor$'];
+            if (isLoading$ && typeof isLoading$.subscribe == "function") {
+                this.distractorSubscription = isLoading$.subscribe(loading => {
+                    if (!loading) {
+                        this.isClearingLoader = true;
+                        this.loaderEmitter.emit();
+                    }
+                    else {
+                        this.showLoader = true;
+                        this.isClearingLoader = false;
+                    }
+                });
+            }
+            else {
+                this.isClearingLoader = true;
+            }
+            const name = Object.keys(bundle)[0];
+            this.log(`Loaded '${name}'`);
+            this.loaderEmitter.emit();
+            return componentRef;
+        }
+        catch (ex) {
+            if (isDevMode()) {
+                console.warn("Component " + this._id + " threw an error on mount!");
+                console.warn("This will cause you to see a 404 panel.");
+                console.error(ex);
+            }
+            // Network errors throw a toast and return an error component
+            if (ex && !isDevMode()) {
+                console.error("Uncaught error when loading component");
+                throw ex;
+            }
+            return this.loadDefault();
+        }
+    }
+    ngOnDestroy(clearAll = true) {
+        // unsubscribe from all subscriptions
+        Object.entries(this.outputSubscriptions).forEach(([key, sub]) => {
+            sub.unsubscribe();
+        });
+        this.outputSubscriptions = {};
+        // Clear all things
+        if (clearAll) {
+            this.loaderSub?.unsubscribe();
+        }
+        this.distractorSubscription?.unsubscribe();
+        // Clear target container
+        this.targetRef?.destroy();
+        this.targetComponentContainerRef?.destroy();
+        this.targetContainer?.clear();
+        // Wipe the rest of the state clean
+        this.targetRef = null;
+        this.targetComponentContainerRef = null;
+    }
+    /**
+     * Bind the input values to the child component.
+     */
+    bindInputs() {
+        if (!this._inputs || !this.targetComponentInstance)
+            return;
+        // Merge match groups
+        if (typeof this._matchGroups == "object") {
+            Object.entries(this._matchGroups).forEach(([key, val]) => {
+                if (typeof this._inputs[key] == 'undefined')
+                    this._inputs[key] = val;
+            });
+        }
+        // forward-bind inputs
+        const { inputs } = this.targetComponentFactory.ɵcmp;
+        // Returns a list of entries that need to be set
+        // This makes it so that unnecessary setters are not invoked.
+        const updated = Object.entries(inputs).filter(([parentKey, childKey]) => {
+            return this.targetComponentInstance[childKey] != this._inputs[parentKey];
+        });
+        updated.forEach(([parentKey, childKey]) => {
+            if (this._inputs.hasOwnProperty(parentKey))
+                this.targetComponentInstance[childKey] = this._inputs[parentKey];
+        });
+    }
+    /**
+     * Bind the output handlers to the loaded child component
+     */
+    bindOutputs() {
+        if (!this._outputs || !this.targetComponentInstance)
+            return;
+        const { outputs } = this.targetComponentFactory.ɵcmp;
+        // Get a list of unregistered outputs
+        const newOutputs = Object.entries(outputs).filter(([parentKey, childKey]) => {
+            return !this.outputSubscriptions[parentKey];
+        });
+        // Reverse bind via subscription
+        newOutputs.forEach(([parentKey, childKey]) => {
+            if (this._outputs.hasOwnProperty(parentKey)) {
+                const target = this.targetComponentInstance[childKey];
+                const outputs = this._outputs;
+                // Angular folks, stop making this so difficult.
+                const ctx = this.viewContainerRef['_hostLView'][8];
+                const sub = target.subscribe(outputs[parentKey].bind(ctx)); // Subscription
+                this.outputSubscriptions[parentKey] = sub;
+            }
+        });
+    }
+    /**
+     * Load the "Default" component (404) screen normally.
+     * This is shown when the component id isn't in the
+     * registry or otherwise doesn't match
+     *
+     * This
+     */
+    loadDefault() {
+        if (this.config.notFoundComponent)
+            this.targetContainer.createComponent(this.config.notFoundComponent);
+        this.showLoader = false;
+    }
+    /**
+     * Load the "Error" component.
+     * This is shown when we are able to resolve the component
+     * in the registry, but have some issue boostrapping the
+     * component into the viewContainer
+     */
+    loadError() {
+        if (this.config.errorComponent)
+            this.targetContainer.createComponent(this.config.errorComponent);
+        this.showLoader = false;
+    }
+}
+LazyLoaderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LazyLoaderComponent, deps: [{ token: i1.LazyLoaderService }, { token: i0.ViewContainerRef, optional: true }, { token: i2.DialogRef, optional: true }, { token: MAT_DIALOG_DATA, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+LazyLoaderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: LazyLoaderComponent, isStandalone: true, selector: "ngx-lazy-loader", inputs: { id: ["component", "id"], group: "group", inputs: "inputs", outputs: "outputs" }, outputs: { componentLoadError: "componentLoadError", componentLoaded: "componentLoaded" }, viewQueries: [{ propertyName: "targetContainer", first: true, predicate: ["content"], descendants: true, read: ViewContainerRef }], ngImport: i0, template: "<ng-container #content></ng-container>\n\n<div class=\"ngx-lazy-loader-distractor\" [class.destroying]=\"isClearingLoader\">\n    <ng-container *ngIf=\"config.loaderDistractorComponent\" [ngComponentOutlet]=\"config.loaderDistractorComponent\"></ng-container>\n    <ng-container *ngIf=\"config.loaderDistractorTemplate\" [ngTemplateOutlet]=\"config.loaderDistractorTemplate\" [ngTemplateOutletContext]=\"{ '$implicit': inputs }\"></ng-container>\n</div>\n", styles: [":host{display:contents;contain:content;z-index:1;position:relative}.ngx-lazy-loader-distractor{position:absolute;inset:0;display:flex;align-items:center;justify-content:center;flex-direction:column;background-color:var(--background-color, #212121);opacity:1;transition:opacity .3s ease;z-index:999999}.ngx-lazy-loader-distractor.destroying{opacity:0;pointer-events:none}\n"], dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LazyLoaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngx-lazy-loader', imports: [NgIf, NgComponentOutlet, NgTemplateOutlet], standalone: true, template: "<ng-container #content></ng-container>\n\n<div class=\"ngx-lazy-loader-distractor\" [class.destroying]=\"isClearingLoader\">\n    <ng-container *ngIf=\"config.loaderDistractorComponent\" [ngComponentOutlet]=\"config.loaderDistractorComponent\"></ng-container>\n    <ng-container *ngIf=\"config.loaderDistractorTemplate\" [ngTemplateOutlet]=\"config.loaderDistractorTemplate\" [ngTemplateOutletContext]=\"{ '$implicit': inputs }\"></ng-container>\n</div>\n", styles: [":host{display:contents;contain:content;z-index:1;position:relative}.ngx-lazy-loader-distractor{position:absolute;inset:0;display:flex;align-items:center;justify-content:center;flex-direction:column;background-color:var(--background-color, #212121);opacity:1;transition:opacity .3s ease;z-index:999999}.ngx-lazy-loader-distractor.destroying{opacity:0;pointer-events:none}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.LazyLoaderService }, { type: i0.ViewContainerRef, decorators: [{
+                    type: Optional
+                }] }, { type: i2.DialogRef, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }]; }, propDecorators: { targetContainer: [{
+                type: ViewChild,
+                args: ["content", { read: ViewContainerRef }]
+            }], id: [{
+                type: Input,
+                args: ["component"]
+            }], group: [{
+                type: Input,
+                args: ["group"]
+            }], inputs: [{
+                type: Input,
+                args: ["inputs"]
+            }], outputs: [{
+                type: Input,
+                args: ["outputs"]
+            }], componentLoadError: [{
+                type: Output
+            }], componentLoaded: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lazy-loader.component.js","sourceRoot":"","sources":["../../../../../packages/common/src/components/lazy-loader/lazy-loader.component.ts","../../../../../packages/common/src/components/lazy-loader/lazy-loader.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Input, ViewContainerRef, isDevMode, ComponentRef, EventEmitter, Optional, ViewChild, Component, Inject, Output, NgModule, AfterViewInit, OnInit } from '@angular/core';\nimport { NgComponentOutlet, NgIf, NgTemplateOutlet } from '@angular/common';\nimport { MAT_DIALOG_DATA, } from '@angular/material/dialog';\nimport { DialogRef } from '@angular/cdk/dialog';\nimport { BehaviorSubject, debounceTime, Subscription } from 'rxjs';\nimport { LazyLoaderService } from './lazy-loader.service';\nimport { stringToSlug } from '../../utils';\nimport { CompiledBundle, NgxLazyLoaderConfig } from './types';\n\n\n@Component({\n    selector: 'ngx-lazy-loader',\n    templateUrl: './lazy-loader.component.html',\n    styleUrls: [ './lazy-loader.component.scss' ],\n    imports: [ NgIf, NgComponentOutlet, NgTemplateOutlet ],\n    standalone: true\n})\nexport class LazyLoaderComponent implements AfterViewInit {\n    @ViewChild(\"content\", { read: ViewContainerRef }) targetContainer: ViewContainerRef;\n\n    /**\n     * ! Here be dragons.\n     * Only the bravest of Adventurers can survive the battles below,\n     * and they must be trained and ready for the gruelling journey ahead.\n     * Many a soul has tried to best these Dragons, yet only one has\n     * succeeded since our founding.\n     *\n     * TL;DR -- Don't mess with this unless you know what you're doing.\n     *     This is central to a ton of moving parts -- breaking it will\n     *     cause more collateral damage than you may realize.\n     */\n\n    private _id: string;\n    /**\n     * The id of the component that will be lazy loaded\n     */\n    @Input(\"component\") set id(data: string) {\n        const id = stringToSlug(data);\n\n        // Check if there is a change to the loaded component's id\n        // if it's updated, we destroy and rehydrate the entire container\n        if (this.initialized && this._id != id) {\n            this._id = id;\n            this.ngAfterViewInit();\n        }\n        else {\n            this._id = id;\n        }\n    };\n\n\n    private _group = \"default\";\n    @Input(\"group\") set group(data: string) {\n        const group = stringToSlug(data);\n\n        if (typeof group != \"string\" || !group) return;\n\n        // If the group was updated, retry to bootstrap something into the container.\n        if (this.initialized && this._group != group) {\n            this._group = group;\n\n            this.ngAfterViewInit();\n            return;\n        }\n\n        this._group = group;\n    }\n    get group() { return this._group }\n\n    private _matchGroups: { [key: string]: string };\n    private _inputs: { [key: string]: any; };\n    /**\n     * A map of inputs to bind to the child.\n     * Supports change detection. (May fail on deep JSON changes)\n     *\n     * ```html\n     * <lazy-loader component=\"MyLazyComponent\"\n     *       [inputs]=\"{\n     *          prop1: true,\n     *          prop2: false,\n     *          complex: {\n     *              a: true,\n     *              b: 0\n     *          }\n     *       }\"\n     * >\n     * </lazy-loader>\n     * ```\n     */\n    @Input(\"inputs\") set inputs(data: { [key: string]: any; }) {\n        if (data == undefined) return;\n\n        let previous = this._inputs;\n        this._inputs = data;\n        if (data == undefined)\n            console.trace(data);\n\n        if (this.targetComponentFactory) {\n            const { inputs } = this.targetComponentFactory.ɵcmp;\n\n            const currentKeys = Object.keys(inputs);\n\n            const oldKeys = Object.keys(previous).filter(key => currentKeys.includes(key));\n            const newKeys = Object.keys(data).filter(key => currentKeys.includes(key));\n\n            const removed = oldKeys.filter(key => !newKeys.includes(key));\n\n            // ? perhaps set to null or undefined instead\n            removed.forEach(k => this.targetComponentInstance[k] = null);\n\n            this.bindInputs();\n        }\n    }\n\n\n    private outputSubscriptions: { [key: string]: Subscription; } = {};\n    private _outputs: { [key: string]: Function; };\n    /**\n     * A map of outputs to bind from the child.\n     * Should support change detection.\n     * ```html\n     * <lazy-loader component=\"MyLazyComponent\"\n     *       [outputs]=\"{\n     *           prop3: onOutputFire\n     *       }\"\n     * >\n     * </lazy-loader>\n     * ```\n     */\n    @Input(\"outputs\") set outputs(data: { [key: string]: Function; }) {\n        let previous = this._outputs;\n        this._outputs = data;\n\n        if (this.targetComponentFactory) {\n            const { inputs } = this.targetComponentFactory.ɵcmp;\n\n            const currentKeys = Object.keys(inputs);\n            const removed = Object.keys(previous).filter(key => !currentKeys.includes(key));\n\n            removed.forEach(k => {\n                // Unsubscribe from observable\n                this.outputSubscriptions[k]?.unsubscribe();\n                delete this.targetComponentInstance[k];\n            });\n\n            this.bindOutputs();\n        }\n    }\n\n    /**\n     * Emits errors encountered when loading components\n     */\n    @Output() componentLoadError = new EventEmitter();\n\n    /**\n     * Emits when the component is fully constructed\n     * and had it's inputs and outputs bound\n     * > before `OnInit`\n     *\n     * Returns the active class instance of the lazy-loaded component\n     */\n    @Output() componentLoaded = new EventEmitter();\n\n\n    /**\n     * This is an instance of the component that is currently loaded.\n     */\n    public instance: any;\n\n\n    /**\n     * Container that provides the component data\n     */\n    private targetModule: CompiledBundle;\n\n    /**\n     * Component definition\n     */\n    private targetComponentFactory: any;\n\n    /**\n     * Active component container reference\n     */\n    private targetComponentContainerRef: ComponentRef<any>;\n    private targetRef: any;\n    /**\n     * Reference to the component class instance\n     */\n    private targetComponentInstance: any;\n\n    /**\n     * Subscription with true/false state on whether the distractor should be\n     */\n    private distractorSubscription: Subscription;\n\n    public config: NgxLazyLoaderConfig;\n    private err;\n    private warn;\n    private log;\n\n    // Force 500ms delay before revealing the spinner\n    private loaderEmitter = new EventEmitter();\n    private clearLoader$ = this.loaderEmitter.pipe(debounceTime(300));\n    private loaderSub: Subscription;\n    showLoader = true; // whether we render the DOM for the spinner\n    isClearingLoader = false; // should the spinner start fading out\n\n    constructor(\n        private service: LazyLoaderService,\n        @Optional() private viewContainerRef: ViewContainerRef,\n        @Optional() public dialog: DialogRef,\n        @Optional() @Inject(MAT_DIALOG_DATA) public dialogArguments\n    ) {\n        this.config = LazyLoaderService.config;\n        this.err = LazyLoaderService.config.logger.err;\n        this.warn = LazyLoaderService.config.logger.warn;\n        this.log = LazyLoaderService.config.logger.log;\n\n        // First, check for dialog arguments\n        if (this.dialogArguments) {\n            this.inputs = this.dialogArguments.inputs || this.dialogArguments.data;\n            this.outputs = this.dialogArguments.outputs;\n            this.id = this.dialogArguments.id;\n            this.group = this.dialogArguments.group;\n        }\n\n        this.loaderSub = this.clearLoader$.subscribe(() => {\n            this.showLoader = false;\n        });\n    }\n\n    private initialized = false;\n    async ngAfterViewInit() {\n        this.ngOnDestroy(false);\n        this.isClearingLoader = false;\n        this.showLoader = true;\n\n        this.initialized = true;\n\n        if (!this._id) {\n            this.warn(\"No component was specified!\");\n            return this.loadDefault();\n        }\n\n        try {\n            const _entry = this.service.resolveRegistrationEntry(this._id, this._group);\n            if (!_entry || !_entry.entry) {\n                this.err(`Failed to find Component '${this._id}' in group '${this._group}' in registry!`);\n                return this.loadDefault();\n            }\n\n            const { entry, matchGroups } = _entry;\n            this._matchGroups = matchGroups;\n\n            // Download the \"module\" (the standalone component)\n            const bundle: CompiledBundle = this.targetModule = await entry.load();\n\n\n            // Check if there is some corruption on the bundle.\n            if (!bundle || typeof bundle != 'object' || bundle['__esModule'] as any !== true || bundle.toString() != \"[object Module]\") {\n                this.err(`Failed to load component/module for '${this._id}'! Parsed resource is invalid.`);\n                return this.loadError();\n            }\n\n            const modules = Object.keys(bundle)\n                .map(k => {\n                    const entry = bundle[k];\n\n                    // Strictly check for exported modules or standalone components\n                    if (typeof entry == \"function\" && typeof entry[\"ɵfac\"] == \"function\")\n                        return entry;\n                    return null;\n                })\n                .filter(e => e != null)\n                .filter(entry => {\n                    entry['_isModule'] = !!entry['ɵmod']; // module\n                    entry['_isComponent'] = !!entry['ɵcmp']; // component\n\n                    return (entry['_isModule'] || entry['_isComponent']);\n                });\n\n            if (modules.length == 0) {\n                this.err(`Component/Module loaded for '${this._id}' has no exported components or modules!`);\n                return this.loadError();\n            }\n\n            const component = this.targetComponentFactory = this.service.resolveComponent(this._id, \"default\", modules);\n\n            if (!component) {\n                this.err(`Component '${this._id}' is invalid or corrupted!`);\n                return this.loadError();\n            }\n\n\n            // Bootstrap the component into the container\n            const componentRef = this.targetComponentContainerRef = this.targetContainer.createComponent(component as any);\n            this.targetRef = this.targetContainer.insert(this.targetComponentContainerRef.hostView);\n\n            const instance: any = this.targetComponentInstance = componentRef['instance'];\n\n            this.bindInputs();\n            this.bindOutputs();\n\n            this.componentLoaded.next(instance);\n            this.instance = instance;\n\n            // Look for an observable called isLoading$ that will make us show/hide\n            // the same distractor that is used on basic loading\n            const isLoading$ = instance['ngxShowDistractor$'] as BehaviorSubject<boolean>;\n\n            if (isLoading$ && typeof isLoading$.subscribe == \"function\") {\n                this.distractorSubscription = isLoading$.subscribe(loading => {\n                    if (!loading) {\n                        this.isClearingLoader = true;\n                        this.loaderEmitter.emit();\n                    }\n                    else {\n                        this.showLoader = true;\n                        this.isClearingLoader = false;\n                    }\n                });\n            }\n            else {\n                this.isClearingLoader = true;\n            }\n\n            const name = Object.keys(bundle)[0];\n            this.log(`Loaded '${name}'`);\n            this.loaderEmitter.emit();\n\n            return componentRef;\n        }\n        catch (ex) {\n\n            if (isDevMode()) {\n                console.warn(\"Component \" + this._id + \" threw an error on mount!\");\n                console.warn(\"This will cause you to see a 404 panel.\");\n                console.error(ex);\n            }\n\n            // Network errors throw a toast and return an error component\n            if (ex && !isDevMode()) {\n                console.error(\"Uncaught error when loading component\");\n                throw ex;\n            }\n\n            return this.loadDefault();\n        }\n    }\n\n    ngOnDestroy(clearAll = true) {\n        // unsubscribe from all subscriptions\n        Object.entries(this.outputSubscriptions).forEach(([key, sub]) => {\n            sub.unsubscribe();\n        });\n        this.outputSubscriptions = {};\n\n        // Clear all things\n        if (clearAll) {\n            this.loaderSub?.unsubscribe();\n        }\n\n        this.distractorSubscription?.unsubscribe();\n\n        // Clear target container\n        this.targetRef?.destroy();\n        this.targetComponentContainerRef?.destroy();\n        this.targetContainer?.clear();\n\n        // Wipe the rest of the state clean\n        this.targetRef = null;\n        this.targetComponentContainerRef = null;\n    }\n\n    /**\n     * Bind the input values to the child component.\n     */\n    private bindInputs() {\n        if (!this._inputs || !this.targetComponentInstance) return;\n\n        // Merge match groups\n        if (typeof this._matchGroups == \"object\") {\n            Object.entries(this._matchGroups).forEach(([key, val]) => {\n                if (typeof this._inputs[key] == 'undefined')\n                    this._inputs[key] = val;\n            });\n        }\n\n        // forward-bind inputs\n        const { inputs } = this.targetComponentFactory.ɵcmp;\n\n        // Returns a list of entries that need to be set\n        // This makes it so that unnecessary setters are not invoked.\n        const updated = Object.entries(inputs).filter(([parentKey, childKey]: [string, string]) => {\n            return this.targetComponentInstance[childKey] != this._inputs[parentKey];\n        });\n\n        updated.forEach(([parentKey, childKey]: [string, string]) => {\n            if (this._inputs.hasOwnProperty(parentKey))\n                this.targetComponentInstance[childKey] = this._inputs[parentKey];\n        });\n    }\n\n    /**\n     * Bind the output handlers to the loaded child component\n     */\n    private bindOutputs() {\n        if (!this._outputs || !this.targetComponentInstance) return;\n\n        const { outputs } = this.targetComponentFactory.ɵcmp;\n\n        // Get a list of unregistered outputs\n        const newOutputs = Object.entries(outputs).filter(([parentKey, childKey]: [string, string]) => {\n            return !this.outputSubscriptions[parentKey];\n        });\n\n        // Reverse bind via subscription\n        newOutputs.forEach(([parentKey, childKey]: [string, string]) => {\n            if (this._outputs.hasOwnProperty(parentKey)) {\n                const target: EventEmitter<unknown> = this.targetComponentInstance[childKey];\n                const outputs = this._outputs;\n\n                // Angular folks, stop making this so difficult.\n                const ctx = this.viewContainerRef['_hostLView'][8];\n                const sub = target.subscribe(outputs[parentKey].bind(ctx)); // Subscription\n\n                this.outputSubscriptions[parentKey] = sub;\n            }\n        });\n    }\n\n    /**\n     * Load the \"Default\" component (404) screen normally.\n     * This is shown when the component id isn't in the\n     * registry or otherwise doesn't match\n     *\n     * This\n     */\n    private loadDefault() {\n        if (this.config.notFoundComponent)\n            this.targetContainer.createComponent(this.config.notFoundComponent);\n\n        this.showLoader = false;\n    }\n\n    /**\n     * Load the \"Error\" component.\n     * This is shown when we are able to resolve the component\n     * in the registry, but have some issue boostrapping the\n     * component into the viewContainer\n     */\n    private loadError() {\n        if (this.config.errorComponent)\n            this.targetContainer.createComponent(this.config.errorComponent);\n\n        this.showLoader = false;\n    }\n}\n","<ng-container #content></ng-container>\n\n<div class=\"ngx-lazy-loader-distractor\" [class.destroying]=\"isClearingLoader\">\n    <ng-container *ngIf=\"config.loaderDistractorComponent\" [ngComponentOutlet]=\"config.loaderDistractorComponent\"></ng-container>\n    <ng-container *ngIf=\"config.loaderDistractorTemplate\" [ngTemplateOutlet]=\"config.loaderDistractorTemplate\" [ngTemplateOutletContext]=\"{ '$implicit': inputs }\"></ng-container>\n</div>\n"]}

package/esm2020/components/lazy-loader/lazy-loader.module.mjs

@@ -0,0 +1,29 @@
+import { NgModule } from '@angular/core';
+import { LazyLoaderComponent } from './lazy-loader.component';
+import { LazyLoaderService, NGX_LAZY_LOADER_CONFIG } from './lazy-loader.service';
+import * as i0 from "@angular/core";
+export class LazyLoaderModule {
+    static forRoot(config) {
+        return ({
+            ngModule: LazyLoaderModule,
+            providers: [
+                LazyLoaderService,
+                {
+                    provide: NGX_LAZY_LOADER_CONFIG,
+                    useValue: config
+                }
+            ]
+        });
+    }
+}
+LazyLoaderModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LazyLoaderModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LazyLoaderModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: LazyLoaderModule, imports: [LazyLoaderComponent], exports: [LazyLoaderComponent] });
+LazyLoaderModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LazyLoaderModule, imports: [LazyLoaderComponent] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LazyLoaderModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [LazyLoaderComponent],
+                    exports: [LazyLoaderComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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