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

package/components/base/esm2022/widgets/common/dialog/dialog.service.mjs

@@ -0,0 +1,170 @@
+import { Injectable } from '@angular/core';
+import { isMobile } from '@wm/core';
+import { forEach } from "lodash-es";
+import * as i0 from "@angular/core";
+const openedDialogs = [];
+/*We need closedDialogs array because onHidden event is asynchronous,
+and if the user uses script and calls dialog1.close() and then dialog2.close() then
+we cannot be sure if both the dialogs onClose callback will be called or not.*/
+const closeDialogsArray = [];
+export class DialogServiceImpl {
+    constructor() {
+        /**
+         * map which contains the references to all dialogs by name
+         * @type {Map<any, any>}
+         * Ex Map[[dialogName, [[dialogScope, dialogRef]]]]
+         */
+        this.dialogRefsCollection = new Map();
+        this.appConfirmDialog = '_app-confirm-dialog';
+    }
+    /**
+     * Register dialog by name and scope
+     * @param {string} name
+     * @param {BaseDialog} dialogRef
+     * @param {scope}
+     */
+    register(name, dialogRef, scope) {
+        if (!name) {
+            return;
+        }
+        if (this.dialogRefsCollection.get(name)) {
+            this.dialogRefsCollection.get(name).set(scope, dialogRef);
+        }
+        else {
+            this.dialogRefsCollection.set(name, new Map([[scope, dialogRef]]));
+        }
+    }
+    getDialogRefsCollection() {
+        return this.dialogRefsCollection;
+    }
+    /**
+     * De Register dialog by name and scope
+     * @param name
+     * @param dialogRef
+     * @param scope
+     */
+    deRegister(name, scope) {
+        if (!name) {
+            return;
+        }
+        if (this.dialogRefsCollection.get(name)) {
+            this.dialogRefsCollection.get(name).delete(scope);
+        }
+    }
+    getDialogRef(name, scope) {
+        const dialogRefMap = this.dialogRefsCollection.get(name);
+        let dialogRef;
+        if (scope) {
+            dialogRef = dialogRefMap.get(scope);
+            if (!dialogRef) {
+                // Check if the scope is App level scope
+                // else throw a console error
+                if (!scope.pageName && !scope.partialName && !scope.prefabName) {
+                    dialogRefMap.forEach((dRef, dialogScope) => {
+                        // Check if the collection of dialogs have a "common" partial scope
+                        // If yes use that else through a console error
+                        if (dialogScope && dialogScope.partialName === 'Common') {
+                            dialogRef = dRef;
+                        }
+                        else {
+                            console.error('No dialog with the name "' + name + '" found in the App scope.');
+                        }
+                    });
+                }
+                else {
+                    console.error('No dialog with the name "' + name + '" found in the given scope.');
+                }
+            }
+        }
+        else {
+            if (dialogRefMap.size === 1) {
+                dialogRef = dialogRefMap.entries().next().value[1];
+            }
+            else {
+                console.error('There are multiple instances of this dialog name. Please provide the Page/Partial/App instance in which the dialog exists.');
+            }
+        }
+        return dialogRef;
+    }
+    /**
+     * Opens the dialog with the given name
+     * @param {string} name
+     */
+    open(name, scope, initState) {
+        const dialogRef = this.getDialogRef(name, scope);
+        if (!dialogRef) {
+            return;
+        }
+        dialogRef.open(initState);
+    }
+    /**
+     * closes the dialog with the given name
+     * @param {string} name
+     */
+    close(name, scope, callBackFn) {
+        const dialogRef = this.getDialogRef(name, scope);
+        if (!dialogRef) {
+            return;
+        }
+        // For notification action variable dialogs onok callback event should be called after closing the dialog.
+        // So passing it as callback function
+        dialogRef.closeCallBackFn = callBackFn;
+        dialogRef.close();
+    }
+    /**
+     * closes all the opened dialogs
+     */
+    closeAllDialogs() {
+        forEach(openedDialogs.reverse(), (dialog) => {
+            dialog.close();
+        });
+    }
+    showAppConfirmDialog(initState) {
+        this.open(this.getAppConfirmDialog(), undefined, initState);
+    }
+    closeAppConfirmDialog() {
+        this.close(this.getAppConfirmDialog());
+    }
+    getAppConfirmDialog() {
+        return this.appConfirmDialog;
+    }
+    setAppConfirmDialog(dialogName) {
+        this.appConfirmDialog = dialogName;
+    }
+    addToOpenedDialogs(ref) {
+        openedDialogs.push(ref);
+    }
+    getLastOpenedDialog() {
+        return openedDialogs[openedDialogs.length - 1];
+    }
+    removeFromOpenedDialogs(ref) {
+        if (openedDialogs.indexOf(ref) !== -1) {
+            openedDialogs.splice(openedDialogs.indexOf(ref), 1);
+        }
+        if (openedDialogs.length === 0 && (isMobile())) {
+            //Fix for [WMS-23948]: remove aria-hidden attribute only after all dialogs are closed
+            const parentSelector = $('body > app-root')[0];
+            parentSelector.removeAttribute('aria-hidden');
+        }
+    }
+    getOpenedDialogs() {
+        return openedDialogs;
+    }
+    addToClosedDialogs(ref) {
+        closeDialogsArray.push(ref);
+    }
+    removeFromClosedDialogs(ref) {
+        if (closeDialogsArray.indexOf(ref) !== -1) {
+            closeDialogsArray.splice(closeDialogsArray.indexOf(ref), 1);
+        }
+    }
+    getDialogRefFromClosedDialogs() {
+        return closeDialogsArray[closeDialogsArray.length - 1];
+    }
+    static { this.ɵfac = function DialogServiceImpl_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || DialogServiceImpl)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DialogServiceImpl, factory: DialogServiceImpl.ɵfac }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DialogServiceImpl, [{
+        type: Injectable
+    }], () => [], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"","sources":["../../../../../../../projects/components/base/src/widgets/common/dialog/dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {isMobile} from '@wm/core';\nimport {forEach} from \"lodash-es\";\n\nconst openedDialogs = [];\n/*We need closedDialogs array because onHidden event is asynchronous,\nand if the user uses script and calls dialog1.close() and then dialog2.close() then\nwe cannot be sure if both the dialogs onClose callback will be called or not.*/\nconst closeDialogsArray = [];\n\n\n@Injectable()\nexport class DialogServiceImpl {\n\n    /**\n     * map which contains the references to all dialogs by name\n     * @type {Map<any, any>}\n     * Ex Map[[dialogName, [[dialogScope, dialogRef]]]]\n     */\n    private dialogRefsCollection = new Map<any, any>();\n    private appConfirmDialog = '_app-confirm-dialog';\n\n    constructor() {}\n\n    /**\n     * Register dialog by name and scope\n     * @param {string} name\n     * @param {BaseDialog} dialogRef\n     * @param {scope}\n     */\n    public register(name: string, dialogRef: any, scope: any) {\n        if (!name) {\n            return;\n        }\n        if (this.dialogRefsCollection.get(name)) {\n            this.dialogRefsCollection.get(name).set(scope, dialogRef);\n        } else {\n            this.dialogRefsCollection.set(name, new Map([[scope, dialogRef]]));\n        }\n    }\n\n    public getDialogRefsCollection() {\n        return this.dialogRefsCollection;\n    }\n\n    /**\n     * De Register dialog by name and scope\n     * @param name\n     * @param dialogRef\n     * @param scope\n     */\n    public deRegister(name: string, scope: any) {\n        if (!name) {\n            return;\n        }\n        if (this.dialogRefsCollection.get(name)) {\n                this.dialogRefsCollection.get(name).delete(scope);\n        }\n    }\n\n    private getDialogRef(name: string, scope?: any) {\n        const dialogRefMap = this.dialogRefsCollection.get(name);\n        let dialogRef;\n\n        if (scope) {\n            dialogRef = dialogRefMap.get(scope);\n            if (!dialogRef) {\n                // Check if the scope is App level scope\n                // else throw a console error\n                if (!scope.pageName && !scope.partialName && !scope.prefabName) {\n                    dialogRefMap.forEach((dRef, dialogScope) => {\n                        // Check if the collection of dialogs have a \"common\" partial scope\n                        // If yes use that else through a console error\n                        if (dialogScope && dialogScope.partialName === 'Common') {\n                            dialogRef = dRef;\n                        } else {\n                            console.error('No dialog with the name \"' + name + '\" found in the App scope.');\n                        }\n                    });\n                } else {\n                    console.error('No dialog with the name \"' + name + '\" found in the given scope.');\n                }\n            }\n        } else {\n            if (dialogRefMap.size === 1) {\n                dialogRef = dialogRefMap.entries().next().value[1];\n            } else {\n                console.error('There are multiple instances of this dialog name. Please provide the Page/Partial/App instance in which the dialog exists.');\n            }\n        }\n        return dialogRef;\n    }\n\n    /**\n     * Opens the dialog with the given name\n     * @param {string} name\n     */\n    public open(name: string, scope?: any, initState?: any) {\n        const dialogRef = this.getDialogRef(name, scope);\n        if (!dialogRef) {\n            return;\n        }\n\n        dialogRef.open(initState);\n    }\n\n    /**\n     * closes the dialog with the given name\n     * @param {string} name\n     */\n    public close(name: string, scope?: any, callBackFn?:any) {\n        const dialogRef = this.getDialogRef(name, scope);\n        if (!dialogRef) {\n            return;\n        }\n        // For notification action variable dialogs onok callback event should be called after closing the dialog.\n        // So passing it as callback function\n        dialogRef.closeCallBackFn = callBackFn;\n        dialogRef.close();\n    }\n\n    /**\n     * closes all the opened dialogs\n     */\n    closeAllDialogs() {\n        forEach(openedDialogs.reverse(), (dialog) => {\n            dialog.close();\n        });\n    }\n\n    public showAppConfirmDialog(initState?: any) {\n        this.open(this.getAppConfirmDialog(), undefined, initState);\n    }\n\n    public closeAppConfirmDialog() {\n        this.close(this.getAppConfirmDialog());\n    }\n\n    public getAppConfirmDialog() {\n        return this.appConfirmDialog;\n    }\n\n    public setAppConfirmDialog(dialogName: string) {\n        this.appConfirmDialog = dialogName;\n    }\n\n    public addToOpenedDialogs(ref) {\n        openedDialogs.push(ref);\n    }\n\n    public getLastOpenedDialog() {\n        return openedDialogs[openedDialogs.length - 1];\n    }\n\n    public removeFromOpenedDialogs(ref) {\n        if (openedDialogs.indexOf(ref) !== -1) {\n            openedDialogs.splice(openedDialogs.indexOf(ref), 1);\n        }\n        if (openedDialogs.length === 0 && (isMobile())) {\n            //Fix for [WMS-23948]: remove aria-hidden attribute only after all dialogs are closed\n            const parentSelector = $('body > app-root')[0];\n            parentSelector.removeAttribute('aria-hidden');\n        }\n    }\n\n    public getOpenedDialogs() {\n        return openedDialogs;\n    }\n\n    public addToClosedDialogs(ref) {\n        closeDialogsArray.push(ref);\n    }\n\n    public removeFromClosedDialogs(ref) {\n        if (closeDialogsArray.indexOf(ref) !== -1) {\n            closeDialogsArray.splice(closeDialogsArray.indexOf(ref), 1);\n        }\n    }\n\n    public getDialogRefFromClosedDialogs() {\n        return closeDialogsArray[closeDialogsArray.length - 1];\n    }\n}\n"]}

