@acorex/platform 1.0.0

package/fesm2022/acorex-platform-common.mjs

@@ -0,0 +1,699 @@
+import { AXPopupModule } from '@acorex/components/popup';
+import { AXDateTimeModule } from '@acorex/core/dateTime';
+import * as i0 from '@angular/core';
+import { Injectable, Injector, ErrorHandler, NgModule, Inject, InjectionToken, inject, APP_INITIALIZER, EventEmitter, Directive, Input, Output, runInInjectionContext, Optional } from '@angular/core';
+import * as i1 from '@ngrx/effects';
+import { createEffect, ofType, EffectsModule } from '@ngrx/effects';
+import * as i2 from '@angular/router';
+import { RouterModule, NavigationEnd } from '@angular/router';
+import { createAction, props, Store } from '@ngrx/store';
+import { switchMap, of, BehaviorSubject, shareReplay } from 'rxjs';
+import { merge } from 'lodash-es';
+import { AXToastService } from '@acorex/components/toast';
+import { filter } from 'rxjs/operators';
+
+const AXPNavigateAction = createAction('[Navigate] Action', props());
+const AXPSignOutAction = createAction('[SignOut] Action');
+const AXPSignInAction = createAction('[SignIn] Action');
+
+class AXPCommonEffects {
+    constructor(actions$, router) {
+        this.actions$ = actions$;
+        this.router = router;
+        this.command$ = createEffect(() => this.actions$.pipe(ofType(AXPNavigateAction), switchMap((action) => {
+            if (Array.isArray(action.payload.commands))
+                this.router.navigate(action.payload.commands, action.payload.extras);
+            else {
+                if (action.payload.commands.toLowerCase().startsWith("http"))
+                    window.open(action.payload.commands, '_blank');
+                else
+                    this.router.navigate([action.payload.commands], action.payload.extras);
+            }
+            return of();
+        })), { dispatch: false });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPCommonEffects, deps: [{ token: i1.Actions }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPCommonEffects }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPCommonEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.Actions }, { type: i2.Router }] });
+
+class AXPErrorHandlerRegistryService {
+    constructor(injector) {
+        this.injector = injector;
+        this.errorHandlers = [];
+    }
+    register(...plugins) {
+        plugins.forEach(t => {
+            const childInjector = Injector.create({ providers: [{ provide: t, useClass: t, deps: [] }], parent: this.injector });
+            const handler = childInjector.get(t);
+            if (handler) {
+                this.errorHandlers.push(handler);
+            }
+        });
+    }
+    get handlers() {
+        return this.errorHandlers;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPErrorHandlerRegistryService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPErrorHandlerRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPErrorHandlerRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+
+class AXPGlobalErrorHandler extends ErrorHandler {
+    constructor(injector, registry) {
+        super();
+        this.injector = injector;
+        this.registry = registry;
+    }
+    handleError(error) {
+        const handleErrorRecursively = (index, error) => {
+            const errorHandlers = this.registry.handlers;
+            if (index < errorHandlers.length) {
+                errorHandlers[index].handleError(error, (err) => {
+                    handleErrorRecursively(index + 1, err);
+                });
+            }
+            else {
+                super.handleError(error); // Fallback to default handler
+            }
+        };
+        if (error.message.startsWith('NG0100')) {
+            //ignore it
+            return;
+        }
+        handleErrorRecursively(0, error);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPGlobalErrorHandler, deps: [{ token: i0.Injector }, { token: AXPErrorHandlerRegistryService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPGlobalErrorHandler, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPGlobalErrorHandler, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: AXPErrorHandlerRegistryService }] });
+
+class AXPCommonModule {
+    static forRoot(configs) {
+        return {
+            ngModule: AXPCommonModule,
+            providers: [
+                ...(configs?.errorHandlers || []),
+                {
+                    provide: 'AXPCommonModuleFactory',
+                    useFactory: (registry) => () => {
+                        registry.register(...(configs?.errorHandlers || []));
+                    },
+                    deps: [AXPErrorHandlerRegistryService],
+                    multi: true
+                }
+            ]
+        };
+    }
+    static forChild(configs) {
+        return {
+            ngModule: AXPCommonModule,
+            providers: [
+                ...(configs?.errorHandlers || []),
+                {
+                    provide: 'AXPCommonModuleFactory',
+                    useFactory: (registry) => () => {
+                        registry.register(...(configs?.errorHandlers || []));
+                    },
+                    deps: [AXPErrorHandlerRegistryService],
+                    multi: true
+                }
+            ]
+        };
+    }
+    /**
+     * @ignore
+     */
+    constructor(instances) {
+        instances.forEach(f => {
+            f();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: AXPCommonModule, imports: [i1.EffectsFeatureModule, AXPopupModule,
+            AXDateTimeModule], exports: [RouterModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPCommonModule, providers: [
+            {
+                provide: ErrorHandler,
+                useClass: AXPGlobalErrorHandler,
+            }
+            // {
+            //   provide: AX_VALIDATION_CONFIG,
+            //   useValue: validationConfig({
+            //     rules: {
+            //       password: {
+            //         rule: 'callback',
+            //         options: {
+            //           validate: (e: any) => {
+            //             const { value } = e;
+            //             const patterns = [/[A-Z]/, /[a-z]/, /\d/, /[!@#$%^&*(),.?":{}|<>]/];
+            //             let conditionsMet = patterns.filter((pattern) => pattern.test(value)).length;
+            //             return /.{8,}/.test(value) && conditionsMet >= 3;
+            //           },
+            //           message: 'Password must be 8+ characters with upper, lower, digit, or symbol.',
+            //           // message: AXTranslator.get('validation.messages.password'),
+            //         }
+            //       },
+            //     },
+            //   }),
+            // },
+        ], imports: [EffectsModule.forFeature([AXPCommonEffects]),
+            AXPopupModule,
+            AXDateTimeModule, RouterModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPCommonModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        EffectsModule.forFeature([AXPCommonEffects]),
+                        AXPopupModule,
+                        AXDateTimeModule,
+                    ],
+                    exports: [RouterModule],
+                    providers: [
+                        {
+                            provide: ErrorHandler,
+                            useClass: AXPGlobalErrorHandler,
+                        }
+                        // {
+                        //   provide: AX_VALIDATION_CONFIG,
+                        //   useValue: validationConfig({
+                        //     rules: {
+                        //       password: {
+                        //         rule: 'callback',
+                        //         options: {
+                        //           validate: (e: any) => {
+                        //             const { value } = e;
+                        //             const patterns = [/[A-Z]/, /[a-z]/, /\d/, /[!@#$%^&*(),.?":{}|<>]/];
+                        //             let conditionsMet = patterns.filter((pattern) => pattern.test(value)).length;
+                        //             return /.{8,}/.test(value) && conditionsMet >= 3;
+                        //           },
+                        //           message: 'Password must be 8+ characters with upper, lower, digit, or symbol.',
+                        //           // message: AXTranslator.get('validation.messages.password'),
+                        //         }
+                        //       },
+                        //     },
+                        //   }),
+                        // },
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['AXPCommonModuleFactory']
+                }] }] });
+
+class AXPTextLogoConfig {
+    constructor(text) {
+        this.text = text;
+    }
+}
+class AXPImageUrlLogoConfig {
+    constructor(url) {
+        this.url = url;
+    }
+}
+class AXPFontIconLogoConfig {
+    constructor(iconClass) {
+        this.iconClass = iconClass;
+    }
+}
+class AXPComponentLogoConfig {
+    constructor(component) {
+        this.component = component;
+    }
+}
+
+const AXP_PLATFORM_CONFIG_TOKEN = new InjectionToken('AXP_PLATFORM_CONFIG_TOKEN', {
+    providedIn: 'root',
+    factory: () => {
+        return AXPPlatformDefaultConfigs;
+    },
+});
+const AXPPlatformDefaultConfigs = {
+    copyright: 'ACoreX @ 2023',
+    title: 'ACoreX Platform',
+    logo: {
+        dark: new AXPTextLogoConfig('ACoreX'),
+        light: new AXPTextLogoConfig('ACoreX'),
+        colored: new AXPTextLogoConfig('ACoreX'),
+    },
+    useLocalData: false,
+    network: {
+        timeOut: 5000,
+    },
+    WEATHER_API_TOKEN: 'a42a02f39881469fa10122949242801',
+};
+function configPlatform(config = AXPPlatformDefaultConfigs) {
+    return merge(AXPPlatformDefaultConfigs, config);
+}
+
+class AXPDataProvider {
+}
+
+const AXP_MENU_LOADER = new InjectionToken('AXP_MENU_LOADER', {
+    providedIn: 'root',
+    factory: () => {
+        return new AXMenuLoaderDefault();
+    },
+});
+class AXMenuLoaderDefault {
+    /**
+     * @ignore
+     */
+    constructor(items = []) {
+        this._items = [
+            {
+                text: 'Menu Item 1',
+                icon: 'fa-solid fa-grid-2',
+                children: [
+                    {
+                        text: 'Sub Menu Item 1',
+                    },
+                    {
+                        text: 'Sub Menu Item 2',
+                    },
+                ],
+            },
+        ];
+        if (items && items.length) {
+            this._items = items;
+        }
+    }
+    currentMenuItem() {
+        throw new Error("Method not implemented.");
+    }
+    getItems(depth) {
+        return of(this._items);
+    }
+}
+
+const AXP_SETTINGS_LOADER = new InjectionToken('AXP_SETTINGS_LOADER', {
+    providedIn: 'root',
+    factory: () => {
+        return new AXPSettingsDefaultLoader();
+    }
+});
+class AXPSettingsDefaultLoader {
+    global$() {
+        return of([]);
+    }
+    user$() {
+        return of([]);
+    }
+}
+
+class AXPSettingsService {
+    constructor() {
+        this.settingsLoader = inject(AXP_SETTINGS_LOADER);
+        this.settingsSubject = new BehaviorSubject([]);
+        this.settings$ = this.settingsSubject.asObservable().pipe(shareReplay(1));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPSettingsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPSettingsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPSettingsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+const INIT_ACTION = '@ngrx/store/init';
+const UPDATE_ACTION = '@ngrx/store/update-reducers';
+const RECUMPUTE_ACTION = '@ngrx/store-devtools/recompute';
+const INIT_EFFECTS_ACTION = '@ngrx/effects/init';
+function syncStateReducer(reducer) {
+    return (state, action) => {
+        let nextState;
+        if (action.type == INIT_EFFECTS_ACTION) {
+            //TODO: replace with storage library
+            const savedState = localStorage.getItem('appState');
+            if (savedState) {
+                const initialState = JSON.parse(savedState);
+                nextState = reducer(initialState, action);
+            }
+            else {
+                nextState = reducer(nextState, action);
+            }
+        }
+        else {
+            nextState = reducer(state, action);
+        }
+        if (![INIT_ACTION, UPDATE_ACTION, RECUMPUTE_ACTION, INIT_EFFECTS_ACTION].includes(action.type) &&
+            Object.keys(state).length > 0) {
+            localStorage.setItem('appState', JSON.stringify(nextState));
+        }
+        return nextState;
+    };
+}
+const metaReducers = [syncStateReducer];
+
+const AXPLoadInitState = createAction('[App] Load State from Storage');
+
+function initializeAppState(store) {
+    return () => {
+        store.dispatch(AXPLoadInitState());
+    };
+}
+class AXPStatePersistenceModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPStatePersistenceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: AXPStatePersistenceModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPStatePersistenceModule, providers: [
+            {
+                provide: APP_INITIALIZER,
+                useFactory: initializeAppState,
+                deps: [Store],
+                multi: true,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPStatePersistenceModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    providers: [
+                        {
+                            provide: APP_INITIALIZER,
+                            useFactory: initializeAppState,
+                            deps: [Store],
+                            multi: true,
+                        },
+                    ]
+                }]
+        }] });
+
+class AXPClipBoardService {
+    constructor() {
+        this.toast = inject(AXToastService);
+    }
+    copy(title, value) {
+        const copyText = document.createElement('input');
+        copyText.type = 'text';
+        copyText.select();
+        copyText.setSelectionRange(0, 99999); // For mobile devices
+        copyText.remove();
+        navigator.clipboard.writeText(value);
+        this.toast.success(`${title} copied!`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPClipBoardService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPClipBoardService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPClipBoardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class AXPRouteUtilityService {
+    constructor(router) {
+        this.router = router;
+        this.routeActiveCache = {};
+        // Subscribe to NavigationEnd events to update the cache
+        this.router.events
+            .pipe(filter((event) => event instanceof NavigationEnd))
+            .subscribe(() => {
+            this.clearRouteCache();
+        });
+    }
+    isRouteActive(item) {
+        const route = item.path;
+        if (!route)
+            return false;
+        // // Check if the result is already cached
+        // if (this.routeActiveCache.hasOwnProperty(route)) {
+        //     return this.routeActiveCache[route];
+        // }
+        // Calculate the route activity
+        const isActive = window.location.pathname.startsWith(route);
+        // Cache the result
+        this.routeActiveCache[route] = isActive;
+        return isActive;
+    }
+    clearRouteCache() {
+        this.routeActiveCache = {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPRouteUtilityService, deps: [{ token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPRouteUtilityService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPRouteUtilityService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i2.Router }] });
+
+class AXPStickyDirective {
+    get isSticky() {
+        return this._isSticky;
+    }
+    set isSticky(v) {
+        this._isSticky = v;
+        this.isStickyChange.emit(v);
+    }
+    constructor(element, renderer, zone, cdr) {
+        this.element = element;
+        this.renderer = renderer;
+        this.zone = zone;
+        this.cdr = cdr;
+        this.isStickyChange = new EventEmitter();
+        this._isSticky = false;
+        this.onParentScroll = () => {
+            this.zone.runOutsideAngular(() => {
+                const scrollPosition = this.parentElement === window ?
+                    window.scrollY :
+                    this.parentElement.scrollTop + this.targetElement.offsetTop;
+                if (scrollPosition >= this.topOffset && !this.isSticky) {
+                    this.stickyClass.split(' ').forEach(c => {
+                        this.renderer.addClass(this.targetElement, c);
+                    });
+                    this.isSticky = true;
+                    this.cdr.markForCheck();
+                }
+                else if (scrollPosition <= this.topOffset && this.isSticky) {
+                    this.stickyClass.split(' ').forEach(c => {
+                        this.renderer.removeClass(this.targetElement, c);
+                    });
+                    this.isSticky = false;
+                    this.cdr.markForCheck();
+                }
+            });
+        };
+    }
+    ngOnInit() {
+        if (this.stickyParent instanceof HTMLElement) {
+            this.parentElement = this.stickyParent;
+        }
+        else {
+            this.parentElement = document.querySelector(this.stickyParent) || window;
+        }
+        this.targetElement = document.querySelector(this.stickyTarget) || this.element.nativeElement;
+        this.topOffset = this.targetElement.offsetTop;
+        this.parentElement.addEventListener('scroll', this.onParentScroll.bind(this));
+    }
+    ngOnDestroy() {
+        this.parentElement.removeEventListener('scroll', this.onParentScroll);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPStickyDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.2", type: AXPStickyDirective, isStandalone: true, selector: "[axpSticky]", inputs: { stickyClass: ["axpSticky", "stickyClass"], stickyParent: "stickyParent", stickyTarget: "stickyTarget" }, outputs: { isStickyChange: "isStickyChange" }, exportAs: ["axpSticky"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPStickyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axpSticky]',
+                    exportAs: 'axpSticky',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }], propDecorators: { stickyClass: [{
+                type: Input,
+                args: ['axpSticky']
+            }], isStickyChange: [{
+                type: Output
+            }], stickyParent: [{
+                type: Input
+            }], stickyTarget: [{
+                type: Input
+            }] } });
+
+class AXPComponentSlotRegistryService {
+    constructor() {
+        this.registry = new Map();
+    }
+    register(slotName, config) {
+        let configs = this.registry.get(slotName) || [];
+        // Check if the component is already registered in this slot
+        const isDuplicate = configs.some(existingConfig => existingConfig.name === config.name);
+        if (!isDuplicate) {
+            configs = [...configs, config]; // Add the new configuration
+            this.registry.set(slotName, configs);
+        }
+    }
+    get(slotName) {
+        return this.registry.get(slotName) || [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPComponentSlotRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPComponentSlotRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPComponentSlotRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class AXPComponentSlotLoaderService {
+    constructor(registryService, injector) {
+        this.registryService = registryService;
+        this.injector = injector;
+    }
+    loadComponent(slotName, viewContainerRef) {
+        const configs = this.registryService.get(slotName);
+        if (configs) {
+            viewContainerRef.clear();
+            configs.forEach(async (config) => {
+                let component;
+                let options = {};
+                if (typeof config.loadComponent === 'function') {
+                    // If component is a function
+                    runInInjectionContext(this.injector, () => {
+                        component = config.loadComponent?.();
+                    });
+                }
+                else if (config.component) {
+                    // If component is a Type
+                    component = config.component;
+                }
+                //
+                if (typeof config.options === 'function') {
+                    // If options is a function
+                    runInInjectionContext(this.injector, () => {
+                        const fun = config.options;
+                        options = fun();
+                    });
+                }
+                else if (config.options) {
+                    // If options is a object
+                    options = config.options;
+                }
+                //
+                if (component != null) {
+                    const componentRef = viewContainerRef.createComponent(component);
+                    Object.assign(componentRef.instance, options);
+                }
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPComponentSlotLoaderService, deps: [{ token: AXPComponentSlotRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPComponentSlotLoaderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPComponentSlotLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: AXPComponentSlotRegistryService }, { type: i0.Injector }] });
+
+class AXPComponentSlotDirective {
+    constructor(dynamicLoaderService, viewContainerRef) {
+        this.dynamicLoaderService = dynamicLoaderService;
+        this.viewContainerRef = viewContainerRef;
+    }
+    ngOnInit() {
+        this.dynamicLoaderService.loadComponent(this.name, this.viewContainerRef);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPComponentSlotDirective, deps: [{ token: AXPComponentSlotLoaderService }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.2", type: AXPComponentSlotDirective, selector: "axp-component-slot", inputs: { name: "name" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPComponentSlotDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'axp-component-slot',
+                }]
+        }], ctorParameters: () => [{ type: AXPComponentSlotLoaderService }, { type: i0.ViewContainerRef }], propDecorators: { name: [{
+                type: Input
+            }] } });
+
+class AXPComponentSlotModule {
+    static forRoot(configs) {
+        return {
+            ngModule: AXPComponentSlotModule,
+            providers: [
+                {
+                    provide: 'AXPComponentSlotModuleFactory',
+                    useFactory: (registry) => () => {
+                        if (configs) {
+                            for (const [key, value] of Object.entries(configs)) {
+                                value.forEach(v => {
+                                    registry.register(key, v);
+                                });
+                            }
+                        }
+                    },
+                    deps: [AXPComponentSlotRegistryService],
+                    multi: true
+                }
+            ]
+        };
+    }
+    static forChild(configs) {
+        return {
+            ngModule: AXPComponentSlotModule,
+            providers: [
+                {
+                    provide: 'AXPComponentSlotModuleFactory',
+                    useFactory: (registry) => () => {
+                        if (configs) {
+                            for (const [key, value] of Object.entries(configs)) {
+                                value.forEach(v => {
+                                    registry.register(key, v);
+                                });
+                            }
+                        }
+                    },
+                    deps: [AXPComponentSlotRegistryService],
+                    multi: true
+                }
+            ]
+        };
+    }
+    /**
+     * @ignore
+     */
+    constructor(instances) {
+        instances?.forEach(f => {
+            f();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPComponentSlotModule, deps: [{ token: 'AXPComponentSlotModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: AXPComponentSlotModule, declarations: [AXPComponentSlotDirective], exports: [AXPComponentSlotDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPComponentSlotModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPComponentSlotModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AXPComponentSlotDirective],
+                    exports: [AXPComponentSlotDirective]
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['AXPComponentSlotModuleFactory']
+                }] }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMenuLoaderDefault, AXPClipBoardService, AXPCommonEffects, AXPCommonModule, AXPComponentLogoConfig, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPDataProvider, AXPErrorHandlerRegistryService, AXPFontIconLogoConfig, AXPGlobalErrorHandler, AXPImageUrlLogoConfig, AXPLoadInitState, AXPNavigateAction, AXPPlatformDefaultConfigs, AXPRouteUtilityService, AXPSettingsService, AXPSignInAction, AXPSignOutAction, AXPStatePersistenceModule, AXPStickyDirective, AXPTextLogoConfig, AXP_MENU_LOADER, AXP_PLATFORM_CONFIG_TOKEN, AXP_SETTINGS_LOADER, configPlatform, initializeAppState, metaReducers, syncStateReducer };
+//# sourceMappingURL=acorex-platform-common.mjs.map