@wavemaker-ai/app-ng-runtime 1.0.0-rc.309

package/runtime/dynamic/fesm2022/index.mjs

@@ -0,0 +1,950 @@
+import * as i0 from '@angular/core';
+import { Injector, Component, Injectable, Inject, CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA, ViewEncapsulation, inject, importProvidersFrom, RendererFactory2, APP_INITIALIZER, LOCALE_ID, provideZoneChangeDetection, enableProdMode, NgModule } from '@angular/core';
+import { isUndefined, isString, isEmpty } from 'lodash-es';
+import { bootstrapApplication, BrowserModule } from '@angular/platform-browser';
+import * as i5 from '@wm/core';
+import { appendScriptToHead, UserDefinedExecutionContext, App, getValidJSON, getWmProjectProperties, _WM_APP_PROJECT, AbstractHttpService, AbstractToasterService, AbstractI18nService, AbstractSpinnerService, AbstractNavigationService, AbstractDialogService, AppDefaults, DynamicComponentRefProvider, PartialRefProvider, CustomWidgetRefProvider, CustomIconsLoaderService, Viewport, setPreviewProperties } from '@wm/core';
+import * as i4 from '@wm/runtime/base';
+import { ComponentType, BasePageComponent, EmptyPageComponent, PrefabPreviewComponent, CanDeactivatePageGuard, CustomwidgetConfigProvider, AppJSProvider, AppVariablesProvider, AppExtensionProvider, getPrefabPartialJsonUrl, getPrefabMinJsonUrl, REQUIRED_MODULES_FOR_DYNAMIC_COMPONENTS, AccessrolesDirective, AppSpinnerComponent, CustomToasterComponent, AppComponent, PrefabDirective, BaseCustomWidgetComponent, BasePrefabComponent, BasePartialComponent, ComponentRefProvider, AppManagerService, PrefabConfigProvider, getPrefabConfigUrl, HttpCallInterceptor, WMDomRendererFactory2, AppRef, ToasterServiceImpl, I18nServiceImpl, SpinnerServiceImpl, NavigationServiceImpl, AppDefaultsService, DynamicComponentRefProviderService, WmRouteReuseStrategy, PipeService, PrefabManagerService, AuthGuard, RoleGuard, PageNotFoundGuard, AppJSResolve, AppVariablesResolve, AppExtensionJSResolve, I18nResolve, AppBeforeLoadResolve, MAX_CACHE_SIZE, MAX_CACHE_AGE, WM_MODULES_FOR_ROOT } from '@wm/runtime/base';
+import * as i1 from '@angular/router';
+import { ActivatedRoute, RouteReuseStrategy, provideRouter, withHashLocation, withComponentInputBinding, RouterModule } from '@angular/router';
+import * as i1$1 from '@angular/common/http';
+import { HTTP_INTERCEPTORS, HttpXhrBackend, provideHttpClient, withInterceptorsFromDi, withXsrfConfiguration, HttpClientXsrfModule, HttpClientModule } from '@angular/common/http';
+import { provideAnimations, BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import * as i2 from '@wm/variables';
+import { VariablesService, MetadataService } from '@wm/variables';
+import * as i3 from '@wm/security';
+import { SecurityService } from '@wm/security';
+import { HttpServiceImpl } from '@wm/http';
+import { OAuthService } from '@wm/oAuth';
+import { ToastNoAnimationModule } from 'ngx-toastr';
+import { ModalModule } from 'ngx-bootstrap/modal';
+import { BsDatepickerModule } from 'ngx-bootstrap/datepicker';
+import { NgCircleProgressModule } from 'ng-circle-progress';
+import { CommonModule, XhrFactory, DecimalPipe, Location, DatePipe } from '@angular/common';
+import { __decorate, __param, __metadata } from 'tslib';
+import { scopeComponentStyles, transpile } from '@wm/transpiler';
+import * as customWidgets from '@wavemaker-ai/custom-widgets-m3';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { PageDirective, LayoutDirective, ContentComponent, PageContentComponent, SpaPageDirective, RouterOutletDirective } from '@wm/components/page';
+import { PartialDirective, DialogServiceImpl, SanitizePipe, ToDatePipe, FilterPipe, TrailingZeroDecimalPipe, TrustAsPipe, ImagePipe, CustomPipe } from '@wm/components/base';
+import { ProgressBarComponent } from '@wm/components/basic/progress/progress-bar';
+import { PrefabContainerDirective, PrefabDirective as PrefabDirective$1 } from '@wm/components/prefab';
+import { TypeaheadModule } from 'ngx-bootstrap/typeahead';
+import { TimepickerModule } from 'ngx-bootstrap/timepicker';
+import { ProgressbarModule } from 'ngx-bootstrap/progressbar';
+import { PaginationModule } from 'ngx-bootstrap/pagination';
+import { TooltipModule } from 'ngx-bootstrap/tooltip';
+import { BsDropdownModule } from 'ngx-bootstrap/dropdown';
+import { PopoverModule } from 'ngx-bootstrap/popover';
+import { CarouselModule } from 'ngx-bootstrap/carousel';
+import { AnchorComponent } from '@wm/components/basic/anchor';
+import { AudioComponent } from '@wm/components/basic/audio';
+import { HtmlDirective } from '@wm/components/basic/html';
+import { IconComponent } from '@wm/components/basic/icon';
+import { IframeComponent } from '@wm/components/basic/iframe';
+import { LabelDirective } from '@wm/components/basic/label';
+import { PictureDirective } from '@wm/components/basic/picture';
+import { SpinnerComponent } from '@wm/components/basic/spinner';
+import { VideoComponent } from '@wm/components/basic/video';
+import { ProgressCircleComponent } from '@wm/components/basic/progress/progress-circle';
+import { RichTextEditorComponent } from '@wm/components/basic/rich-text-editor';
+import { SearchComponent, ScrollableDirective } from '@wm/components/basic/search';
+import { TreeComponent } from '@wm/components/basic/tree';
+import { ButtonComponent } from '@wm/components/input/button';
+import { ButtonGroupDirective } from '@wm/components/input/button-group';
+import { CaptionPositionDirective } from '@wm/components/input/caption-position';
+import { CheckboxComponent } from '@wm/components/input/checkbox';
+import { CheckboxsetComponent } from '@wm/components/input/checkboxset';
+import { CompositeDirective } from '@wm/components/input/composite';
+import { NumberComponent } from '@wm/components/input/number';
+import { RadiosetComponent } from '@wm/components/input/radioset';
+import { SelectComponent } from '@wm/components/input/select';
+import { SwitchComponent } from '@wm/components/input/switch';
+import { InputCalendarComponent, InputColorComponent, InputEmailComponent, InputNumberComponent, InputTextComponent } from '@wm/components/input/text';
+import { TextareaComponent } from '@wm/components/input/textarea';
+import { CalendarComponent } from '@wm/components/input/calendar';
+import { ChipsComponent } from '@wm/components/input/chips';
+import { ColorPickerComponent } from '@wm/components/input/color-picker';
+import { CurrencyComponent } from '@wm/components/input/currency';
+import { DateComponent } from '@wm/components/input/epoch/date';
+import { DatetimeComponent } from '@wm/components/input/epoch/date-time';
+import { TimeComponent } from '@wm/components/input/epoch/time';
+import { DateTimePickerComponent, TimePickerComponent } from '@wm/components/input/epoch/date-time-picker';
+import { PickerComponent, PickerGroupComponent } from '@wm/components/input/epoch/picker';
+import { FileUploadComponent } from '@wm/components/input/file-upload';
+import { RatingComponent } from '@wm/components/input/rating';
+import { SliderComponent } from '@wm/components/input/slider';
+import { CardComponent, CardActionsDirective, CardContentComponent, CardFooterDirective } from '@wm/components/data/card';
+import { FormComponent, FormWidgetDirective, FormActionDirective, FormFieldDirective, LiveActionsDirective, DependsonDirective, LiveFilterDirective, LiveFormDirective } from '@wm/components/data/form';
+import { ListComponent, ListItemDirective } from '@wm/components/data/list';
+import { LiveTableComponent } from '@wm/components/data/live-table';
+import { PaginationComponent } from '@wm/components/data/pagination';
+import { TableComponent, TableCUDDirective, TableFilterSortDirective, TableActionDirective, TableColumnDirective, TableColumnGroupDirective, TableRowDirective, TableRowActionDirective } from '@wm/components/data/table';
+import { ChartComponent } from '@wm/components/chart';
+import { AccordionPaneComponent, AccordionDirective } from '@wm/components/containers/accordion';
+import { LinearLayoutDirective, LinearLayoutItemDirective } from '@wm/components/containers/linear-layout';
+import { LayoutgridDirective, LayoutGridRowDirective, LayoutGridColumnDirective } from '@wm/components/containers/layout-grid';
+import { PanelComponent } from '@wm/components/containers/panel';
+import { TabPaneComponent, TabsComponent } from '@wm/components/containers/tabs';
+import { TileDirective } from '@wm/components/containers/tile';
+import { WizardActionDirective, WizardStepComponent, WizardComponent } from '@wm/components/containers/wizard';
+import { AlertDialogComponent } from '@wm/components/dialogs/alert-dialog';
+import { IframeDialogComponent } from '@wm/components/dialogs/iframe-dialog';
+import { LoginDialogDirective } from '@wm/components/dialogs/login-dialog';
+import { PartialDialogComponent } from '@wm/components/dialogs/partial-dialog';
+import { BreadcrumbComponent } from '@wm/components/navigation/breadcrumb';
+import { MenuComponent, MenuDropdownComponent, MenuDropdownItemComponent, NavigationControlDirective, NavComponent, NavItemDirective } from '@wm/components/navigation/menu';
+import { NavbarComponent } from '@wm/components/navigation/navbar';
+import { PopoverComponent } from '@wm/components/navigation/popover';
+import { CarouselDirective, CarouselTemplateDirective } from '@wm/components/advanced/carousel';
+import { LoginComponent } from '@wm/components/advanced/login';
+import { MarqueeDirective } from '@wm/components/advanced/marquee';
+import { CustomWidgetDirective, CustomWidgetContainerDirective } from '@wm/components/advanced/custom';
+import { FooterDirective } from '@wm/components/page/footer';
+import { HeaderComponent } from '@wm/components/page/header';
+import { LeftPanelDirective } from '@wm/components/page/left-panel';
+import { RightPanelDirective } from '@wm/components/page/right-panel';
+import { TopNavDirective } from '@wm/components/page/top-nav';
+
+class PageWrapperComponent {
+    constructor(injector, envInjector, route, vcRef, appRef, metadataService, securityService, appManager, app, ngZone, elRef, spinnerService, componentRefProvider, router) {
+        this.injector = injector;
+        this.envInjector = envInjector;
+        this.route = route;
+        this.vcRef = vcRef;
+        this.appRef = appRef;
+        this.metadataService = metadataService;
+        this.securityService = securityService;
+        this.appManager = appManager;
+        this.app = app;
+        this.ngZone = ngZone;
+        this.elRef = elRef;
+        this.spinnerService = spinnerService;
+        this.componentRefProvider = componentRefProvider;
+        this.router = router;
+    }
+    getTargetNode() {
+        return this.elRef.nativeElement;
+    }
+    resetViewContainer() {
+        this.vcRef.clear();
+        const $target = this.getTargetNode();
+        $target.innerHTML = '';
+    }
+    renderPage(pageName) {
+        const $target = this.getTargetNode();
+        this.appManager.loadAppVariables()
+            .then(async () => {
+            const PageComponentClass = await this.componentRefProvider.getComponentFactoryRef(pageName, ComponentType.PAGE);
+            if (!PageComponentClass) {
+                console.error(`Failed to load page component: ${pageName}`);
+                BasePageComponent.clear();
+                return;
+            }
+            try {
+                // Create a child injector that explicitly provides the route-specific
+                // ActivatedRoute from PageWrapperComponent. This ensures dynamically
+                // created page components get the correct ActivatedRoute with proper
+                // queryParams, rather than a root-level ActivatedRoute.
+                const childInjector = Injector.create({
+                    providers: [
+                        { provide: ActivatedRoute, useValue: this.route }
+                    ],
+                    parent: this.injector
+                });
+                const componentRef = this.vcRef.createComponent(PageComponentClass, {
+                    index: 0,
+                    environmentInjector: this.envInjector,
+                    injector: childInjector
+                });
+                this.instance = componentRef.instance;
+                $target.appendChild(componentRef.location.nativeElement);
+                // Clean up any duplicate component instances
+                if (this.vcRef.length > 1) {
+                    this.vcRef.remove(1);
+                }
+            }
+            catch (error) {
+                console.error(`Error creating page component ${pageName}:`, error);
+                BasePageComponent.clear();
+            }
+        })
+            .catch(error => {
+            console.error(`Error loading app variables for page ${pageName}:`, error);
+            BasePageComponent.clear();
+        });
+    }
+    renderPrefabPreviewPage() {
+        this.router.navigate(['prefab-preview']);
+    }
+    loadPage(pageName) {
+        this.ngZone.run(() => {
+            if (pageName) {
+                this.renderPage(pageName);
+            }
+        });
+    }
+    ngOnInit() {
+        if (this.app.isPrefabType) {
+            // there is only one route
+            this.renderPrefabPreviewPage();
+        }
+        else {
+            $(this.getTargetNode()).find('>div').first().remove();
+            this.subscription = this.route.params.subscribe(({ pageName }) => {
+                this.loadPage(pageName);
+            });
+        }
+    }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Clear ViewContainerRef to destroy dynamically created components
+        this.vcRef.clear();
+        // MEMORY LEAK FIX: Unsubscribe from route params subscription
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+            this.subscription = null;
+        }
+        // MEMORY LEAK FIX: Clear instance reference
+        this.instance = null;
+    }
+    ngOnAttach() {
+        this.getTargetNode().appendChild(this.instance.$page[0]);
+        this.instance.ngOnAttach();
+    }
+    ngOnDetach() {
+        this.instance.ngOnDetach();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: PageWrapperComponent, deps: [{ token: i0.Injector }, { token: i0.EnvironmentInjector }, { token: i1.ActivatedRoute }, { token: i0.ViewContainerRef }, { token: i0.ApplicationRef }, { token: i2.MetadataService }, { token: i3.SecurityService }, { token: i4.AppManagerService }, { token: i5.App }, { token: i0.NgZone }, { token: i0.ElementRef }, { token: i5.AbstractSpinnerService }, { token: i4.ComponentRefProvider }, { token: i1.Router }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.19", type: PageWrapperComponent, isStandalone: true, selector: "app-page-outlet", ngImport: i0, template: '<div></div>', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: PageWrapperComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    selector: 'app-page-outlet',
+                    template: '<div></div>'
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.EnvironmentInjector }, { type: i1.ActivatedRoute }, { type: i0.ViewContainerRef }, { type: i0.ApplicationRef }, { type: i2.MetadataService }, { type: i3.SecurityService }, { type: i4.AppManagerService }, { type: i5.App }, { type: i0.NgZone }, { type: i0.ElementRef }, { type: i5.AbstractSpinnerService }, { type: i4.ComponentRefProvider }, { type: i1.Router }] });
+
+const routes = [
+    {
+        path: '',
+        pathMatch: 'full',
+        component: EmptyPageComponent
+    },
+    {
+        path: 'prefab-preview',
+        pathMatch: 'full',
+        component: PrefabPreviewComponent
+    },
+    {
+        path: ':pageName',
+        pathMatch: 'full',
+        component: PageWrapperComponent,
+        canDeactivate: [CanDeactivatePageGuard]
+    }
+];
+
+const cache$2 = new Map();
+class CustomwidgetConfigProviderService extends CustomwidgetConfigProvider {
+    constructor() {
+        super();
+    }
+    getConfig(widgetname) {
+        return new Promise((res, rej) => {
+            Promise.resolve(window['resourceCache'].get(`./custom-widgets/${widgetname}/page.min.json`)).then((pageInfo) => {
+                res(pageInfo.config);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: CustomwidgetConfigProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: CustomwidgetConfigProviderService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: CustomwidgetConfigProviderService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class AppJSProviderService extends AppJSProvider {
+    constructor($http) {
+        super();
+        this.$http = $http;
+    }
+    getAppScriptFn() {
+        return this.$http.get('./app.js', { responseType: 'text' })
+            .toPromise()
+            .then(script => new Function('App', 'Utils', 'Injector', script));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AppJSProviderService, deps: [{ token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AppJSProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AppJSProviderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1$1.HttpClient }] });
+
+const cache$1 = new Map();
+class AppResourceManagerService {
+    get(url, useCache) {
+        const cachedResponse = cache$1.get(url);
+        if (cachedResponse) {
+            return Promise.resolve(cachedResponse);
+        }
+        return this.$http.get(url).then(response => {
+            if (useCache) {
+                cache$1.set(url, response);
+            }
+            return response;
+        });
+    }
+    clearCache() {
+        cache$1.clear();
+    }
+    constructor($http) {
+        this.$http = $http;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AppResourceManagerService, deps: [{ token: i5.AbstractHttpService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AppResourceManagerService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AppResourceManagerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i5.AbstractHttpService }] });
+
+class AppVariablesProviderService extends AppVariablesProvider {
+    constructor(resourceManager, app) {
+        super();
+        this.resourceManager = resourceManager;
+        this.app = app;
+    }
+    async getAppVariables() {
+        // if prefab return {} - app variables will be empty for prefabs
+        return this.app.isPrefabType ? {} : this.resourceManager.get('./app.variables.json');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AppVariablesProviderService, deps: [{ token: AppResourceManagerService }, { token: i5.App }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AppVariablesProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AppVariablesProviderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: AppResourceManagerService }, { type: i5.App }] });
+
+class AppExtensionProviderService extends AppExtensionProvider {
+    // With renderer create element, added onloaded callback the append to the body
+    loadFormatterConfigScript(callback) {
+        try {
+            appendScriptToHead(callback);
+        }
+        catch (e) {
+            console.warn('Error while loading the formatters.js file');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AppExtensionProviderService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AppExtensionProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AppExtensionProviderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+// ==================== Caches ====================
+const fragmentCache = new Map();
+const componentCache = new Map([
+    [ComponentType.PAGE, new Map()],
+    [ComponentType.PARTIAL, new Map()],
+    [ComponentType.PREFAB, new Map()],
+    [ComponentType.WIDGET, new Map()]
+]);
+const scriptCache = new Map();
+window.resourceCache = fragmentCache;
+// ==================== Utilities ====================
+const decode = (str) => {
+    try {
+        return decodeURIComponent(str.replace(/\+/g, ' '));
+    }
+    catch {
+        return str;
+    }
+};
+const getUrl = (name, type, options) => {
+    if (type === ComponentType.PAGE || type === ComponentType.PARTIAL) {
+        return options?.prefab ? getPrefabPartialJsonUrl(options.prefab, name) : `./pages/${name}/page.min.json`;
+    }
+    return type === ComponentType.PREFAB ? getPrefabMinJsonUrl(name) : `./custom-widgets/${name}/page.min.json`;
+};
+const execScript = (script, id, ctx, instance, app, utils) => {
+    let fn = scriptCache.get(id);
+    if ((ctx === 'Partial' && !isUndefined(instance.Prefab)) || !fn) {
+        fn = new Function(ctx, 'App', 'Utils', script);
+        scriptCache.set(id, fn);
+    }
+    fn(instance, app, utils);
+};
+// ==================== Component Imports ====================
+const IMPORTS = [
+    ...REQUIRED_MODULES_FOR_DYNAMIC_COMPONENTS, CommonModule, FormsModule, ReactiveFormsModule,
+    PartialDirective, PageDirective, AccessrolesDirective, AppSpinnerComponent, CustomToasterComponent,
+    AppComponent, PrefabDirective, PrefabPreviewComponent, EmptyPageComponent, LayoutDirective,
+    ContentComponent, PageContentComponent, SpaPageDirective, RouterOutletDirective,
+    ProgressBarComponent, PrefabContainerDirective
+];
+// ==================== Component Factory ====================
+const CONFIG_MAP = {
+    [ComponentType.PAGE]: { Base: BasePageComponent, prefix: 'app-page-', ctx: 'Page' },
+    [ComponentType.PARTIAL]: { Base: BasePartialComponent, prefix: 'app-partial-', ctx: 'Partial' },
+    [ComponentType.PREFAB]: { Base: BasePrefabComponent, prefix: 'app-prefab-', ctx: 'Prefab' },
+    [ComponentType.WIDGET]: { Base: BaseCustomWidgetComponent, prefix: 'app-custom-', ctx: 'Widget' }
+};
+const createComponent = (name, type, template, css, script, variables) => {
+    const { Base, prefix, ctx } = CONFIG_MAP[type];
+    const selector = prefix + name;
+    let DynamicComponent = class DynamicComponent extends Base {
+        constructor(injector) {
+            super();
+            this.injector = injector;
+            this.isDynamicComponent = true;
+            this.injector = injector;
+            // Set component name based on type
+            if (type === ComponentType.PAGE)
+                this.pageName = name;
+            else if (type === ComponentType.PARTIAL)
+                this.partialName = name;
+            else if (type === ComponentType.PREFAB)
+                this.prefabName = name;
+            else if (type === ComponentType.WIDGET)
+                this.customWidgetName = name;
+            super.init();
+        }
+        evalUserScript(instance, app, utils) {
+            execScript(script, selector, ctx, instance, app, utils);
+        }
+        getVariables() {
+            try {
+                return JSON.parse(variables) || {};
+            }
+            catch {
+                return {};
+            }
+        }
+        getExpressions() {
+            return {};
+        }
+    };
+    DynamicComponent = __decorate([
+        __param(0, Inject(Injector)),
+        __metadata("design:paramtypes", [Injector])
+    ], DynamicComponent);
+    return Component({
+        template,
+        styles: [css],
+        encapsulation: ViewEncapsulation.None,
+        selector,
+        standalone: true,
+        imports: [...IMPORTS],
+        providers: [{ provide: UserDefinedExecutionContext, useExisting: DynamicComponent }],
+        schemas: [CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA]
+    })(DynamicComponent);
+};
+// ==================== Service ====================
+class ComponentRefProviderService extends ComponentRefProvider {
+    constructor() {
+        super();
+        this.cache = new Map();
+        this.app = inject(App);
+        this.appManager = inject(AppManagerService);
+        this.resourceMngr = inject(AppResourceManagerService);
+    }
+    /**
+     * Load component fragment (markup, script, styles, variables) from JSON resources
+     * Fetches and processes .min.json files for pages, partials, prefabs, and widgets
+     *
+     * @param name - Component name
+     * @param type - Component type (PAGE, PARTIAL, PREFAB, WIDGET)
+     * @param options - Additional options (e.g., prefab context)
+     * @returns Promise resolving to processed component definition
+     * @throws Error with user-friendly message if loading fails (404, 403, etc.)
+     * @private
+     */
+    async loadFragment(name, type, options) {
+        const url = getUrl(name, type, options);
+        // Return cached promise if already loading/loaded
+        if (fragmentCache.has(url)) {
+            return fragmentCache.get(url);
+        }
+        // Create loading promise
+        const loadPromise = (async () => {
+            try {
+                // Determine if we need to fetch from server or use bundled custom widgets
+                const shouldFetch = type === ComponentType.WIDGET && !customWidgets[name];
+                const rawData = shouldFetch || type !== ComponentType.WIDGET
+                    ? await this.resourceMngr.get(url, true)
+                    : customWidgets[name];
+                // Process and return component definition
+                return {
+                    markup: transpile(decode(rawData.markup)).markup,
+                    script: decode(rawData.script),
+                    styles: scopeComponentStyles(name, type, decode(rawData.styles)),
+                    variables: getValidJSON(decode(rawData.variables)),
+                    ...(rawData.config && { config: getValidJSON(decode(rawData.config)) })
+                };
+            }
+            catch (err) {
+                // Provide user-friendly error messages
+                const status = err?.details?.status;
+                const errorMessages = {
+                    404: this.app.appLocale?.MESSAGE_PAGE_NOT_FOUND || 'Page not available',
+                    403: this.app.appLocale?.LABEL_ACCESS_DENIED || 'Access Denied'
+                };
+                throw errorMessages[status] || 'Unknown error loading component';
+            }
+        })();
+        // Cache the promise to prevent duplicate requests
+        fragmentCache.set(url, loadPromise);
+        return loadPromise;
+    }
+    /**
+     * Get component class by loading and compiling from JSON resources
+     * Loads page/partial/prefab/widget definitions from .min.json files and creates standalone components
+     *
+     * @param name - Component name (e.g., 'Main', 'Header')
+     * @param type - Component type (PAGE, PARTIAL, PREFAB, WIDGET)
+     * @param options - Additional options (e.g., prefab context for partials)
+     * @returns Promise resolving to component Type or undefined if loading fails
+     */
+    async getComponentFactoryRef(name, type, options) {
+        const cacheKey = options?.prefab ? `${options.prefab}${name}` : name;
+        const fullKey = `${type}-${cacheKey}`;
+        // Check component cache (by type and name)
+        const typeCache = componentCache.get(type);
+        if (typeCache?.has(cacheKey)) {
+            return typeCache.get(cacheKey);
+        }
+        // Check full cache (by full key)
+        if (this.cache.has(fullKey)) {
+            return this.cache.get(fullKey);
+        }
+        try {
+            // Load component definition from JSON file
+            const { markup, script, styles, variables } = await this.loadFragment(name, type, options);
+            // Create standalone component class from definition
+            const ComponentClass = createComponent(name, type, markup, styles, script, JSON.stringify(variables));
+            // Store in both caches for fast lookup
+            this.cache.set(fullKey, ComponentClass);
+            typeCache?.set(cacheKey, ComponentClass);
+            return ComponentClass;
+        }
+        catch (err) {
+            const errorMsg = isString(err) ? err : 'Error loading component, check console';
+            console.error(`Failed to load ${type} component '${name}':`, err);
+            this.appManager.notifyApp(errorMsg, 'error');
+            return undefined;
+        }
+    }
+    clearComponentFactoryRefCache() {
+        this.resourceMngr.clearCache();
+        fragmentCache.clear();
+        this.cache.clear();
+        componentCache.forEach(m => m.clear());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: ComponentRefProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: ComponentRefProviderService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: ComponentRefProviderService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+const cache = new Map();
+class PrefabConfigProviderService extends PrefabConfigProvider {
+    constructor(resourceMngr) {
+        super();
+        this.resourceMngr = resourceMngr;
+    }
+    getConfig(prefabName) {
+        const config = cache.get(prefabName);
+        if (config) {
+            return Promise.resolve(config);
+        }
+        return this.resourceMngr.get(getPrefabConfigUrl(prefabName))
+            .then(_config => {
+            cache.set(prefabName, _config);
+            return _config;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: PrefabConfigProviderService, deps: [{ token: AppResourceManagerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: PrefabConfigProviderService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: PrefabConfigProviderService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: AppResourceManagerService }] });
+
+const wmModules = [
+    importProvidersFrom(ModalModule.forRoot(), ToastNoAnimationModule.forRoot({ maxOpened: 1, autoDismiss: true }), BsDatepickerModule.forRoot(), NgCircleProgressModule.forRoot())
+];
+const WM_XHR_FACTORY = { build: () => new XMLHttpRequest() };
+const xsrfHeaderName$1 = getWmProjectProperties().xsrf_header_name || "X-WM-XSRF-TOKEN";
+const initializeProjectDetails = () => {
+    let cdnUrl = document.querySelector('[name="deployUrl"]') && document.querySelector('[name="deployUrl"]').getAttribute('content');
+    _WM_APP_PROJECT.isPreview = cdnUrl ? false : true;
+    const apiUrl = document.querySelector('[name="apiUrl"]') && document.querySelector('[name="apiUrl"]').getAttribute('content');
+    //for preview
+    if (!cdnUrl) {
+        cdnUrl = document.querySelector('[name="cdnUrl"]') && document.querySelector('[name="cdnUrl"]').getAttribute('content');
+    }
+    _WM_APP_PROJECT.id = location.href.split('/')[3];
+    // Integration with third party apps like in SSPA/WebComponents, this meta tag with cdnUrl will not be there then default it to ng-bundle/
+    _WM_APP_PROJECT.apiUrl = apiUrl || './';
+    _WM_APP_PROJECT.cdnUrl = cdnUrl || 'ng-bundle/';
+    _WM_APP_PROJECT.ngDest = 'ng-bundle/';
+    try {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        //@ts-ignore
+        __webpack_require__.p = __webpack_public_path__ = cdnUrl;
+    }
+    catch (e) {
+        //for app preview there is no webpack. Don't do anything.
+    }
+};
+function InitializeApp(I18nService, AppJSResolve, AppBeforeLoadResolve, AppVariablesResolve, AppExtensionJSResolve, PipeService) {
+    return async () => {
+        initializeProjectDetails();
+        await AppJSResolve.resolve();
+        await AppVariablesResolve.resolve();
+        await AppExtensionJSResolve.resolve();
+        await I18nService.loadDefaultLocale();
+        return AppBeforeLoadResolve.resolve();
+    };
+}
+function setAngularLocale(I18nService) {
+    initializeProjectDetails();
+    return I18nService.deduceAppLocale();
+}
+const appConfig = {
+    providers: [
+        provideZoneChangeDetection({
+            eventCoalescing: true,
+            runCoalescing: true
+        }),
+        { provide: HTTP_INTERCEPTORS, useClass: HttpCallInterceptor, multi: true },
+        // Provide Angular core services FIRST
+        provideRouter(routes, withHashLocation(), withComponentInputBinding()),
+        provideAnimations(),
+        { provide: XhrFactory, useValue: WM_XHR_FACTORY },
+        provideHttpClient(withInterceptorsFromDi(), withXsrfConfiguration({
+            cookieName: "wm_xsrf_token",
+            headerName: xsrfHeaderName$1
+        })),
+        { provide: HttpXhrBackend, useFactory: () => new HttpXhrBackend(WM_XHR_FACTORY) },
+        // Custom renderer overrides (must be early)
+        { provide: RendererFactory2, useClass: WMDomRendererFactory2 },
+        // Provide HttpService EARLY (AppManagerService needs it)
+        { provide: AbstractHttpService, useClass: HttpServiceImpl },
+        // Provide base services (before APP_INITIALIZER that depends on them)
+        { provide: App, useClass: AppRef },
+        { provide: AbstractToasterService, useClass: ToasterServiceImpl },
+        { provide: AbstractI18nService, useClass: I18nServiceImpl },
+        { provide: AbstractSpinnerService, useClass: SpinnerServiceImpl },
+        { provide: AbstractNavigationService, useClass: NavigationServiceImpl },
+        { provide: AbstractDialogService, useClass: DialogServiceImpl },
+        { provide: AppDefaults, useClass: AppDefaultsService },
+        { provide: DynamicComponentRefProvider, useClass: DynamicComponentRefProviderService },
+        { provide: AppJSProvider, useClass: AppJSProviderService },
+        { provide: AppVariablesProvider, useClass: AppVariablesProviderService },
+        { provide: AppExtensionProvider, useClass: AppExtensionProviderService },
+        { provide: ComponentRefProvider, useClass: ComponentRefProviderService },
+        { provide: PartialRefProvider, useClass: ComponentRefProviderService },
+        { provide: CustomWidgetRefProvider, useClass: ComponentRefProviderService },
+        { provide: CustomwidgetConfigProvider, useClass: CustomwidgetConfigProviderService },
+        { provide: PrefabConfigProvider, useClass: PrefabConfigProviderService },
+        { provide: RouteReuseStrategy, useClass: WmRouteReuseStrategy },
+        AppResourceManagerService,
+        PipeService,
+        CustomIconsLoaderService,
+        Viewport,
+        DecimalPipe,
+        SanitizePipe,
+        ToDatePipe,
+        FilterPipe,
+        TrailingZeroDecimalPipe,
+        TrustAsPipe,
+        ImagePipe,
+        CustomPipe,
+        Location,
+        DatePipe,
+        AppManagerService,
+        PrefabManagerService,
+        AuthGuard,
+        RoleGuard,
+        PageNotFoundGuard,
+        CanDeactivatePageGuard,
+        AppJSResolve,
+        AppVariablesResolve,
+        AppExtensionJSResolve,
+        I18nResolve,
+        AppBeforeLoadResolve,
+        SecurityService,
+        OAuthService,
+        VariablesService,
+        MetadataService,
+        // Route reuse strategy cache settings
+        { provide: MAX_CACHE_SIZE, useValue: 10 },
+        { provide: MAX_CACHE_AGE, useValue: 30 * 60 },
+        // Third-party standalone providers
+        ...wmModules,
+        // APP_INITIALIZER for locale and app initialization
+        {
+            provide: APP_INITIALIZER,
+            useFactory: InitializeApp,
+            deps: [AbstractI18nService, AppJSResolve, AppBeforeLoadResolve, AppVariablesResolve, AppExtensionJSResolve, PipeService],
+            multi: true
+        },
+        // LOCALE_ID will be set by I18n service
+        {
+            provide: LOCALE_ID,
+            useFactory: setAngularLocale,
+            deps: [AbstractI18nService]
+        }
+    ]
+};
+
+const DEBUG_MODE = 'debugMode';
+if (sessionStorage.getItem(DEBUG_MODE) !== 'true') {
+    enableProdMode();
+}
+fetch('./font.config.js')
+    .then(response => response.text())
+    .then((fontConfig) => {
+    setPreviewProperties({ fontConfig });
+    const iconLoader = new CustomIconsLoaderService();
+    iconLoader.load();
+});
+console.time('bootstrap');
+document.addEventListener('DOMContentLoaded', () => {
+    new Promise(resolve => {
+        resolve();
+    }).then(() => bootstrapApplication(AppComponent, appConfig))
+        .then((appRef) => {
+        window.addEventListener('unload', () => {
+            appRef.components.map(c => c?.destroy());
+        });
+    })
+        .catch(err => console.error('Error bootstrapping app:', err));
+});
+window.debugMode = function (on) {
+    if (isEmpty(on)) {
+        on = true;
+    }
+    const value = on ? 'true' : 'false';
+    if (sessionStorage.getItem(DEBUG_MODE) !== value) {
+        sessionStorage.setItem(DEBUG_MODE, value);
+        window.location.reload();
+    }
+};
+var main = () => { };
+
+const routerModule = RouterModule.forRoot(routes, { useHash: true, scrollPositionRestoration: 'top' });
+const toastrModule = ToastNoAnimationModule.forRoot({ maxOpened: 1, autoDismiss: true });
+// In angular 15, xsrf headerName should not be null. Angular 15 is not using default header value like it used to send in calls
+// for angular 12 if the headerName is null . The user has to take care of not sending null values. Then ng 15 uses default value for headerName
+const xsrfHeaderName = getWmProjectProperties().xsrf_header_name;
+const xsrfOptions = {
+    cookieName: 'wm_xsrf_token'
+};
+if (xsrfHeaderName) {
+    xsrfOptions['headerName'] = xsrfHeaderName;
+}
+const httpClientXsrfModule = HttpClientXsrfModule.withOptions(xsrfOptions);
+const modalModule = ModalModule.forRoot();
+const bsDatePickerModule = BsDatepickerModule.forRoot();
+const timepickerModule = TimepickerModule.forRoot();
+const bsDropdownModule = BsDropdownModule.forRoot();
+const paginationModule = PaginationModule.forRoot();
+const typeaheadModule = TypeaheadModule.forRoot();
+const progressbarModule = ProgressbarModule.forRoot();
+const carouselModule = CarouselModule.forRoot();
+const popoverModule = PopoverModule.forRoot();
+const ngCircleProgressModule = NgCircleProgressModule.forRoot({});
+const tooltipModule = TooltipModule.forRoot();
+const componentsModule = [
+    // NGX Bootstrap
+    BsDatepickerModule,
+    TimepickerModule,
+    BsDropdownModule,
+    PaginationModule,
+    TypeaheadModule,
+    ProgressbarModule,
+    CarouselModule,
+    PopoverModule,
+    NgCircleProgressModule,
+    TooltipModule,
+    // Basic widgets
+    AnchorComponent,
+    AudioComponent,
+    HtmlDirective,
+    IconComponent,
+    IframeComponent,
+    LabelDirective,
+    PictureDirective,
+    SpinnerComponent,
+    VideoComponent,
+    ProgressBarComponent, ProgressCircleComponent,
+    RichTextEditorComponent,
+    SearchComponent, ScrollableDirective,
+    TreeComponent,
+    // Input
+    CalendarComponent,
+    ChipsComponent,
+    ColorPickerComponent,
+    CurrencyComponent,
+    DateComponent,
+    DatetimeComponent,
+    TimeComponent,
+    DateTimePickerComponent,
+    TimePickerComponent,
+    PickerComponent,
+    PickerGroupComponent,
+    FileUploadComponent,
+    ButtonComponent,
+    ButtonGroupDirective,
+    CaptionPositionDirective,
+    CheckboxComponent,
+    CheckboxsetComponent,
+    CompositeDirective,
+    NumberComponent,
+    RadiosetComponent,
+    SelectComponent,
+    SwitchComponent,
+    InputCalendarComponent,
+    InputColorComponent,
+    InputEmailComponent,
+    InputNumberComponent,
+    InputTextComponent,
+    TextareaComponent,
+    RatingComponent,
+    SliderComponent,
+    // Data
+    CardComponent,
+    CardActionsDirective,
+    CardContentComponent,
+    CardFooterDirective,
+    FormComponent,
+    FormWidgetDirective,
+    FormActionDirective,
+    FormFieldDirective,
+    LiveActionsDirective,
+    DependsonDirective,
+    LiveFilterDirective,
+    LiveFormDirective,
+    ListComponent, ListItemDirective,
+    LiveTableComponent,
+    PaginationComponent,
+    TableComponent,
+    TableCUDDirective,
+    TableFilterSortDirective,
+    TableActionDirective,
+    TableColumnDirective,
+    TableColumnGroupDirective,
+    TableRowDirective,
+    TableRowActionDirective,
+    // chart
+    ChartComponent,
+    // container modules
+    AccordionPaneComponent, AccordionDirective,
+    LinearLayoutDirective, LinearLayoutItemDirective,
+    LayoutgridDirective, LayoutGridRowDirective, LayoutGridColumnDirective,
+    PanelComponent,
+    TabPaneComponent, TabsComponent,
+    TileDirective,
+    WizardActionDirective, WizardStepComponent, WizardComponent,
+    // dialogs
+    AlertDialogComponent,
+    IframeDialogComponent,
+    LoginDialogDirective,
+    PartialDialogComponent,
+    // navigation
+    BreadcrumbComponent,
+    MenuComponent, MenuDropdownComponent, MenuDropdownItemComponent, NavigationControlDirective, NavComponent, NavItemDirective,
+    NavbarComponent,
+    PopoverComponent,
+    // Advanced
+    CarouselDirective, CarouselTemplateDirective,
+    LoginComponent,
+    MarqueeDirective,
+    CustomWidgetDirective, CustomWidgetContainerDirective,
+    PageDirective,
+    LayoutDirective,
+    ContentComponent,
+    PageContentComponent,
+    SpaPageDirective,
+    RouterOutletDirective,
+    FooterDirective,
+    HeaderComponent,
+    LeftPanelDirective,
+    RightPanelDirective,
+    TopNavDirective,
+    PrefabDirective$1, PrefabContainerDirective
+];
+REQUIRED_MODULES_FOR_DYNAMIC_COMPONENTS.push(...componentsModule);
+REQUIRED_MODULES_FOR_DYNAMIC_COMPONENTS.push(FormsModule, ReactiveFormsModule);
+let AppModule = class AppModule {
+    constructor(app, inj, componentRefProvider) {
+        this.app = app;
+        this.inj = inj;
+        this.componentRefProvider = componentRefProvider;
+    }
+};
+AppModule = __decorate([
+    NgModule({
+        declarations: [
+            PageWrapperComponent
+        ],
+        imports: [
+            BrowserModule,
+            BrowserAnimationsModule,
+            CommonModule,
+            RouterModule,
+            HttpClientModule,
+            modalModule,
+            bsDatePickerModule,
+            timepickerModule,
+            bsDropdownModule,
+            paginationModule,
+            typeaheadModule,
+            tooltipModule,
+            progressbarModule,
+            carouselModule,
+            popoverModule,
+            ngCircleProgressModule,
+            routerModule,
+            toastrModule,
+            httpClientXsrfModule,
+            WM_MODULES_FOR_ROOT
+        ],
+        providers: [
+            AppResourceManagerService,
+            { provide: AppJSProvider, useClass: AppJSProviderService },
+            { provide: AppVariablesProvider, useClass: AppVariablesProviderService },
+            { provide: AppExtensionProvider, useClass: AppExtensionProviderService },
+            { provide: ComponentRefProvider, useClass: ComponentRefProviderService },
+            { provide: PartialRefProvider, useClass: ComponentRefProviderService },
+            { provide: CustomWidgetRefProvider, useClass: ComponentRefProviderService },
+            { provide: CustomwidgetConfigProvider, useClass: CustomwidgetConfigProviderService },
+            { provide: PrefabConfigProvider, useClass: PrefabConfigProviderService },
+            { provide: RouteReuseStrategy, useClass: WmRouteReuseStrategy },
+            { provide: AbstractHttpService, useClass: HttpServiceImpl }
+        ],
+        bootstrap: [AppComponent]
+    }),
+    __metadata("design:paramtypes", [App, Injector, ComponentRefProvider])
+], AppModule);
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AppExtensionProviderService, AppJSProviderService, AppModule, AppResourceManagerService, AppVariablesProviderService, ComponentRefProviderService, PageWrapperComponent, PrefabConfigProviderService, bsDatePickerModule, bsDropdownModule, carouselModule, httpClientXsrfModule, modalModule, ngCircleProgressModule, paginationModule, popoverModule, progressbarModule, routerModule, timepickerModule, toastrModule, tooltipModule, typeaheadModule };
+//# sourceMappingURL=index.mjs.map