package/components/base/esm2022/widgets/common/item-template/item-template.directive.mjs

@@ -0,0 +1,89 @@
+/**
+ * This directive is used to set custom template partial for an item and maintains separate scope for each item.
+ * This takes two inputs
+ *      1) template partial name as wmItemTemplate
+ *      2) item object as userComponentParams
+ * Example: Providing a custom template for the search/autocomplete widget (customized UI in the dropdown for each item)
+ * Add this directive to the li tag and provide item object and partial name like below. And also provide partialContainer and partial-container-target to render the partial.
+ * <li #liElements *ngFor="let match of matches" [wmItemTemplate]="content" [userComponentParams]="match.item" partialContainer>
+ *      <a partial-container-target></a>
+ * </li>
+ */
+import { Directive, ElementRef, Inject, Injector, Input, Optional } from '@angular/core';
+import { App } from '@wm/core';
+import { provideAsWidgetRef } from '../../../utils/widget-utils';
+import { registerProps } from './item-template.props';
+import { StylableComponent } from '../base/stylable.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/core";
+const WIDGET_CONFIG = { widgetType: 'wm-item-template' };
+export class ItemTemplateDirective extends StylableComponent {
+    static { this.initializeProps = registerProps(); }
+    get $index() {
+        return this.context.index;
+    }
+    set wmItemTemplate(value) {
+        this.widget.content = value;
+    }
+    constructor(inj, elRef, app, explicitContext) {
+        super(inj, WIDGET_CONFIG, explicitContext);
+        this.app = app;
+        this.nativeElement = elRef.nativeElement;
+        // this.context = (<NgForOfContext<ItemTemplateDirective>>(<any>inj).view.context);
+        this.context = this.inj._lView[8];
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.partialParams.item = this.userComponentParams.dataObject;
+    }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Clear context to release references to ngFor context
+        // The context holds references to the parent LView and loop variables
+        if (this.context) {
+            Object.keys(this.context).forEach(key => {
+                delete this.context[key];
+            });
+            this.context = null;
+        }
+        // MEMORY LEAK FIX: Clear partial params
+        if (this.partialParams) {
+            Object.keys(this.partialParams).forEach(key => {
+                delete this.partialParams[key];
+            });
+            this.partialParams = null;
+        }
+        // MEMORY LEAK FIX: Clear user component params reference
+        this.userComponentParams = null;
+        // MEMORY LEAK FIX: Clear content reference
+        this.content = null;
+        // MEMORY LEAK FIX: Clear ViewContainerRef reference
+        this.viewContainerRef = null;
+        // Call parent ngOnDestroy (StylableComponent → BaseComponent)
+        super.ngOnDestroy();
+    }
+    static { this.ɵfac = function ItemTemplateDirective_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ItemTemplateDirective)(i0.ɵɵdirectiveInject(i0.Injector), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i1.App), i0.ɵɵdirectiveInject('EXPLICIT_CONTEXT', 8)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ItemTemplateDirective, selectors: [["", "wmItemTemplate", ""]], inputs: { userComponentParams: "userComponentParams", wmItemTemplate: "wmItemTemplate" }, exportAs: ["itemTemplateRef"], standalone: true, features: [i0.ɵɵProvidersFeature([
+                provideAsWidgetRef(ItemTemplateDirective)
+            ]), i0.ɵɵInheritDefinitionFeature] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ItemTemplateDirective, [{
+        type: Directive,
+        args: [{
+                standalone: true,
+                selector: '[wmItemTemplate]',
+                exportAs: 'itemTemplateRef',
+                providers: [
+                    provideAsWidgetRef(ItemTemplateDirective)
+                ]
+            }]
+    }], () => [{ type: i0.Injector }, { type: i0.ElementRef }, { type: i1.App }, { type: undefined, decorators: [{
+                type: Inject,
+                args: ['EXPLICIT_CONTEXT']
+            }, {
+                type: Optional
+            }] }], { userComponentParams: [{
+            type: Input
+        }], wmItemTemplate: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/components/base/esm2022/widgets/common/item-template/item-template.props.mjs

@@ -0,0 +1,7 @@
+import { PROP_STRING, register } from '../../framework/widget-props';
+export const registerProps = () => {
+    register('wm-item-template', new Map([
+        ['content', PROP_STRING]
+    ]));
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXRlbS10ZW1wbGF0ZS5wcm9wcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvYmFzZS9zcmMvd2lkZ2V0cy9jb21tb24vaXRlbS10ZW1wbGF0ZS9pdGVtLXRlbXBsYXRlLnByb3BzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBMEIsV0FBVyxFQUFFLFFBQVEsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBRTdGLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxHQUFHLEVBQUU7SUFDOUIsUUFBUSxDQUNKLGtCQUFrQixFQUNsQixJQUFJLEdBQUcsQ0FDSDtRQUNJLENBQUMsU0FBUyxFQUFFLFdBQVcsQ0FBQztLQUMzQixDQUNKLENBQ0osQ0FBQztBQUNOLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBST1BfQU5ZLCBQUk9QX0JPT0xFQU4sIFBST1BfU1RSSU5HLCByZWdpc3RlciB9IGZyb20gJy4uLy4uL2ZyYW1ld29yay93aWRnZXQtcHJvcHMnO1xuXG5leHBvcnQgY29uc3QgcmVnaXN0ZXJQcm9wcyA9ICgpID0+IHtcbiAgICByZWdpc3RlcihcbiAgICAgICAgJ3dtLWl0ZW0tdGVtcGxhdGUnLFxuICAgICAgICBuZXcgTWFwKFxuICAgICAgICAgICAgW1xuICAgICAgICAgICAgICAgIFsnY29udGVudCcsIFBST1BfU1RSSU5HXVxuICAgICAgICAgICAgXVxuICAgICAgICApXG4gICAgKTtcbn07XG4iXX0=

package/components/base/esm2022/widgets/common/lazy-load/lazy-load.directive.mjs

@@ -0,0 +1,84 @@
+import { Directive, Inject, inject, Injector, Input, Optional, TemplateRef, ViewContainerRef } from '@angular/core';
+import { $watch, App, findParent } from '@wm/core';
+import { extend } from "lodash-es";
+import * as i0 from "@angular/core";
+export class LazyLoadDirective {
+    constructor(inj, templateRef, viewContainer, explicitContext = {}) {
+        this.templateRef = templateRef;
+        this.viewContainer = viewContainer;
+        this.context = {}; // Changed from readonly to allow cleanup
+        let viewParentApp = inj ? inj.get(App) : inject(App);
+        let lView = inj._lView;
+        this.viewParent = findParent(lView, viewParentApp);
+        //this.context = (inj as any).view.context;
+        extend(this.context, inj._lView[8], explicitContext);
+    }
+    set lazyLoad(expr) {
+        // MEMORY LEAK FIX: Unsubscribe from previous watcher if it exists
+        if (this.unSubscribeFn && typeof this.unSubscribeFn === 'function') {
+            try {
+                this.unSubscribeFn();
+            }
+            catch (e) {
+                console.warn('Error unsubscribing from previous lazyLoad watcher:', e);
+            }
+            this.unSubscribeFn = null;
+        }
+        this.unSubscribeFn = $watch(expr, this.viewParent, this.context, (val) => {
+            if (!this.embeddedView && val) {
+                this.embeddedView = this.viewContainer.createEmbeddedView(this.templateRef, this.context);
+                // Unsubscribe after creating the view (lazy load is complete)
+                if (this.unSubscribeFn && typeof this.unSubscribeFn === 'function') {
+                    try {
+                        this.unSubscribeFn();
+                        this.unSubscribeFn = null; // Clear after calling to prevent double-call
+                    }
+                    catch (e) {
+                        console.warn('Error unsubscribing from lazyLoad watcher:', e);
+                        this.unSubscribeFn = null;
+                    }
+                }
+            }
+        });
+    }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Safely unsubscribe from watcher
+        if (this.unSubscribeFn && typeof this.unSubscribeFn === 'function') {
+            try {
+                this.unSubscribeFn();
+            }
+            catch (e) {
+                console.warn('Error unsubscribing from lazyLoad watcher in ngOnDestroy:', e);
+            }
+            this.unSubscribeFn = null;
+        }
+        // MEMORY LEAK FIX: Clear context to release references to parent scope data
+        if (this.context) {
+            Object.keys(this.context).forEach(key => {
+                delete this.context[key];
+            });
+            this.context = null;
+        }
+        // MEMORY LEAK FIX: Clear embedded view reference
+        if (this.embeddedView) {
+            this.embeddedView = null;
+        }
+    }
+    static { this.ɵfac = function LazyLoadDirective_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LazyLoadDirective)(i0.ɵɵdirectiveInject(i0.Injector), i0.ɵɵdirectiveInject(i0.TemplateRef), i0.ɵɵdirectiveInject(i0.ViewContainerRef), i0.ɵɵdirectiveInject('EXPLICIT_CONTEXT', 8)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: LazyLoadDirective, selectors: [["", "lazyLoad", ""]], inputs: { lazyLoad: "lazyLoad" }, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LazyLoadDirective, [{
+        type: Directive,
+        args: [{
+                standalone: true,
+                selector: '[lazyLoad]'
+            }]
+    }], () => [{ type: i0.Injector }, { type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: undefined, decorators: [{
+                type: Inject,
+                args: ['EXPLICIT_CONTEXT']
+            }, {
+                type: Optional
+            }] }], { lazyLoad: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lazy-load.directive.js","sourceRoot":"","sources":["../../../../../../../projects/components/base/src/widgets/common/lazy-load/lazy-load.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Directive,\n    Inject,\n    inject,\n    Injector,\n    Input,\n    OnDestroy,\n    Optional,\n    TemplateRef,\n    ViewContainerRef\n} from '@angular/core';\n\nimport {$watch, App, findParent} from '@wm/core';\nimport {extend} from \"lodash-es\";\n\n@Directive({\n  standalone: true,\n    selector: '[lazyLoad]'\n})\nexport class LazyLoadDirective implements OnDestroy {\n    private readonly viewParent: any;\n    private context: any = {}; // Changed from readonly to allow cleanup\n    private embeddedView;\n    private unSubscribeFn: Function;\n\n    constructor(\n        inj: Injector,\n        private templateRef: TemplateRef<any>,\n        private viewContainer: ViewContainerRef,\n        @Inject('EXPLICIT_CONTEXT') @Optional() explicitContext: any = {}\n    ) {\n        let viewParentApp = inj ? inj.get(App) : inject(App);\n        let lView = (inj as any)._lView;\n        this.viewParent = findParent(lView, viewParentApp)\n        //this.context = (inj as any).view.context;\n        extend(this.context, (inj as any)._lView[8], explicitContext);\n    }\n\n    @Input()\n    set lazyLoad(expr) {\n        // MEMORY LEAK FIX: Unsubscribe from previous watcher if it exists\n        if (this.unSubscribeFn && typeof this.unSubscribeFn === 'function') {\n            try {\n                this.unSubscribeFn();\n            } catch (e) {\n                console.warn('Error unsubscribing from previous lazyLoad watcher:', e);\n            }\n            this.unSubscribeFn = null;\n        }\n        \n        this.unSubscribeFn = $watch(\n            expr,\n            this.viewParent,\n            this.context,\n            (val) => {\n                if (!this.embeddedView && val) {\n                    this.embeddedView  = this.viewContainer.createEmbeddedView(this.templateRef, this.context);\n                    // Unsubscribe after creating the view (lazy load is complete)\n                    if (this.unSubscribeFn && typeof this.unSubscribeFn === 'function') {\n                        try {\n                            this.unSubscribeFn();\n                            this.unSubscribeFn = null; // Clear after calling to prevent double-call\n                        } catch (e) {\n                            console.warn('Error unsubscribing from lazyLoad watcher:', e);\n                            this.unSubscribeFn = null;\n                        }\n                    }\n                }\n            }\n        );\n    }\n\n    ngOnDestroy() {\n        // MEMORY LEAK FIX: Safely unsubscribe from watcher\n        if (this.unSubscribeFn && typeof this.unSubscribeFn === 'function') {\n            try {\n                this.unSubscribeFn();\n            } catch (e) {\n                console.warn('Error unsubscribing from lazyLoad watcher in ngOnDestroy:', e);\n            }\n            this.unSubscribeFn = null;\n        }\n        \n        // MEMORY LEAK FIX: Clear context to release references to parent scope data\n        if (this.context) {\n            Object.keys(this.context).forEach(key => {\n                delete this.context[key];\n            });\n            this.context = null;\n        }\n        \n        // MEMORY LEAK FIX: Clear embedded view reference\n        if (this.embeddedView) {\n            this.embeddedView = null;\n        }\n    }\n}\n"]}

package/components/base/esm2022/widgets/common/message/message.component.mjs

@@ -0,0 +1,104 @@
+import { Component, Inject, Injector, Optional } from '@angular/core';
+import { switchClass } from '@wm/core';
+import { styler } from '../../framework/styler';
+import { StylableComponent } from '../base/stylable.component';
+import { registerProps } from './message.props';
+import { provideAsWidgetRef } from '../../../utils/widget-utils';
+import * as i0 from "@angular/core";
+const _c0 = ["wmMessage", ""];
+const DEFAULT_CLS = 'alert app-message';
+const WIDGET_CONFIG = { widgetType: 'wm-message', hostClass: DEFAULT_CLS };
+export class MessageComponent extends StylableComponent {
+    static { this.initializeProps = registerProps(); }
+    constructor(inj, explicitContext) {
+        super(inj, WIDGET_CONFIG, explicitContext);
+        this.messageClass = '';
+        this.messageIconClass = '';
+        this.type = '';
+        styler(this.nativeElement, this);
+    }
+    showMessage(caption, type) {
+        if (caption) {
+            this.caption = caption;
+        }
+        if (type) {
+            this.setWidgetProperty('type', type);
+        }
+        this.setWidgetProperty('show', true);
+    }
+    hideMessage() {
+        this.setWidgetProperty('show', false);
+    }
+    dismiss($event) {
+        this.hideMessage();
+        this.invokeEventCallback('close', { $event });
+    }
+    onMessageTypeChange(nv) {
+        let msgCls, msgIconCls;
+        switch (nv) {
+            case 'success':
+                msgCls = 'alert-success';
+                msgIconCls = 'wm-sl-l sl-check';
+                break;
+            case 'error':
+                msgCls = 'alert-danger';
+                msgIconCls = 'wi wi-cancel';
+                break;
+            case 'warn': /*To support old projects with type as "warn"*/
+            case 'warning':
+                msgCls = 'alert-warning';
+                msgIconCls = 'wm-sl-l sl-alarm-bell';
+                break;
+            case 'info':
+                msgCls = 'alert-info';
+                msgIconCls = 'wi wi-info';
+                break;
+            case 'loading':
+                msgCls = 'alert-info alert-loading';
+                msgIconCls = 'fa fa-spinner fa-spin';
+                break;
+        }
+        switchClass(this.nativeElement, msgCls, this.messageClass);
+        this.messageClass = msgCls;
+        this.messageIconClass = msgIconCls;
+    }
+    onPropertyChange(key, nv, ov) {
+        if (key === 'type') {
+            this.onMessageTypeChange(nv);
+        }
+        else {
+            super.onPropertyChange(key, nv, ov);
+        }
+    }
+    static { this.ɵfac = function MessageComponent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || MessageComponent)(i0.ɵɵdirectiveInject(i0.Injector), i0.ɵɵdirectiveInject('EXPLICIT_CONTEXT', 8)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: MessageComponent, selectors: [["", "wmMessage", ""]], exportAs: ["wmMessage"], standalone: true, features: [i0.ɵɵProvidersFeature([
+                provideAsWidgetRef(MessageComponent)
+            ]), i0.ɵɵInheritDefinitionFeature, i0.ɵɵStandaloneFeature], attrs: _c0, decls: 5, vars: 7, consts: [["aria-hidden", "true", 3, "title"], [3, "innerHtml"], ["title", "Close", "type", "button", "aria-label", "Close", 1, "btn-transparent", "close", 3, "click", "hidden"], ["aria-hidden", "true"]], template: function MessageComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelement(0, "i", 0)(1, "span", 1);
+            i0.ɵɵelementStart(2, "button", 2);
+            i0.ɵɵlistener("click", function MessageComponent_Template_button_click_2_listener($event) { return ctx.dismiss($event); });
+            i0.ɵɵelementStart(3, "span", 3);
+            i0.ɵɵtext(4, "\u00D7");
+            i0.ɵɵelementEnd()();
+        } if (rf & 2) {
+            i0.ɵɵclassMapInterpolate2("icon ", ctx.type, " ", ctx.messageIconClass, "");
+            i0.ɵɵproperty("title", ctx.type + "Alert");
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("innerHtml", ctx.caption, i0.ɵɵsanitizeHtml);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("hidden", ctx.hideclose);
+        } }, encapsulation: 2 }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MessageComponent, [{
+        type: Component,
+        args: [{ standalone: true, selector: '[wmMessage]', providers: [
+                    provideAsWidgetRef(MessageComponent)
+                ], exportAs: 'wmMessage', template: "<i aria-hidden=\"true\" [title]=\"type + 'Alert'\" class=\"icon {{type}} {{messageIconClass}}\"></i>\n<span [innerHtml]=\"caption\"></span>\n<button title=\"Close\" type=\"button\" class=\"btn-transparent close\" [hidden]=\"hideclose\" (click)=\"dismiss($event)\" aria-label=\"Close\">\n    <span aria-hidden=\"true\">&times;</span>\n</button>\n" }]
+    }], () => [{ type: i0.Injector }, { type: undefined, decorators: [{
+                type: Inject,
+                args: ['EXPLICIT_CONTEXT']
+            }, {
+                type: Optional
+            }] }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(MessageComponent, { className: "MessageComponent", filePath: "widgets/common/message/message.component.ts", lineNumber: 23 }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message.component.js","sourceRoot":"","sources":["../../../../../../../projects/components/base/src/widgets/common/message/message.component.ts","../../../../../../../projects/components/base/src/widgets/common/message/message.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Inject, Injector, Optional } from '@angular/core';\n\nimport { switchClass } from '@wm/core';\n\nimport { styler } from '../../framework/styler';\nimport { IWidgetConfig } from '../../framework/types';\nimport { StylableComponent } from '../base/stylable.component';\nimport { registerProps } from './message.props';\nimport { provideAsWidgetRef } from '../../../utils/widget-utils';\n\nconst DEFAULT_CLS = 'alert app-message';\nconst WIDGET_CONFIG: IWidgetConfig = { widgetType: 'wm-message', hostClass: DEFAULT_CLS };\n\n@Component({\n    standalone: true,\n    selector: '[wmMessage]',\n    templateUrl: './message.component.html',\n    providers: [\n        provideAsWidgetRef(MessageComponent)\n    ],\n    exportAs: 'wmMessage'\n})\nexport class MessageComponent extends StylableComponent {\n    static initializeProps = registerProps();\n    messageClass = '';\n    messageIconClass = '';\n    type = '';\n    caption: string;\n    public hideclose: any;\n\n    constructor(inj: Injector, @Inject('EXPLICIT_CONTEXT') @Optional() explicitContext: any) {\n        super(inj, WIDGET_CONFIG, explicitContext);\n        styler(this.nativeElement, this);\n    }\n\n    public showMessage(caption?: string, type?: string) {\n        if (caption) {\n            this.caption = caption;\n        }\n        if (type) {\n            this.setWidgetProperty('type', type);\n        }\n        this.setWidgetProperty('show', true);\n    }\n\n    public hideMessage() {\n        this.setWidgetProperty('show', false);\n    }\n\n    public dismiss($event) {\n        this.hideMessage();\n        this.invokeEventCallback('close', { $event });\n    }\n\n    private onMessageTypeChange(nv: string) {\n        let msgCls, msgIconCls;\n        switch (nv) {\n            case 'success':\n                msgCls = 'alert-success';\n                msgIconCls = 'wm-sl-l sl-check';\n                break;\n            case 'error':\n                msgCls = 'alert-danger';\n                msgIconCls = 'wi wi-cancel';\n                break;\n            case 'warn':  /*To support old projects with type as \"warn\"*/\n            case 'warning':\n                msgCls = 'alert-warning';\n                msgIconCls = 'wm-sl-l sl-alarm-bell';\n                break;\n            case 'info':\n                msgCls = 'alert-info';\n                msgIconCls = 'wi wi-info';\n                break;\n            case 'loading':\n                msgCls = 'alert-info alert-loading';\n                msgIconCls = 'fa fa-spinner fa-spin';\n                break;\n        }\n        switchClass(this.nativeElement, msgCls, this.messageClass);\n        this.messageClass = msgCls;\n        this.messageIconClass = msgIconCls;\n    }\n\n    onPropertyChange(key, nv, ov?) {\n        if (key === 'type') {\n            this.onMessageTypeChange(nv);\n        } else {\n            super.onPropertyChange(key, nv, ov);\n        }\n    }\n}\n","<i aria-hidden=\"true\" [title]=\"type + 'Alert'\" class=\"icon {{type}} {{messageIconClass}}\"></i>\n<span [innerHtml]=\"caption\"></span>\n<button title=\"Close\" type=\"button\" class=\"btn-transparent close\" [hidden]=\"hideclose\" (click)=\"dismiss($event)\" aria-label=\"Close\">\n    <span aria-hidden=\"true\">&times;</span>\n</button>\n"]}

