@indice/ng-components 0.2.175 → 0.3.1

package/esm2022/lib/pipes/duration-format.pipe.mjs

@@ -0,0 +1,64 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DurationFormatPipe {
+    transform(value, arg1, arg2) {
+        let days;
+        let seconds;
+        let minutes;
+        let hours;
+        if (arg1 === 'ms' && arg2 === 'hhmmss') {
+            seconds = Math.floor((value / 1000) % 60);
+            minutes = Math.floor(((value / (1000 * 60)) % 60));
+            hours = Math.floor((value / (1000 * 60 * 60)));
+            return this.format(arg2, seconds, minutes, hours, days);
+        }
+        else if (arg1 === 's' && arg2 === 'hhmmss') {
+            seconds = Math.floor((value % 60));
+            minutes = Math.floor(((value / 60) % 60));
+            hours = Math.floor(((value / 60) / 60));
+            return this.format(arg2, seconds, minutes, hours, days);
+        }
+        else if (arg1 === 'ms' && (arg2 === 'ddhhmmss' || arg2 === 'ddhhmmssLong')) {
+            seconds = Math.floor(((value / 1000) % 60));
+            minutes = Math.floor((value / (1000 * 60) % 60));
+            hours = Math.floor((value / (1000 * 60 * 60) % 24));
+            days = Math.floor((value / (1000 * 60 * 60 * 24)));
+            return this.format(arg2, seconds, minutes, hours, days);
+        }
+        else if (arg1 === 's' && (arg2 === 'ddhhmmss' || arg2 === 'ddhhmmssLong')) {
+            seconds = Math.floor(value % 60);
+            minutes = Math.floor(((value / 60) % 60));
+            hours = Math.floor(((value / 60) / 60) % 24);
+            days = Math.floor((((value / 60) / 60) / 24));
+            return this.format(arg2, seconds, minutes, hours, days);
+        }
+        else {
+            return value;
+        }
+    }
+    format(arg2, seconds, minutes, hours, days) {
+        (days < 10) ? days = '0' + days : days;
+        (hours < 10) ? hours = '0' + hours : hours;
+        (minutes < 10) ? minutes = '0' + minutes : minutes;
+        (seconds < 10) ? seconds = '0' + seconds : seconds;
+        switch (arg2) {
+            case 'hhmmss':
+                return `${hours}:${minutes}:${seconds}`;
+            case 'ddhhmmss':
+                return `${days}d, ${hours}h, ${minutes}m, ${seconds}s`;
+            case 'ddhhmmssLong':
+                return `${days} days, ${hours} hours, ${minutes} minutes, ${seconds} seconds`;
+        }
+        return undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DurationFormatPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.6", ngImport: i0, type: DurationFormatPipe, name: "durationFormat", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DurationFormatPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'durationFormat',
+                    pure: false
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/pipes/short-number.pipe.mjs

@@ -0,0 +1,43 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ShortNumberPipe {
+    transform(number, args) {
+        if (isNaN(number))
+            return null; // will only work value is a number
+        if (number === null)
+            return null;
+        if (number === 0)
+            return null;
+        let abs = Math.abs(number);
+        const rounder = Math.pow(10, 1);
+        const isNegative = number < 0; // will also work for Negative numbers
+        let key = '';
+        const powers = [
+            { key: 'Q', value: Math.pow(10, 15) },
+            { key: 'T', value: Math.pow(10, 12) },
+            { key: 'B', value: Math.pow(10, 9) },
+            { key: 'M', value: Math.pow(10, 6) },
+            { key: 'K', value: 1000 }
+        ];
+        for (let i = 0; i < powers.length; i++) {
+            let reduced = abs / powers[i].value;
+            reduced = Math.round(reduced * rounder) / rounder;
+            if (reduced >= 1) {
+                abs = reduced;
+                key = powers[i].key;
+                break;
+            }
+        }
+        return (isNegative ? '-' : '') + abs + key;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: ShortNumberPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.6", ngImport: i0, type: ShortNumberPipe, name: "shortNumber", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: ShortNumberPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'shortNumber',
+                    pure: false
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/breadcrumb.service.mjs

@@ -0,0 +1,174 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import { Subject } from 'rxjs';
+import { distinctUntilChanged, filter } from 'rxjs/operators';
+import { BreadcrumbItem } from '../controls/breadcrumb/breadcrumb-item';
+import { SHELL_CONFIG } from '../tokens';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "./utilities.service";
+export class BreadcrumbService {
+    constructor(_router, _utilities, _shellConfig) {
+        this._router = _router;
+        this._utilities = _utilities;
+        this._shellConfig = _shellConfig;
+        this._breadcrumb$ = new Subject();
+        this.breadcrumb = this._breadcrumb$.asObservable();
+        if (_shellConfig?.breadcrumb) {
+            this._defaultHome = this._getDefaultHomeItem();
+            this._router
+                .events
+                .pipe(filter(event => event instanceof NavigationEnd), distinctUntilChanged())
+                .subscribe(_ => {
+                const breadcrumb = [...this._buildBreadcrumb()];
+                this._breadcrumb$.next(breadcrumb);
+            });
+        }
+    }
+    _getDefaultHomeItem() {
+        const routerConfig = this._router.config;
+        const declaredHomeRoutes = routerConfig.filter((route) => route.data?.breadcrumb?.isHome === true);
+        if (declaredHomeRoutes.length > 1) {
+            throw new Error('You can declare only one route as home.');
+        }
+        let homeRoute;
+        if (declaredHomeRoutes.length === 1) {
+            homeRoute = declaredHomeRoutes[0];
+        }
+        else {
+            homeRoute = routerConfig.find((route) => route.path === '');
+            if (!homeRoute) {
+                return undefined;
+            }
+            const redirectionUrl = homeRoute.redirectTo;
+            if (!homeRoute?.data?.breadcrumb?.title && redirectionUrl) {
+                homeRoute = routerConfig.find((route) => route.path === redirectionUrl);
+                if (!homeRoute) {
+                    return undefined;
+                }
+            }
+        }
+        return new BreadcrumbItem(this._getRouteTitle(homeRoute), homeRoute.path || '');
+    }
+    _getRouteTitle(route) {
+        return route?.data?.breadcrumb?.title || route.component?.name.replace('Component', '');
+    }
+    _buildBreadcrumb() {
+        const breadcrumb = [];
+        if (this._defaultHome) {
+            breadcrumb.push(this._defaultHome);
+        }
+        const url = this._router.url;
+        const path = this._utilities.getPathFromUrl(url) || '';
+        const activeRoute = this._findRouteFromUrl(path);
+        const parentRoutes = this._findParentRoutes(activeRoute);
+        breadcrumb.push(...parentRoutes);
+        if (activeRoute && activeRoute?.path !== this._defaultHome?.url) {
+            const routeData = this._getBreadcrumbRouteData(activeRoute);
+            breadcrumb.push(new BreadcrumbItem(this._getRouteTitle(activeRoute), (routeData._fullPath || activeRoute.path || '')));
+        }
+        return breadcrumb.map((route) => {
+            const routeSegments = route.url?.split('/') || [];
+            routeSegments.forEach((segment, index) => {
+                if (segment.startsWith(':')) {
+                    route.url = route.url?.replace(segment, url.split('/')[index + 1]);
+                }
+            });
+            return route;
+        });
+    }
+    _findRouteFromUrl(url) {
+        const urlSegments = url.split('/').filter((segment) => segment !== '');
+        const routerConfig = this._router.config;
+        const flattenedRouterConfig = this._flattenRoutes(routerConfig);
+        const filteredRouterConfig = flattenedRouterConfig.filter((route) => {
+            const routeData = this._getBreadcrumbRouteData(route);
+            return (routeData._fullPath || route.path)?.split('/').length === urlSegments.length;
+        });
+        const route = filteredRouterConfig.find((route) => {
+            const routeData = this._getBreadcrumbRouteData(route);
+            const routeSegments = (routeData._fullPath || route.path)?.split('/') || [];
+            let segmentsMatched = false;
+            for (let i = 0; i < routeSegments.length; i++) {
+                const currentSegment = routeSegments[i];
+                const isDynamicSegment = currentSegment.startsWith(':');
+                if (!isDynamicSegment) {
+                    segmentsMatched = currentSegment === urlSegments[i];
+                }
+            }
+            return segmentsMatched ? route : undefined;
+        });
+        return route;
+    }
+    _findParentRoutes(activeRoute, items = []) {
+        if (!activeRoute) {
+            return [];
+        }
+        const routeData = this._getBreadcrumbRouteData(activeRoute);
+        let urlSegments = (routeData._fullPath || activeRoute.path)?.split('/').filter((segment) => segment !== '') || [];
+        if (urlSegments?.length <= 1) {
+            return [...items];
+        }
+        const previousUrl = urlSegments.slice(0, -1).join('/');
+        const route = this._findRouteFromUrl(previousUrl);
+        if (route) {
+            const routeData = this._getBreadcrumbRouteData(route);
+            if (routeData._level > 0 || (!route.children || route.children.length === 0)) {
+                items.push(new BreadcrumbItem(this._getRouteTitle(route), routeData._fullPath || route.path));
+                this._findParentRoutes(route, [...items]);
+            }
+        }
+        return [...items];
+    }
+    _flattenRoutes(routes, level) {
+        let children = [];
+        level = level || 0;
+        return routes.map((route) => {
+            const routeData = this._getBreadcrumbRouteData(route);
+            routeData._level = level;
+            if (route.children && route.children.length) {
+                route.children.forEach((child) => {
+                    const childRouteData = this._getBreadcrumbRouteData(child);
+                    const routePath = routeData._fullPath || route.path || '';
+                    const childPath = child.path?.endsWith('/') ? child.path.slice(0, -1) : child.path;
+                    childRouteData._fullPath = childPath?.indexOf(routePath) === -1 ? `${routePath}/${childPath}` : childPath;
+                });
+                children = [...children, ...route.children];
+            }
+            return route;
+        }).concat(children.length ? this._flattenRoutes(children, level + 1) : children);
+    }
+    _getBreadcrumbRouteData(route) {
+        if (!route) {
+            throw new Error('No route was found');
+        }
+        if (!route.data?.breadcrumb) {
+            if (!route.data) {
+                route.data = {};
+            }
+            route.data.breadcrumb = new BreadcrumbRouteData(0, false, undefined);
+        }
+        return route.data.breadcrumb;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: BreadcrumbService, deps: [{ token: i1.Router }, { token: i2.UtilitiesService }, { token: SHELL_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: BreadcrumbService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: BreadcrumbService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.UtilitiesService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [SHELL_CONFIG]
+                }] }] });
+export class BreadcrumbRouteData {
+    constructor(_level, isHome, _fullPath) {
+        this._level = _level;
+        this.isHome = isHome;
+        this._fullPath = _fullPath;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"breadcrumb.service.js","sourceRoot":"","sources":["../../../../../projects/ng-components/src/lib/services/breadcrumb.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { Data, NavigationEnd, Route, Router } from '@angular/router';\n\nimport { Observable, Subject } from 'rxjs';\nimport { distinctUntilChanged, filter } from 'rxjs/operators';\nimport { BreadcrumbItem } from '../controls/breadcrumb/breadcrumb-item';\nimport { SHELL_CONFIG } from '../tokens';\nimport { UtilitiesService } from './utilities.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class BreadcrumbService {\n    private _defaultHome: BreadcrumbItem | undefined;\n    private _breadcrumb$: Subject<BreadcrumbItem[]> = new Subject<BreadcrumbItem[]>();\n\n    constructor(\n        private _router: Router,\n        private _utilities: UtilitiesService,\n        @Optional() @Inject(SHELL_CONFIG) public _shellConfig?: any\n    ) {\n        if (_shellConfig?.breadcrumb) {\n            this._defaultHome = this._getDefaultHomeItem();\n            this._router\n                .events\n                .pipe(\n                    filter(event => event instanceof NavigationEnd),\n                    distinctUntilChanged()\n                )\n                .subscribe(_ => {\n                    const breadcrumb = [...this._buildBreadcrumb()];\n                    this._breadcrumb$.next(breadcrumb);\n                });\n        }\n    }\n\n    public breadcrumb: Observable<BreadcrumbItem[]> = this._breadcrumb$.asObservable();\n\n    private _getDefaultHomeItem(): BreadcrumbItem | undefined {\n        const routerConfig = this._router.config;\n        const declaredHomeRoutes = routerConfig.filter((route: Route) => route.data?.breadcrumb?.isHome === true);\n        if (declaredHomeRoutes.length > 1) {\n            throw new Error('You can declare only one route as home.');\n        }\n        let homeRoute: Route | undefined;\n        if (declaredHomeRoutes.length === 1) {\n            homeRoute = declaredHomeRoutes[0];\n        } else {\n            homeRoute = routerConfig.find((route: Route) => route.path === '');\n            if (!homeRoute) {\n                return undefined;\n            }\n            const redirectionUrl = homeRoute.redirectTo;\n            if (!homeRoute?.data?.breadcrumb?.title && redirectionUrl) {\n                homeRoute = routerConfig.find((route: Route) => route.path === redirectionUrl);\n                if (!homeRoute) {\n                    return undefined;\n                }\n            }\n        }\n        return new BreadcrumbItem(this._getRouteTitle(homeRoute), homeRoute.path || '');\n    }\n\n    private _getRouteTitle(route: Route) {\n        return route?.data?.breadcrumb?.title || route.component?.name.replace('Component', '');\n    }\n\n    private _buildBreadcrumb(): BreadcrumbItem[] {\n        const breadcrumb: BreadcrumbItem[] = [];\n        if (this._defaultHome) {\n            breadcrumb.push(this._defaultHome);\n        }\n        const url = this._router.url;\n        const path = this._utilities.getPathFromUrl(url) || '';\n        const activeRoute = this._findRouteFromUrl(path);\n        const parentRoutes = this._findParentRoutes(activeRoute);\n        breadcrumb.push(...parentRoutes);\n        if (activeRoute && activeRoute?.path !== this._defaultHome?.url) {\n            const routeData = this._getBreadcrumbRouteData(activeRoute);\n            breadcrumb.push(new BreadcrumbItem(this._getRouteTitle(activeRoute), (routeData._fullPath || activeRoute.path || '')));\n        }\n        return breadcrumb.map((route: BreadcrumbItem) => {\n            const routeSegments = route.url?.split('/') || [];\n            routeSegments.forEach((segment: string, index: number) => {\n                if (segment.startsWith(':')) {\n                    route.url = route.url?.replace(segment, url.split('/')[index + 1]);\n                }\n            });\n            return route;\n        });\n    }\n\n    private _findRouteFromUrl(url: string): Route | undefined {\n        const urlSegments = url.split('/').filter((segment: string) => segment !== '');\n        const routerConfig = this._router.config;\n        const flattenedRouterConfig = this._flattenRoutes(routerConfig);\n        const filteredRouterConfig = flattenedRouterConfig.filter((route: Route) => {\n            const routeData = this._getBreadcrumbRouteData(route);\n            return (routeData._fullPath || route.path)?.split('/').length === urlSegments.length;\n        });\n        const route = filteredRouterConfig.find((route: Route) => {\n            const routeData = this._getBreadcrumbRouteData(route);\n            const routeSegments = (routeData._fullPath || route.path)?.split('/') || [];\n            let segmentsMatched = false;\n            for (let i = 0; i < routeSegments.length; i++) {\n                const currentSegment = routeSegments[i];\n                const isDynamicSegment = currentSegment.startsWith(':');\n                if (!isDynamicSegment) {\n                    segmentsMatched = currentSegment === urlSegments[i];\n                }\n            }\n            return segmentsMatched ? route : undefined;\n        });\n        return route;\n    }\n\n    private _findParentRoutes(activeRoute: Route | undefined, items: BreadcrumbItem[] = []): BreadcrumbItem[] {\n        if (!activeRoute) {\n            return [];\n        }\n        const routeData = this._getBreadcrumbRouteData(activeRoute);\n        let urlSegments = (routeData._fullPath || activeRoute.path)?.split('/').filter((segment: string) => segment !== '') || [];\n        if (urlSegments?.length <= 1) {\n            return [...items];\n        }\n        const previousUrl = urlSegments.slice(0, -1).join('/');\n        const route = this._findRouteFromUrl(previousUrl);\n        if (route) {\n            const routeData = this._getBreadcrumbRouteData(route);\n            if (routeData._level > 0 || (!route.children || route.children.length === 0)) {\n                items.push(new BreadcrumbItem(this._getRouteTitle(route), routeData._fullPath || route.path));\n                this._findParentRoutes(route, [...items]);\n            }\n        }\n        return [...items];\n    }\n\n    private _flattenRoutes(routes: Route[], level?: number): Route[] {\n        let children: Route[] = [];\n        level = level || 0;\n        return routes.map((route: Route) => {\n            const routeData = this._getBreadcrumbRouteData(route);\n            routeData._level = level!;\n            if (route.children && route.children.length) {\n                route.children.forEach((child: Route) => {\n                    const childRouteData = this._getBreadcrumbRouteData(child);\n                    const routePath = routeData._fullPath || route.path || '';\n                    const childPath = child.path?.endsWith('/') ? child.path.slice(0, -1) : child.path;\n                    childRouteData._fullPath = childPath?.indexOf(routePath) === -1 ? `${routePath}/${childPath}` : childPath;\n                });\n                children = [...children, ...route.children];\n            }\n            return route;\n        }).concat(children.length ? this._flattenRoutes(children, level + 1) : children);\n    }\n\n    private _getBreadcrumbRouteData(route: Route | undefined): BreadcrumbRouteData {\n        if (!route) {\n            throw new Error('No route was found');\n        }\n        if (!route.data?.breadcrumb) {\n            if (!route.data) {\n                route.data = {};\n            }\n            route.data.breadcrumb = new BreadcrumbRouteData(0, false, undefined);\n        }\n        return route.data.breadcrumb;\n    }\n}\n\nexport class BreadcrumbRouteData {\n    constructor(public _level: number, public isHome: boolean, public _fullPath?: string | undefined) { }\n}\n"]}

package/esm2022/lib/services/component-loader/component-loader-options.class.mjs

@@ -0,0 +1,8 @@
+/**
+ * Options passed to {@link ComponentLoader.show}.
+ *
+ * @internal
+ */
+export class ComponentLoaderOptions {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LWxvYWRlci1vcHRpb25zLmNsYXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctY29tcG9uZW50cy9zcmMvbGliL3NlcnZpY2VzL2NvbXBvbmVudC1sb2FkZXIvY29tcG9uZW50LWxvYWRlci1vcHRpb25zLmNsYXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOzs7O0dBSUc7QUFDSCxNQUFNLE9BQU8sc0JBQXNCO0NBdUJsQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFRlbXBsYXRlUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbi8qKlxuICogT3B0aW9ucyBwYXNzZWQgdG8ge0BsaW5rIENvbXBvbmVudExvYWRlci5zaG93fS5cbiAqIFxuICogQGludGVybmFsXG4gKi9cbmV4cG9ydCBjbGFzcyBDb21wb25lbnRMb2FkZXJPcHRpb25zIHtcbiAgLyoqXG4gICAqIFRoZSBjb250ZW50IHRvIGJlIGRyYXduIGluc2lkZSBgPG5nLWNvbnRlbnQ+YCBvZiBgQ29tcG9uZW50TG9hZGVyYCBhdHRhY2hlZCBjb21wb25lbnQuXG5cdCAqIEByZW1hcmtzXG5cdCAqIGBjb250ZW50YCBjYW4gYmUgYENvbXBvbmVudGAgLCBgVGVtcGxhdGVSZWZgIG9yIGBTdHJpbmdgLlxuICAgKi9cbiAgY29udGVudD86IHN0cmluZyB8IFRlbXBsYXRlUmVmPHVua25vd24+O1xuICAvKipcbiAgICogVGhlIGRhdGEgdG8gYmUgcGFzc2VkIHRvIHZpZXcgZm9yIGBUZW1wbGF0ZVJlZmAgY2FzZS5cbiAgICovXG4gIGNvbnRleHQ/OiB1bmtub3duO1xuICAvKipcbiAgICogSW5pdGlhbCBkYXRhIHRvIGJlIHBhc3NlZCB0byBgY29udGVudGAgZm9yIGBDb21wb25lbnRgIGNhc2UuXG4gICAqL1xuICBpbml0aWFsU3RhdGU/OiB1bmtub3duO1xuICAvKipcbiAgICogT3RoZXIgcHJvcGVydGllcyBwYXNzZWQgdG8gYXR0YWNoZWQgY29tcG9uZW50LlxuICAgKi9cbiAgW2tleTogc3RyaW5nXTogdW5rbm93bjtcbiAgLyoqXG4gICAqIGlkYCAtIFRoZSBpZCBvZiB0aGUgYXR0YWNoZWQgY29tcG9uZW50IHJlZi5cbiAgICovXG4gIGlkPzogbnVtYmVyIHwgc3RyaW5nO1xufVxuIl19

package/esm2022/lib/services/component-loader/component-loader.class.mjs

@@ -0,0 +1,188 @@
+import { ElementRef, TemplateRef, Injector, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { ContentRef } from './content-ref.class';
+/**
+ * Provides ways of loading and handling dynamic content.
+ *
+ * @remarks
+ * Do NOT use this directly, create an instance through {@link ComponentLoaderFactory}
+ * You can use this loader in two ways:
+ * - Attaches a component to `ViewContainerRef`.
+ * - Attaches a component to `ViewContainerRef`. The attached component has a `<ng-content>` tag inside its view. The {@link ComponentLoaderOptions.content} will be drawn inside this tag.
+ *
+ * @internal
+ */
+export class ComponentLoader {
+    constructor(vcr, cfr, applicationRef, injector) {
+        this.vcr = vcr;
+        this.cfr = cfr;
+        this.applicationRef = applicationRef;
+        this.injector = injector;
+        /**
+         * Before content is shown event.
+         */
+        this.onBeforeShow = new Subject();
+        /**
+         * After show content event.
+         * @returns The id of newly created component ref.
+         */
+        this.onShown = new Subject();
+        /**
+         * Before content is hidden event.
+         * @returns The instance of attached component;
+         */
+        this.onBeforeHide = new Subject();
+        /**
+         * After content is hidden event.
+         * @returns The id of destroyed component ref.
+         */
+        this.onHidden = new Subject();
+        this.providers = [];
+        this.containerDefaultSelector = 'body';
+    }
+    /**
+     * Attaches component.
+     * @param componentType - The type component to attach.
+     * @returns Current instance of {@link ComponentLoader}
+     */
+    attach(componentType) {
+        this.componentFactory = this.cfr.resolveComponentFactory(componentType);
+        return this;
+    }
+    /**
+     * Body will be used in nothing is provided.
+     * @param container - The element in which dynamic content will be drawn inside to. For string case a query to the dom will be executed to find the element.
+     * @returns Current instance of {@link ComponentLoader}
+     */
+    to(container) {
+        this.container = container || this.container;
+        return this;
+    }
+    /**
+     * Adds provider to the providers array. These providers will be injected to the attached component.
+     *
+     * @see {@link https://angular.io/guide/glossary#di-token | Injection Token}
+     *
+     * @param provider - Provider to inject.
+     * @returns Current instance of {@link ComponentLoader}
+     */
+    provide(provider) {
+        this.providers.push(provider);
+        return this;
+    }
+    /**
+     * Attaches attached component to dom and any dynamic content if provided.
+     * @remarks
+     * Also triggers the {@link ComponentLoader.onBeforeShow} and {@link ComponentLoader.onShown} events.
+     *
+     * @param options - {@link ComponentLoaderOptions}.
+     * @returns A reference to the created content.
+     */
+    show(options = {}) {
+        if (this.componentRef) {
+            throw Error('Component is already shown');
+        }
+        if (!this.componentFactory) {
+            throw Error('You must attach a component');
+        }
+        this.onBeforeShow.next({});
+        if (options.content) {
+            this.contentRef = this.getContentRef(options.content, options.context, options.initialState);
+        }
+        this.createComponentAndAttachToView(options);
+        this.appendContentToContainer();
+        this.markComponentsForCheck();
+        this.onShown.next(options.id);
+        return this.componentRef;
+    }
+    /**
+     * Removes attached component from dom.
+     * @remarks
+     * Also triggers the {@link ComponentLoader.onBeforeHide} and {@link ComponentLoader.onHidden} events.
+     *
+     * @param id - If provided it is returned through the {@link ComponentLoader.onHidden}.
+     * @returns Current instance of {@link ComponentLoader}
+     */
+    hide(id, result) {
+        if (!this.componentRef) {
+            throw Error('No attached component found to hide');
+        }
+        this.onBeforeHide.next(this.componentRef.instance);
+        const componentEl = this.componentRef.location.nativeElement;
+        componentEl.parentNode.removeChild(componentEl);
+        if (this.contentRef?.componentRef) {
+            this.contentRef.componentRef.destroy();
+        }
+        if (this.vcr && this.contentRef?.viewRef) {
+            this.vcr.remove(this.vcr.indexOf(this.contentRef.viewRef));
+        }
+        if (this.contentRef?.viewRef) {
+            this.contentRef.viewRef.destroy();
+        }
+        this.contentRef = void 0;
+        this.componentRef = void 0;
+        this.onHidden.next(id ? { id, result } : null);
+        return this;
+    }
+    getInnerComponent() {
+        return this.innerComponent;
+    }
+    markComponentsForCheck() {
+        if (this.contentRef?.componentRef) {
+            this.innerComponent = this.contentRef.componentRef.instance;
+            this.contentRef.componentRef.changeDetectorRef.markForCheck();
+            this.contentRef.componentRef.changeDetectorRef.detectChanges();
+        }
+        this.componentRef.changeDetectorRef.markForCheck();
+        this.componentRef.changeDetectorRef.detectChanges();
+    }
+    createComponentAndAttachToView(options) {
+        const injector = Injector.create({
+            providers: this.providers,
+            parent: this.injector,
+        });
+        this.componentRef = this.componentFactory.create(injector, this.contentRef?.nodes);
+        this.applicationRef.attachView(this.componentRef.hostView);
+        this.instance = this.componentRef.instance;
+        Object.assign(this.componentRef.instance, options);
+    }
+    appendContentToContainer() {
+        if (this.container instanceof ElementRef) {
+            this.container.nativeElement.appendChild(this.componentRef?.location.nativeElement);
+        }
+        if (typeof this.container === 'string' && typeof document !== 'undefined') {
+            const selectedElement = document.querySelector(this.container) || document.querySelector(this.containerDefaultSelector);
+            if (!selectedElement) {
+                return;
+            }
+            selectedElement.appendChild(this.componentRef?.location.nativeElement);
+        }
+    }
+    getContentRef(content, context, initialState) {
+        //TemplateRef case
+        if (content instanceof TemplateRef) {
+            if (this.vcr) {
+                const viewRef = this.vcr.createEmbeddedView(content, context);
+                viewRef.markForCheck();
+                return new ContentRef([viewRef.rootNodes], viewRef);
+            }
+            const viewRef = content.createEmbeddedView({});
+            this.applicationRef.attachView(viewRef);
+            return new ContentRef([viewRef.rootNodes], viewRef);
+        }
+        //Component case
+        if (typeof content === 'function') {
+            const contentCf = this.cfr.resolveComponentFactory(content);
+            const injector = Injector.create({
+                providers: this.providers,
+                parent: this.injector,
+            });
+            const componentRef = contentCf.create(injector);
+            // Object.assign(componentRef.instance, initialState);
+            this.applicationRef.attachView(componentRef.hostView);
+            return new ContentRef([[componentRef.location.nativeElement]], componentRef.hostView, componentRef);
+        }
+        throw Error('Unsupported content type');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-loader.class.js","sourceRoot":"","sources":["../../../../../../projects/ng-components/src/lib/services/component-loader/component-loader.class.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ComponentFactoryResolver,\n  ViewContainerRef,\n  ComponentFactory,\n  Type,\n  ElementRef,\n  StaticProvider,\n  TemplateRef,\n  ComponentRef,\n  ApplicationRef,\n  Injector,\n} from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { ComponentLoaderOptions } from './component-loader-options.class';\nimport { ContentRef } from './content-ref.class';\n\n/**\n * Provides ways of loading and handling dynamic content.\n *\n * @remarks\n * Do NOT use this directly, create an instance through {@link ComponentLoaderFactory}\n * You can use this loader in two ways:\n * - Attaches a component to `ViewContainerRef`.\n * - Attaches a component to `ViewContainerRef`. The attached component has a `<ng-content>` tag inside its view. The {@link ComponentLoaderOptions.content} will be drawn inside this tag.\n *\n * @internal\n */\nexport class ComponentLoader<T extends object> {\n  /**\n   * Before content is shown event.\n   */\n  onBeforeShow = new Subject();\n  /**\n   * After show content event.\n   * @returns The id of newly created component ref.\n   */\n  onShown = new Subject();\n  /**\n   * Before content is hidden event.\n   * @returns The instance of attached component;\n   */\n  onBeforeHide = new Subject();\n  /**\n   * After content is hidden event.\n   * @returns The id of destroyed component ref.\n   */\n  onHidden = new Subject();\n\n  public instance?: T;\n  public componentRef?: ComponentRef<T>;\n  private componentFactory?: ComponentFactory<T>;\n  private container: string | ElementRef | any;\n  private providers: StaticProvider[] = [];\n  private contentRef?: ContentRef;\n  private containerDefaultSelector = 'body';\n  private innerComponent?: ComponentRef<T>;\n  constructor(\n    private vcr: ViewContainerRef | undefined,\n    private cfr: ComponentFactoryResolver,\n    private applicationRef: ApplicationRef,\n    private injector: Injector\n  ) {}\n\n  /**\n   * Attaches component.\n   * @param componentType - The type component to attach.\n   * @returns Current instance of {@link ComponentLoader}\n   */\n  public attach(componentType: Type<T>): ComponentLoader<T> {\n    this.componentFactory = this.cfr.resolveComponentFactory<T>(componentType);\n    return this;\n  }\n\n  /**\n   * Body will be used in nothing is provided.\n   * @param container - The element in which dynamic content will be drawn inside to. For string case a query to the dom will be executed to find the element.\n   * @returns Current instance of {@link ComponentLoader}\n   */\n  public to(container?: string | ElementRef): ComponentLoader<T> {\n    this.container = container || this.container;\n    return this;\n  }\n\n  /**\n   * Adds provider to the providers array. These providers will be injected to the attached component.\n   *\n   * @see {@link https://angular.io/guide/glossary#di-token | Injection Token}\n   *\n   * @param provider - Provider to inject.\n   * @returns Current instance of {@link ComponentLoader}\n   */\n  public provide(provider: StaticProvider): ComponentLoader<T> {\n    this.providers.push(provider);\n    return this;\n  }\n\n  /**\n   * Attaches attached component to dom and any dynamic content if provided.\n   * @remarks\n   * Also triggers the {@link ComponentLoader.onBeforeShow} and {@link ComponentLoader.onShown} events.\n   *\n   * @param options - {@link ComponentLoaderOptions}.\n   * @returns A reference to the created content.\n   */\n  public show(options: ComponentLoaderOptions = {}): ComponentRef<T> | undefined {\n    if (this.componentRef) {\n      throw Error('Component is already shown');\n    }\n    if (!this.componentFactory) {\n      throw Error('You must attach a component');\n    }\n    this.onBeforeShow.next({});\n\n    if (options.content) {\n      this.contentRef = this.getContentRef(options.content, options.context, options.initialState);\n    }\n    this.createComponentAndAttachToView(options);\n    this.appendContentToContainer();\n    this.markComponentsForCheck();\n\n    this.onShown.next(options.id);\n\n    return this.componentRef;\n  }\n\n  /**\n   * Removes attached component from dom.\n   * @remarks\n   * Also triggers the {@link ComponentLoader.onBeforeHide} and {@link ComponentLoader.onHidden} events.\n   *\n   * @param id - If provided it is returned through the {@link ComponentLoader.onHidden}.\n   * @returns Current instance of {@link ComponentLoader}\n   */\n  public hide(id?: number | string, result?: any): ComponentLoader<T> {\n    if (!this.componentRef) {\n      throw Error('No attached component found to hide');\n    }\n\n    this.onBeforeHide.next(this.componentRef.instance);\n\n    const componentEl = this.componentRef.location.nativeElement;\n    componentEl.parentNode.removeChild(componentEl);\n    if (this.contentRef?.componentRef) {\n      this.contentRef.componentRef.destroy();\n    }\n    if (this.vcr && this.contentRef?.viewRef) {\n      this.vcr.remove(this.vcr.indexOf(this.contentRef.viewRef));\n    }\n    if (this.contentRef?.viewRef) {\n      this.contentRef.viewRef.destroy();\n    }\n    this.contentRef = void 0;\n    this.componentRef = void 0;\n\n    this.onHidden.next(id ? { id, result } : null);\n\n    return this;\n  }\n\n  getInnerComponent(): ComponentRef<T> | undefined {\n    return this.innerComponent;\n  }\n\n  private markComponentsForCheck() {\n    if (this.contentRef?.componentRef) {\n      this.innerComponent = this.contentRef.componentRef.instance;\n      this.contentRef.componentRef.changeDetectorRef.markForCheck();\n      this.contentRef.componentRef.changeDetectorRef.detectChanges();\n    }\n    this.componentRef!.changeDetectorRef.markForCheck();\n    this.componentRef!.changeDetectorRef.detectChanges();\n  }\n\n  private createComponentAndAttachToView(options: ComponentLoaderOptions) {\n    const injector = Injector.create({\n      providers: this.providers,\n      parent: this.injector,\n    });\n    this.componentRef = this.componentFactory!.create(injector, this.contentRef?.nodes);\n    this.applicationRef.attachView(this.componentRef.hostView);\n    this.instance = this.componentRef.instance;\n    Object.assign(this.componentRef.instance, options);\n  }\n\n  private appendContentToContainer() {\n    if (this.container instanceof ElementRef) {\n      this.container.nativeElement.appendChild(this.componentRef?.location.nativeElement);\n    }\n    if (typeof this.container === 'string' && typeof document !== 'undefined') {\n      const selectedElement = document.querySelector(this.container) || document.querySelector(this.containerDefaultSelector);\n      if (!selectedElement) {\n        return;\n      }\n      selectedElement.appendChild(this.componentRef?.location.nativeElement);\n    }\n  }\n\n  private getContentRef(content?: string | TemplateRef<any>, context?: any, initialState?: any): ContentRef {\n    //TemplateRef case\n    if (content instanceof TemplateRef) {\n      if (this.vcr) {\n        const viewRef = this.vcr.createEmbeddedView<TemplateRef<T>>(content, context);\n        viewRef.markForCheck();\n        return new ContentRef([viewRef.rootNodes], viewRef);\n      }\n      const viewRef = content.createEmbeddedView({});\n      this.applicationRef.attachView(viewRef);\n      return new ContentRef([viewRef.rootNodes], viewRef);\n    }\n\n    //Component case\n    if (typeof content === 'function') {\n      const contentCf = this.cfr.resolveComponentFactory(content);\n      const injector = Injector.create({\n        providers: this.providers,\n        parent: this.injector,\n      });\n      const componentRef = contentCf.create(injector);\n      // Object.assign(componentRef.instance, initialState);\n      this.applicationRef.attachView(componentRef.hostView);\n      return new ContentRef([[componentRef.location.nativeElement]], componentRef.hostView, componentRef);\n    }\n\n    throw Error('Unsupported content type');\n  }\n}\n"]}

package/esm2022/lib/services/component-loader/component-loader.factory.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { ComponentLoader } from './component-loader.class';
+import * as i0 from "@angular/core";
+/**
+ * Use to create instances of {@link ComponentLoader}.
+ *
+ * @public
+ */
+export class ComponentLoaderFactory {
+    constructor(componentFactoryResolver, injector, applicationRef) {
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.injector = injector;
+        this.applicationRef = applicationRef;
+    }
+    /**
+     * Returns a new instance of {@link ComponentLoader}
+     * @param viewContainerRef - The view container the dynamic content will be attached to.
+     * @returns A new instance of {@link ComponentLoader}.
+     *
+     * @public
+     */
+    createLoader(viewContainerRef) {
+        return new ComponentLoader(viewContainerRef, this.componentFactoryResolver, this.applicationRef, this.injector);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: ComponentLoaderFactory, deps: [{ token: i0.ComponentFactoryResolver }, { token: i0.Injector }, { token: i0.ApplicationRef }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: ComponentLoaderFactory, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: ComponentLoaderFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i0.ComponentFactoryResolver }, { type: i0.Injector }, { type: i0.ApplicationRef }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LWxvYWRlci5mYWN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctY29tcG9uZW50cy9zcmMvbGliL3NlcnZpY2VzL2NvbXBvbmVudC1sb2FkZXIvY29tcG9uZW50LWxvYWRlci5mYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBNEMsVUFBVSxFQUE4QixNQUFNLGVBQWUsQ0FBQztBQUNqSCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7O0FBRTNEOzs7O0dBSUc7QUFFSCxNQUFNLE9BQU8sc0JBQXNCO0lBQ2pDLFlBQ1Usd0JBQWtELEVBQ2xELFFBQWtCLEVBQ2xCLGNBQThCO1FBRjlCLDZCQUF3QixHQUF4Qix3QkFBd0IsQ0FBMEI7UUFDbEQsYUFBUSxHQUFSLFFBQVEsQ0FBVTtRQUNsQixtQkFBYyxHQUFkLGNBQWMsQ0FBZ0I7SUFDckMsQ0FBQztJQUVKOzs7Ozs7T0FNRztJQUNILFlBQVksQ0FBbUIsZ0JBQW1DO1FBQ2hFLE9BQU8sSUFBSSxlQUFlLENBQUksZ0JBQWdCLEVBQUUsSUFBSSxDQUFDLHdCQUF3QixFQUFFLElBQUksQ0FBQyxjQUFjLEVBQUUsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ3JILENBQUM7OEdBaEJVLHNCQUFzQjtrSEFBdEIsc0JBQXNCLGNBRFQsTUFBTTs7MkZBQ25CLHNCQUFzQjtrQkFEbEMsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBcHBsaWNhdGlvblJlZiwgQ29tcG9uZW50RmFjdG9yeVJlc29sdmVyLCBJbmplY3RhYmxlLCBJbmplY3RvciwgVmlld0NvbnRhaW5lclJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tcG9uZW50TG9hZGVyIH0gZnJvbSAnLi9jb21wb25lbnQtbG9hZGVyLmNsYXNzJztcblxuLyoqXG4gKiBVc2UgdG8gY3JlYXRlIGluc3RhbmNlcyBvZiB7QGxpbmsgQ29tcG9uZW50TG9hZGVyfS5cbiAqXG4gKiBAcHVibGljXG4gKi9cbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXG5leHBvcnQgY2xhc3MgQ29tcG9uZW50TG9hZGVyRmFjdG9yeSB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgY29tcG9uZW50RmFjdG9yeVJlc29sdmVyOiBDb21wb25lbnRGYWN0b3J5UmVzb2x2ZXIsXG4gICAgcHJpdmF0ZSBpbmplY3RvcjogSW5qZWN0b3IsXG4gICAgcHJpdmF0ZSBhcHBsaWNhdGlvblJlZjogQXBwbGljYXRpb25SZWZcbiAgKSB7fVxuXG4gIC8qKlxuICAgKiBSZXR1cm5zIGEgbmV3IGluc3RhbmNlIG9mIHtAbGluayBDb21wb25lbnRMb2FkZXJ9XG4gICAqIEBwYXJhbSB2aWV3Q29udGFpbmVyUmVmIC0gVGhlIHZpZXcgY29udGFpbmVyIHRoZSBkeW5hbWljIGNvbnRlbnQgd2lsbCBiZSBhdHRhY2hlZCB0by5cbiAgICogQHJldHVybnMgQSBuZXcgaW5zdGFuY2Ugb2Yge0BsaW5rIENvbXBvbmVudExvYWRlcn0uXG4gICAqXG4gICAqIEBwdWJsaWNcbiAgICovXG4gIGNyZWF0ZUxvYWRlcjxUIGV4dGVuZHMgb2JqZWN0Pih2aWV3Q29udGFpbmVyUmVmPzogVmlld0NvbnRhaW5lclJlZik6IENvbXBvbmVudExvYWRlcjxUPiB7XG4gICAgcmV0dXJuIG5ldyBDb21wb25lbnRMb2FkZXI8VD4odmlld0NvbnRhaW5lclJlZiwgdGhpcy5jb21wb25lbnRGYWN0b3J5UmVzb2x2ZXIsIHRoaXMuYXBwbGljYXRpb25SZWYsIHRoaXMuaW5qZWN0b3IpO1xuICB9XG59XG4iXX0=