package/components/base/esm2022/widgets/common/message/message.props.mjs

@@ -0,0 +1,13 @@
+import { PROP_BOOLEAN, PROP_STRING, register } from '../../framework/widget-props';
+export const registerProps = () => {
+    register('wm-message', new Map([
+        ['animation', PROP_STRING],
+        ['caption', { value: 'Message', ...PROP_STRING }],
+        ['class', PROP_STRING],
+        ['hideclose', { value: false, ...PROP_BOOLEAN }],
+        ['name', PROP_STRING],
+        ['show', { value: true, ...PROP_BOOLEAN }],
+        ['type', { value: 'success', ...PROP_STRING }],
+    ]));
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZS5wcm9wcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvYmFzZS9zcmMvd2lkZ2V0cy9jb21tb24vbWVzc2FnZS9tZXNzYWdlLnByb3BzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsV0FBVyxFQUFFLFFBQVEsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBRW5GLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxHQUFHLEVBQUU7SUFDOUIsUUFBUSxDQUNKLFlBQVksRUFDWixJQUFJLEdBQUcsQ0FDSDtRQUNJLENBQUMsV0FBVyxFQUFFLFdBQVcsQ0FBQztRQUMxQixDQUFDLFNBQVMsRUFBRSxFQUFDLEtBQUssRUFBRSxTQUFTLEVBQUUsR0FBRyxXQUFXLEVBQUMsQ0FBQztRQUMvQyxDQUFDLE9BQU8sRUFBRSxXQUFXLENBQUM7UUFDdEIsQ0FBQyxXQUFXLEVBQUUsRUFBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLEdBQUcsWUFBWSxFQUFDLENBQUM7UUFDOUMsQ0FBQyxNQUFNLEVBQUUsV0FBVyxDQUFDO1FBQ3JCLENBQUMsTUFBTSxFQUFFLEVBQUMsS0FBSyxFQUFFLElBQUksRUFBRSxHQUFHLFlBQVksRUFBQyxDQUFDO1FBQ3hDLENBQUMsTUFBTSxFQUFFLEVBQUMsS0FBSyxFQUFFLFNBQVMsRUFBRSxHQUFHLFdBQVcsRUFBQyxDQUFDO0tBQy9DLENBQ0osQ0FDSixDQUFDO0FBQ04sQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUFJPUF9CT09MRUFOLCBQUk9QX1NUUklORywgcmVnaXN0ZXIgfSBmcm9tICcuLi8uLi9mcmFtZXdvcmsvd2lkZ2V0LXByb3BzJztcblxuZXhwb3J0IGNvbnN0IHJlZ2lzdGVyUHJvcHMgPSAoKSA9PiB7XG4gICAgcmVnaXN0ZXIoXG4gICAgICAgICd3bS1tZXNzYWdlJyxcbiAgICAgICAgbmV3IE1hcChcbiAgICAgICAgICAgIFtcbiAgICAgICAgICAgICAgICBbJ2FuaW1hdGlvbicsIFBST1BfU1RSSU5HXSxcbiAgICAgICAgICAgICAgICBbJ2NhcHRpb24nLCB7dmFsdWU6ICdNZXNzYWdlJywgLi4uUFJPUF9TVFJJTkd9XSxcbiAgICAgICAgICAgICAgICBbJ2NsYXNzJywgUFJPUF9TVFJJTkddLFxuICAgICAgICAgICAgICAgIFsnaGlkZWNsb3NlJywge3ZhbHVlOiBmYWxzZSwgLi4uUFJPUF9CT09MRUFOfV0sXG4gICAgICAgICAgICAgICAgWyduYW1lJywgUFJPUF9TVFJJTkddLFxuICAgICAgICAgICAgICAgIFsnc2hvdycsIHt2YWx1ZTogdHJ1ZSwgLi4uUFJPUF9CT09MRUFOfV0sXG4gICAgICAgICAgICAgICAgWyd0eXBlJywge3ZhbHVlOiAnc3VjY2VzcycsIC4uLlBST1BfU1RSSU5HfV0sXG4gICAgICAgICAgICBdXG4gICAgICAgIClcbiAgICApO1xufTtcbiJdfQ==

package/components/base/esm2022/widgets/common/partial/partial.directive.mjs

@@ -0,0 +1,53 @@
+import { Directive, Inject, Injector, Optional } from '@angular/core';
+import { Viewport } from '@wm/core';
+import { StylableComponent } from '../base/stylable.component';
+import { registerProps } from './partial.props';
+import { provideAsWidgetRef } from '../../../utils/widget-utils';
+import { assign } from "lodash-es";
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/core";
+const DEFAULT_CLS = 'app-partial clearfix';
+const WIDGET_CONFIG = { widgetType: 'wm-partial', hostClass: DEFAULT_CLS };
+export class PartialDirective extends StylableComponent {
+    static { this.initializeProps = registerProps(); }
+    constructor(inj, viewport, explicitContext) {
+        super(inj, WIDGET_CONFIG, explicitContext);
+        this.viewport = viewport;
+        this.registerDestroyListener(this.viewport.subscribe("resize" /* ViewportEvent.RESIZE */, data => this.callback('resize', data)));
+        this.registerDestroyListener(this.viewport.subscribe("orientationchange" /* ViewportEvent.ORIENTATION_CHANGE */, data => this.callback('orientationchange', data)));
+    }
+    callback(eventName, locals) {
+        locals = assign({ widget: this }, locals);
+        this.invokeEventCallback(eventName, locals);
+    }
+    ngOnAttach() {
+        this.callback('attach');
+    }
+    ngOnDetach() {
+        this.callback('detach');
+    }
+    ngOnDestroy() {
+        this.callback('destroy');
+        super.ngOnDestroy();
+    }
+    static { this.ɵfac = function PartialDirective_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || PartialDirective)(i0.ɵɵdirectiveInject(i0.Injector), i0.ɵɵdirectiveInject(i1.Viewport), i0.ɵɵdirectiveInject('EXPLICIT_CONTEXT', 8)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PartialDirective, selectors: [["", "wmPartial", ""]], standalone: true, features: [i0.ɵɵProvidersFeature([
+                provideAsWidgetRef(PartialDirective)
+            ]), i0.ɵɵInheritDefinitionFeature] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PartialDirective, [{
+        type: Directive,
+        args: [{
+                standalone: true,
+                selector: '[wmPartial]',
+                providers: [
+                    provideAsWidgetRef(PartialDirective)
+                ]
+            }]
+    }], () => [{ type: i0.Injector }, { type: i1.Viewport }, { type: undefined, decorators: [{
+                type: Inject,
+                args: ['EXPLICIT_CONTEXT']
+            }, {
+                type: Optional
+            }] }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/components/base/esm2022/widgets/common/partial/partial.props.mjs

@@ -0,0 +1,7 @@
+import { PROP_STRING, register } from '../../framework/widget-props';
+export const registerProps = () => {
+    register('wm-partial', new Map([
+        ['name', PROP_STRING]
+    ]));
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFydGlhbC5wcm9wcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvYmFzZS9zcmMvd2lkZ2V0cy9jb21tb24vcGFydGlhbC9wYXJ0aWFsLnByb3BzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsUUFBUSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFckUsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLEdBQUcsRUFBRTtJQUM5QixRQUFRLENBQ0osWUFBWSxFQUNaLElBQUksR0FBRyxDQUNIO1FBQ0ksQ0FBQyxNQUFNLEVBQUUsV0FBVyxDQUFDO0tBQ3hCLENBQ0osQ0FDSixDQUFDO0FBQ04sQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUFJPUF9TVFJJTkcsIHJlZ2lzdGVyIH0gZnJvbSAnLi4vLi4vZnJhbWV3b3JrL3dpZGdldC1wcm9wcyc7XG5cbmV4cG9ydCBjb25zdCByZWdpc3RlclByb3BzID0gKCkgPT4ge1xuICAgIHJlZ2lzdGVyKFxuICAgICAgICAnd20tcGFydGlhbCcsXG4gICAgICAgIG5ldyBNYXAoXG4gICAgICAgICAgICBbXG4gICAgICAgICAgICAgICAgWyduYW1lJywgUFJPUF9TVFJJTkddXG4gICAgICAgICAgICBdXG4gICAgICAgIClcbiAgICApO1xufTtcbiJdfQ==