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

package/components/data/list/esm2022/index.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL3dpZGdldHMvZGF0YS9saXN0L3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpY19hcGknO1xuIl19

package/components/data/list/esm2022/list-item.directive.mjs

@@ -0,0 +1,260 @@
+import { __decorate, __metadata } from "tslib";
+import { Directive, ElementRef, HostBinding, HostListener, Inject, inject, Injector, Input, Optional, Renderer2, ViewContainerRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { $watch, App } from '@wm/core';
+import { ListComponent } from './list.component';
+import { APPLY_STYLES_TYPE, AutoLayout, StylableComponent, styler, widgetIdGenerator } from "@wm/components/base";
+import { BaseFormComponent } from "@wm/components/input/base-form";
+import { registerProps } from './list-item.props';
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/core";
+/********* Will come to this later for listtemplate = container variant **********/
+// const DEFAULT_CLS = 'app-container';
+// const WIDGET_CONFIG = { widgetType: 'wm-listtemplate', hostClass: DEFAULT_CLS};
+const WIDGET_CONFIG = { widgetType: 'wm-listtemplate' };
+let ListItemDirective = class ListItemDirective extends StylableComponent {
+    static { this.initializeProps = registerProps(); }
+    onFocus() {
+        // maintains which element is focused/selected most recently.
+        this.listComponent.lastSelectedItem = this;
+    }
+    get $index() {
+        return this.context.$index;
+    }
+    get $even() {
+        return this.context.even;
+    }
+    get $odd() {
+        return this.context.odd;
+    }
+    get $first() {
+        return this.context.first;
+    }
+    get $last() {
+        return this.context.last;
+    }
+    get currentItemWidgets() {
+        const componentElements = Array.from(this.nativeElement.querySelectorAll('[widget-id]'));
+        return Object.assign(this._currentItemWidgets, componentElements.reduce((result, comp) => {
+            result[comp.widget.name] = comp.widget;
+            return result;
+        }, {}));
+    }
+    set wmListItem(val) {
+        this.item = val;
+    }
+    constructor(inj, elRef, app, renderer, explicitContext) {
+        super(inj, WIDGET_CONFIG, explicitContext);
+        this.app = app;
+        this.renderer = renderer;
+        this.destroySub = new Subject();
+        this.destroy$ = this.destroySub.asObservable();
+        this.itemClass = '';
+        this._currentItemWidgets = {};
+        /**
+         * To avoid re-rendering of widget, passing unique id as contextKey to createCustomInjector
+         */
+        this.trackId = widgetIdGenerator.nextUid();
+        this.isActive = false;
+        this.disableItem = false;
+        this._viewParent = inject(ListComponent, { optional: true });
+        // addClass(this.nativeElement, DEFAULT_CLS); // Will come to this later for listtemplate = container variant
+        styler(this.nativeElement, this, APPLY_STYLES_TYPE.CONTAINER);
+        this.viewContainerRef = inj.get(ViewContainerRef);
+        this.nativeElement = elRef.nativeElement;
+        this.listComponent = this._viewParent;
+        // this.context = (<NgForOfContext<ListItemDirective>>(<any>inj).view.context);
+        this.context = this.inj._lView[8];
+        //this.context = (this.viewContainerRef as any)._hostLView.find(t => t && !!t.$implicit);
+        this.itemClassWatcher(this.listComponent);
+        this.disableItemWatcher(this.listComponent);
+        this.itemAttrsHandler();
+        $(this.nativeElement).data('listItemContext', this);
+    }
+    /**
+    * Applies all the list item attributes and adds a watch on postion attribute
+    */
+    itemAttrsHandler() {
+        const attrsMap = this.listComponent.itemAttrsMap;
+        if (!attrsMap) {
+            return;
+        }
+        Object.keys(attrsMap).forEach(key => {
+            const value = attrsMap[key];
+            this.setProperty(key, value);
+        });
+    }
+    registerWatch(expression, callback) {
+        // Removing ngFor context as the same properties are availble on listitem scope.
+        // passing viewparent context for accessing varibales and widgets.
+        //[CSP]: expression will be generated in the component as e.g. 'item.className'
+        this.destroy$.subscribe($watch(expression, this.listComponent.viewParent, this, callback));
+    }
+    itemClassWatcher(listComponent) {
+        if (listComponent.binditemclass) {
+            this.registerWatch(listComponent.binditemclass, nv => this.itemClass = nv || '');
+        }
+        else {
+            this.itemClass = listComponent.itemclass;
+        }
+    }
+    disableItemWatcher($list) {
+        if ($list.binddisableitem) {
+            this.registerWatch($list.binddisableitem, nv => this.disableItem = nv || false);
+        }
+        else {
+            this.disableItem = $list.disableitem || false;
+        }
+    }
+    setUpCUDHandlers() {
+        const $editItem = this.nativeElement.querySelector('.edit-list-item');
+        const $deleteItem = this.nativeElement.querySelector('.delete-list-item');
+        if ($editItem) {
+            // MEMORY LEAK FIX: Store bound handler for cleanup
+            this.boundEditHandler = (evt) => {
+                this.listComponent.update();
+            };
+            // Triggered on click of edit action
+            $editItem.addEventListener('click', this.boundEditHandler);
+        }
+        if ($deleteItem) {
+            // MEMORY LEAK FIX: Store bound handler for cleanup
+            this.boundDeleteHandler = (evt) => {
+                this.listComponent.delete();
+            };
+            // Triggered on click of delete action
+            $deleteItem.addEventListener('click', this.boundDeleteHandler);
+        }
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        if (this.listComponent.mouseEnterCB) {
+            // MEMORY LEAK FIX: Store bound handler for cleanup
+            this.boundMouseEnterHandler = ($event) => {
+                this.listComponent.invokeEventCallback('mouseenter', { widget: this, $event });
+            };
+            this.nativeElement.addEventListener('mouseenter', this.boundMouseEnterHandler);
+        }
+        if (this.listComponent.mouseLeaveCB) {
+            // MEMORY LEAK FIX: Store bound handler for cleanup
+            this.boundMouseLeaveHandler = ($event) => {
+                this.listComponent.invokeEventCallback('mouseleave', { widget: this, $event });
+            };
+            this.nativeElement.addEventListener('mouseleave', this.boundMouseLeaveHandler);
+        }
+        // adding item attribute on every list item
+        $(this.nativeElement).attr('listitemindex', this.$index);
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        this.setUpCUDHandlers();
+        const componentElements = Array.from(this.nativeElement.querySelectorAll('[widget-id]'));
+        componentElements.forEach((component) => {
+            if (component.widget instanceof BaseFormComponent) {
+                if (!component.widget.$attrs.get('datavaluesource.bind')) {
+                    component.widget.datavaluesource = this.listComponent['datasource'];
+                }
+            }
+        });
+    }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Remove event listeners
+        if (this.boundMouseEnterHandler && this.nativeElement) {
+            try {
+                this.nativeElement.removeEventListener('mouseenter', this.boundMouseEnterHandler);
+            }
+            catch (e) {
+                // Silently handle cleanup errors
+            }
+            this.boundMouseEnterHandler = null;
+        }
+        if (this.boundMouseLeaveHandler && this.nativeElement) {
+            try {
+                this.nativeElement.removeEventListener('mouseleave', this.boundMouseLeaveHandler);
+            }
+            catch (e) {
+                // Silently handle cleanup errors
+            }
+            this.boundMouseLeaveHandler = null;
+        }
+        if (this.nativeElement) {
+            const $editItem = this.nativeElement.querySelector('.edit-list-item');
+            if ($editItem && this.boundEditHandler) {
+                try {
+                    $editItem.removeEventListener('click', this.boundEditHandler);
+                }
+                catch (e) {
+                    // Silently handle cleanup errors
+                }
+                this.boundEditHandler = null;
+            }
+            const $deleteItem = this.nativeElement.querySelector('.delete-list-item');
+            if ($deleteItem && this.boundDeleteHandler) {
+                try {
+                    $deleteItem.removeEventListener('click', this.boundDeleteHandler);
+                }
+                catch (e) {
+                    // Silently handle cleanup errors
+                }
+                this.boundDeleteHandler = null;
+            }
+        }
+        // MEMORY LEAK FIX: Clear context to release references
+        if (this.context) {
+            Object.keys(this.context).forEach(key => {
+                delete this.context[key];
+            });
+            this.context = null;
+        }
+        // MEMORY LEAK FIX: Clear ViewContainerRef reference
+        if (this.viewContainerRef) {
+            this.viewContainerRef = null;
+        }
+        // MEMORY LEAK FIX: Complete the destroy subject
+        if (this.destroySub) {
+            try {
+                if (!this.destroySub.closed) {
+                    this.destroySub.next(null);
+                    this.destroySub.complete();
+                }
+            }
+            catch (e) {
+                // Silently handle cleanup errors
+            }
+            this.destroySub = null;
+        }
+        super.ngOnDestroy();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ListItemDirective, deps: [{ token: i0.Injector }, { token: i0.ElementRef }, { token: i1.App }, { token: i0.Renderer2 }, { token: 'EXPLICIT_CONTEXT', optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: ListItemDirective, isStandalone: true, selector: "[wmListItem]", inputs: { wmListItem: "wmListItem" }, host: { listeners: { "focus": "onFocus()" }, properties: { "class.active": "this.isActive", "class.disable-item": "this.disableItem" } }, exportAs: ["listItemRef"], usesInheritance: true, ngImport: i0 }); }
+};
+ListItemDirective = __decorate([
+    AutoLayout({ bindParent: 'listComponent.viewParent' }),
+    __metadata("design:paramtypes", [Injector, ElementRef, App, Renderer2, Object])
+], ListItemDirective);
+export { ListItemDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ListItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[wmListItem]',
+                    exportAs: 'listItemRef'
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ElementRef }, { type: i1.App }, { type: i0.Renderer2 }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['EXPLICIT_CONTEXT']
+                }, {
+                    type: Optional
+                }] }], propDecorators: { isActive: [{
+                type: HostBinding,
+                args: ['class.active']
+            }], disableItem: [{
+                type: HostBinding,
+                args: ['class.disable-item']
+            }], onFocus: [{
+                type: HostListener,
+                args: ['focus']
+            }], wmListItem: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-item.directive.js","sourceRoot":"","sources":["../../../../../projects/components/widgets/data/list/src/list-item.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterViewInit,\n    Directive,\n    ElementRef,\n    HostBinding,\n    HostListener,\n    Inject,\n    inject,\n    Injector,\n    Input,\n    OnDestroy,\n    OnInit,\n    Optional,\n    Renderer2,\n    ViewContainerRef\n} from '@angular/core';\n\nimport {Observable, Subject} from 'rxjs';\n\nimport {$watch, addClass, App} from '@wm/core';\n\nimport {ListComponent} from './list.component';\nimport {APPLY_STYLES_TYPE, AutoLayout, StylableComponent, styler, widgetIdGenerator} from \"@wm/components/base\";\nimport {BaseFormComponent} from \"@wm/components/input/base-form\";\nimport { registerProps } from './list-item.props';\n\ndeclare const $;\n/********* Will come to this later for listtemplate = container variant **********/\n// const DEFAULT_CLS = 'app-container';\n// const WIDGET_CONFIG = { widgetType: 'wm-listtemplate', hostClass: DEFAULT_CLS};\n\nconst WIDGET_CONFIG = { widgetType: 'wm-listtemplate'};\n\n@AutoLayout({ bindParent: 'listComponent.viewParent' })\n@Directive({\n  standalone: true,\n    selector: '[wmListItem]',\n    exportAs: 'listItemRef'\n})\nexport class ListItemDirective  extends StylableComponent implements OnInit, AfterViewInit, OnDestroy {\n\n    static initializeProps = registerProps();\n\n    public item;\n    public context;\n    public destroySub: Subject<any> = new Subject();\n    public destroy$: Observable<any> = this.destroySub.asObservable();\n    public nativeElement: HTMLElement;\n    public readonly listComponent: ListComponent;\n\n    private itemClass = '';\n    private _currentItemWidgets = {};\n    viewContainerRef: ViewContainerRef;\n    /**\n     * To avoid re-rendering of widget, passing unique id as contextKey to createCustomInjector\n     */\n    trackId = widgetIdGenerator.nextUid();\n\n    @HostBinding('class.active') isActive = false;\n    @HostBinding('class.disable-item') disableItem = false;\n\n    @HostListener('focus')\n    onFocus() {\n        // maintains which element is focused/selected most recently.\n        this.listComponent.lastSelectedItem = this;\n    }\n\n    get $index() {\n        return this.context.$index;\n    }\n\n    get $even() {\n        return this.context.even;\n    }\n\n    get $odd() {\n        return this.context.odd;\n    }\n\n    get $first() {\n        return this.context.first;\n    }\n\n    get $last() {\n        return this.context.last;\n    }\n\n    get currentItemWidgets () {\n        const componentElements = Array.from(this.nativeElement.querySelectorAll('[widget-id]'));\n        return Object.assign(this._currentItemWidgets, componentElements.reduce((result, comp: any) => {\n            result[comp.widget.name] = comp.widget;\n            return result;\n        }, {}));\n    }\n\n    @Input() set wmListItem(val) {\n        this.item = val;\n    }\n    private _viewParent = inject(ListComponent, {optional: true});\n    constructor(inj: Injector, elRef: ElementRef, public app: App, private renderer: Renderer2, @Inject('EXPLICIT_CONTEXT') @Optional() explicitContext: any) {\n        super(inj, WIDGET_CONFIG, explicitContext);\n        // addClass(this.nativeElement, DEFAULT_CLS); // Will come to this later for listtemplate = container variant\n        styler(this.nativeElement, this, APPLY_STYLES_TYPE.CONTAINER);\n\n        this.viewContainerRef = inj.get(ViewContainerRef);\n        this.nativeElement = elRef.nativeElement;\n        this.listComponent = this._viewParent;\n        // this.context = (<NgForOfContext<ListItemDirective>>(<any>inj).view.context);\n        this.context = (this.inj as any)._lView[8];\n        //this.context = (this.viewContainerRef as any)._hostLView.find(t => t && !!t.$implicit);\n        this.itemClassWatcher(this.listComponent);\n        this.disableItemWatcher(this.listComponent);\n\n        this.itemAttrsHandler();\n\n        $(this.nativeElement).data('listItemContext', this);\n    }\n\n    /**\n    * Applies all the list item attributes and adds a watch on postion attribute\n    */\n    private itemAttrsHandler() {\n        const attrsMap = this.listComponent.itemAttrsMap;\n        \n        if (!attrsMap) {\n            return;\n        }\n\n        Object.keys(attrsMap).forEach(key => {\n            const value = attrsMap[key];\n            this.setProperty(key, value);\n        });\n    }\n\n    private registerWatch(expression: string, callback: Function) {\n        // Removing ngFor context as the same properties are availble on listitem scope.\n        // passing viewparent context for accessing varibales and widgets.\n        //[CSP]: expression will be generated in the component as e.g. 'item.className'\n        this.destroy$.subscribe($watch(expression, (this.listComponent as any).viewParent, this, callback));\n    }\n\n    private itemClassWatcher(listComponent: ListComponent) {\n        if (listComponent.binditemclass) {\n            this.registerWatch(listComponent.binditemclass, nv => this.itemClass = nv || '');\n        } else {\n            this.itemClass = listComponent.itemclass;\n        }\n    }\n\n    private disableItemWatcher($list: ListComponent) {\n        if ($list.binddisableitem) {\n            this.registerWatch($list.binddisableitem, nv => this.disableItem = nv || false);\n        } else {\n            this.disableItem = $list.disableitem || false;\n        }\n    }\n\n    private boundEditHandler: (event: Event) => void;\n    private boundDeleteHandler: (event: Event) => void;\n    private boundMouseEnterHandler: (event: Event) => void;\n    private boundMouseLeaveHandler: (event: Event) => void;\n\n    private setUpCUDHandlers() {\n        const $editItem = this.nativeElement.querySelector('.edit-list-item');\n        const $deleteItem = this.nativeElement.querySelector('.delete-list-item');\n\n        if ($editItem) {\n            // MEMORY LEAK FIX: Store bound handler for cleanup\n            this.boundEditHandler = (evt: Event) => {\n                this.listComponent.update();\n            };\n            // Triggered on click of edit action\n            $editItem.addEventListener('click', this.boundEditHandler);\n        }\n\n        if ($deleteItem) {\n            // MEMORY LEAK FIX: Store bound handler for cleanup\n            this.boundDeleteHandler = (evt: Event) => {\n                this.listComponent.delete();\n            };\n            // Triggered on click of delete action\n            $deleteItem.addEventListener('click', this.boundDeleteHandler);\n        }\n    }\n    ngOnInit() {\n        super.ngOnInit();\n        if (this.listComponent.mouseEnterCB) {\n            // MEMORY LEAK FIX: Store bound handler for cleanup\n            this.boundMouseEnterHandler = ($event: Event) => {\n                this.listComponent.invokeEventCallback('mouseenter', {widget: this, $event});\n            };\n            this.nativeElement.addEventListener('mouseenter', this.boundMouseEnterHandler);\n        }\n        if (this.listComponent.mouseLeaveCB) {\n            // MEMORY LEAK FIX: Store bound handler for cleanup\n            this.boundMouseLeaveHandler = ($event: Event) => {\n                this.listComponent.invokeEventCallback('mouseleave', {widget: this, $event});\n            };\n            this.nativeElement.addEventListener('mouseleave', this.boundMouseLeaveHandler);\n        }\n        // adding item attribute on every list item\n        $(this.nativeElement).attr('listitemindex', this.$index);\n    }\n\n    ngAfterViewInit() {\n        super.ngAfterViewInit();\n        this.setUpCUDHandlers();\n        const componentElements = Array.from(this.nativeElement.querySelectorAll('[widget-id]'));\n        componentElements.forEach((component: any) => {\n            if(component.widget instanceof BaseFormComponent) {\n                if(!component.widget.$attrs.get('datavaluesource.bind')) {\n                    component.widget.datavaluesource = this.listComponent['datasource'];\n                }\n            }\n        });\n    }\n\n    ngOnDestroy() {\n        // MEMORY LEAK FIX: Remove event listeners\n        if (this.boundMouseEnterHandler && this.nativeElement) {\n            try {\n                this.nativeElement.removeEventListener('mouseenter', this.boundMouseEnterHandler);\n            } catch (e) {\n                // Silently handle cleanup errors\n            }\n            this.boundMouseEnterHandler = null;\n        }\n        if (this.boundMouseLeaveHandler && this.nativeElement) {\n            try {\n                this.nativeElement.removeEventListener('mouseleave', this.boundMouseLeaveHandler);\n            } catch (e) {\n                // Silently handle cleanup errors\n            }\n            this.boundMouseLeaveHandler = null;\n        }\n\n        if (this.nativeElement) {\n            const $editItem = this.nativeElement.querySelector('.edit-list-item');\n            if ($editItem && this.boundEditHandler) {\n                try {\n                    $editItem.removeEventListener('click', this.boundEditHandler);\n                } catch (e) {\n                    // Silently handle cleanup errors\n                }\n                this.boundEditHandler = null;\n            }\n\n            const $deleteItem = this.nativeElement.querySelector('.delete-list-item');\n            if ($deleteItem && this.boundDeleteHandler) {\n                try {\n                    $deleteItem.removeEventListener('click', this.boundDeleteHandler);\n                } catch (e) {\n                    // Silently handle cleanup errors\n                }\n                this.boundDeleteHandler = null;\n            }\n        }\n\n        // MEMORY LEAK FIX: Clear context to release references\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 ViewContainerRef reference\n        if (this.viewContainerRef) {\n            this.viewContainerRef = null;\n        }\n\n        // MEMORY LEAK FIX: Complete the destroy subject\n        if (this.destroySub) {\n            try {\n                if (!this.destroySub.closed) {\n                    this.destroySub.next(null);\n                    this.destroySub.complete();\n                }\n            } catch (e) {\n                // Silently handle cleanup errors\n            }\n            this.destroySub = null;\n        }\n\n        super.ngOnDestroy();\n    }\n}\n"]}

package/components/data/list/esm2022/list-item.props.mjs

@@ -0,0 +1,7 @@
+import { AUTO_LAYOUT_PROPS, register } from '@wm/components/base';
+export const registerProps = () => {
+    register('wm-listtemplate', new Map([
+        ...AUTO_LAYOUT_PROPS
+    ]));
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC1pdGVtLnByb3BzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29tcG9uZW50cy93aWRnZXRzL2RhdGEvbGlzdC9zcmMvbGlzdC1pdGVtLnByb3BzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxpQkFBaUIsRUFBRSxRQUFRLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUVoRSxNQUFNLENBQUMsTUFBTSxhQUFhLEdBQUcsR0FBRyxFQUFFO0lBQzlCLFFBQVEsQ0FDSixpQkFBaUIsRUFDakIsSUFBSSxHQUFHLENBQ0g7UUFDSSxHQUFHLGlCQUFpQjtLQUN2QixDQUNKLENBQ0osQ0FBQztBQUNOLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7QVVUT19MQVlPVVRfUFJPUFMsIHJlZ2lzdGVyfSBmcm9tICdAd20vY29tcG9uZW50cy9iYXNlJztcblxuZXhwb3J0IGNvbnN0IHJlZ2lzdGVyUHJvcHMgPSAoKSA9PiB7XG4gICAgcmVnaXN0ZXIoXG4gICAgICAgICd3bS1saXN0dGVtcGxhdGUnLFxuICAgICAgICBuZXcgTWFwKFxuICAgICAgICAgICAgW1xuICAgICAgICAgICAgICAgIC4uLkFVVE9fTEFZT1VUX1BST1BTXG4gICAgICAgICAgICBdXG4gICAgICAgIClcbiAgICApO1xufTtcbiJdfQ==

package/components/data/list/esm2022/list.animator.mjs

@@ -0,0 +1,233 @@
+import { SwipeAnimation } from '@swipey';
+import { map, reduce } from "lodash-es";
+export class ListAnimator extends SwipeAnimation {
+    constructor(list) {
+        super();
+        this.list = list;
+        this.$el = $(this.list.getNativeElement()).find('ul.app-livelist-container').first();
+        this.leftChildrenCount = this.$el.find('>.app-list-item-left-action-panel > button:visible').length;
+        this.rightChildrenCount = this.$el.find('>.app-list-item-right-action-panel > button:visible').length;
+        // when there are no children in both the templates then do not apply swipeAnimation;
+        if (!this.leftChildrenCount && !this.rightChildrenCount) {
+            return;
+        }
+        // initialise swipe animation on the list component.
+        this.init(this.$el);
+        // retrieves all the button components which are placed outside the listTemplate.
+        this.$btnSubscription = this.list.btnComponents.changes.subscribe(items => this.actionItems = items);
+    }
+    // This method sets the css for left or right action panels based on the template. Appends the actionTemplate before li.
+    createActionPanel(li, actionPanelTemplate) {
+        actionPanelTemplate.css({
+            width: li.outerWidth() + 'px',
+            height: li.outerHeight() + 'px',
+            marginBottom: -1 * li.outerHeight() + 'px',
+            float: 'left',
+            padding: 0
+        });
+        return actionPanelTemplate.insertBefore(li);
+    }
+    // Returns the total width occupied by all the children inside the element
+    computeTotalChildrenWidth($ele) {
+        return reduce($ele.children(), (totalWidth, el) => {
+            return totalWidth + $(el).outerWidth();
+        }, 0);
+    }
+    // Returns amount of transition to be applied on element when swiped left or right
+    computeTransitionProportions($ele) {
+        const totalWidth = this.computeTotalChildrenWidth($ele);
+        const reverse = this.position === 'right';
+        let d = 0;
+        // @ts-ignore
+        return map($ele.children(), e => {
+            const f = (totalWidth - d) / totalWidth;
+            d += $(e).outerWidth();
+            return reverse ? f : (d / totalWidth);
+        });
+    }
+    // Resets the transform applied on the element.
+    resetElement(el) {
+        if (el) {
+            el.css({
+                transform: 'none',
+                transition: 'none'
+            });
+        }
+    }
+    resetState() {
+        this.resetElement(this.li);
+        this.resetElement(this.actionPanel);
+        if (this.actionPanel) {
+            this.actionPanel = null;
+        }
+    }
+    // Returns the target button (child element) inside the left and right actionPanels.
+    getChildActionElement(actionTemplate) {
+        if (actionTemplate.children().length) {
+            if (this.position === 'left') {
+                return actionTemplate.children().first();
+            }
+            return actionTemplate.children().last();
+        }
+    }
+    // create the actionPanels and set the background-color for remaining panel as that of first child element
+    // calculates the children's width and its transition proportionates.
+    initActionPanel(actionTemplate) {
+        this.actionPanel = this.createActionPanel(this.li, actionTemplate);
+        this.actionPanel.css({
+            backgroundColor: this.getChildActionElement(this.actionPanel).css('background-color')
+        });
+        this.limit = this.computeTotalChildrenWidth(this.actionPanel);
+        this.transitionProportions = this.computeTransitionProportions(this.actionPanel);
+    }
+    bounds(e, $d) {
+        const target = $(e.target).closest('li');
+        // default bounds when action template markup is not available.
+        let bounds = {
+            strictUpper: true,
+            strictLower: true,
+            lower: 0,
+            center: 0,
+            upper: 0
+        };
+        // apply swipe animation only on list items having "app-list-item" class.
+        if (!target.hasClass('app-list-item')) {
+            return bounds;
+        }
+        if (!this.li || this.li[0] !== target[0]) {
+            let selector = $d > 0 ? '.app-list-item-left-action-panel' : '.app-list-item-right-action-panel';
+            let actionTemplate = this.$el.find('>' + selector);
+            // when groupby is set select the action panel from the list group items.
+            if (!actionTemplate.length && this.list.groupby) {
+                selector = 'li > ul.list-group >' + selector;
+                actionTemplate = this.$el.find('>' + selector);
+            }
+            // check for children visiblity. If children are visible then initiate the action panel.
+            if (!actionTemplate.length || !actionTemplate.find('button:visible').length) {
+                return bounds;
+            }
+            this.resetState();
+            this.li = target;
+            this.position = actionTemplate.attr('position');
+            this.initActionPanel(actionTemplate);
+            if ($d > 0) {
+                // bounds while swiping from right to left to open left action panel. It can be moved upto limit value (Upper bound).
+                bounds = {
+                    strictUpper: false,
+                    lower: 0,
+                    center: 0,
+                    upper: this.limit
+                };
+            }
+            else {
+                // bounds while swiping from left to right to open right action panel. It can be moved in reverse direction with -limit value (lower bound).
+                bounds = {
+                    strictLower: false,
+                    lower: -this.limit,
+                    center: 0,
+                    upper: 0
+                };
+            }
+        }
+        else if (this.position === 'left') {
+            // when left action panel is visible (i.e. center at limit value) then this can be moved by distance (limit) in reverse direction to close the view.
+            bounds = {
+                strictUpper: false,
+                lower: -this.limit,
+                center: this.limit
+            };
+        }
+        else if (this.position === 'right') {
+            // when right action panel is visible (i.e. center at -limit value) then this can be moved by distance (limit) to close the view.
+            bounds = {
+                center: -this.limit,
+                upper: this.limit,
+                strictLower: false
+            };
+        }
+        return bounds;
+    }
+    context() {
+        return {
+            computeActionTransition: (index, $d) => {
+                const sign = $d > 0 ? 1 : -1;
+                if (sign * $d > this.limit) {
+                    // once the distance swiped is beyond the limit, then calculate the proportionate distance moved after the limit value.
+                    return ($d - sign * this.limit) + (this.transitionProportions[index] * sign * this.limit);
+                }
+                return this.transitionProportions[index] * $d;
+            }
+        };
+    }
+    animation() {
+        return [{
+                target: () => this.li,
+                css: {
+                    transform: 'translate3d(${{$D + $d}}px, 0, 0)'
+                }
+            }, {
+                target: () => (this.actionPanel && this.actionPanel.children()),
+                css: {
+                    transform: 'translate3d(${{computeActionTransition($i, $D + $d)}}px, 0, 0)'
+                }
+            }];
+    }
+    // Triggers full swipe event on the target element.
+    invokeFullSwipeEvt($event) {
+        let target, actions, index;
+        // Check if button are visible or not, invoke the tap event of the last button which is visible.
+        if (this.position === 'left') {
+            actions = this.actionItems.filter(btn => {
+                return btn.getAttr('swipe-position') === 'left' && btn.$element.is(':visible');
+            });
+            index = 0;
+        }
+        else {
+            actions = this.actionItems.filter(btn => {
+                return btn.getAttr('swipe-position') === 'right' && btn.$element.is(':visible');
+            });
+            index = actions.length - 1;
+        }
+        target = actions[index];
+        if (target && target.hasEventCallback('tap')) {
+            target.invokeEventCallback('tap', { $event });
+        }
+        this.resetState();
+        this.li = null;
+    }
+    // Called when swipeEnd is triggered. d contains the total distance covered by the element until touchEnd.
+    onAnimation($event, d) {
+        // set the selecteditem on the list component on swipe.
+        this.list.triggerListItemSelection(this.li, $event);
+        if (this.actionPanel && this.actionPanel.attr('enablefullswipe') === 'true') {
+            const sign = d > 0 ? 1 : -1;
+            const $el = this.getChildActionElement(this.actionPanel);
+            if ($el) {
+                const index = this.position === 'right' ? this.rightChildrenCount - 1 : 0;
+                // proportionate amount of distance covered by the target element.
+                const distPercentage = this.transitionProportions[index] * sign * d * 100 / (this.li.outerWidth() - this.limit + $el.width());
+                // If distance travelled by the target button element is more than 50% of the list item width then invoke the fullswipe.
+                if (distPercentage > 50) {
+                    // invoke fullswipe event
+                    this.invokeFullSwipeEvt($event);
+                }
+            }
+        }
+    }
+    onLower() {
+        if (this.position === 'left') {
+            this.resetState();
+            this.li = null;
+        }
+    }
+    onUpper() {
+        if (this.position === 'right') {
+            this.resetState();
+            this.li = null;
+        }
+    }
+    threshold() {
+        return 10;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.animator.js","sourceRoot":"","sources":["../../../../../projects/components/widgets/data/list/src/list.animator.ts"],"names":[],"mappings":"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","sourcesContent":["import { QueryList } from '@angular/core';\nimport { Subscription } from 'rxjs';\n\nimport { SwipeAnimation } from '@swipey';\nimport { ButtonComponent } from '@wm/components/input/button';\n\nimport { ListComponent } from './list.component';\nimport {map, reduce} from \"lodash-es\";\n\ndeclare const $;\n\nexport class ListAnimator extends SwipeAnimation {\n    private $el: JQuery<HTMLElement>;\n    private li: JQuery<HTMLElement>;\n    private limit: number;\n    private transitionProportions: any;\n    private rightChildrenCount: number;\n    private leftChildrenCount: number;\n    private position: string;\n    private actionPanel: JQuery<HTMLElement>;\n    private actionItems: QueryList<ButtonComponent>;\n    public $btnSubscription: Subscription;\n\n    constructor(private list: ListComponent) {\n        super();\n        this.$el = $(this.list.getNativeElement()).find('ul.app-livelist-container').first();\n\n        this.leftChildrenCount = this.$el.find('>.app-list-item-left-action-panel > button:visible').length;\n        this.rightChildrenCount = this.$el.find('>.app-list-item-right-action-panel > button:visible').length;\n\n        // when there are no children in both the templates then do not apply swipeAnimation;\n        if (!this.leftChildrenCount && !this.rightChildrenCount) {\n            return;\n        }\n\n        // initialise swipe animation on the list component.\n        this.init(this.$el);\n\n        // retrieves all the button components which are placed outside the listTemplate.\n        this.$btnSubscription = this.list.btnComponents.changes.subscribe(items => this.actionItems = items);\n    }\n\n    // This method sets the css for left or right action panels based on the template. Appends the actionTemplate before li.\n    private createActionPanel(li: JQuery<HTMLElement>, actionPanelTemplate: JQuery<HTMLElement>): JQuery<HTMLElement> {\n        actionPanelTemplate.css({\n            width: li.outerWidth() + 'px',\n            height: li.outerHeight() + 'px',\n            marginBottom: -1 * li.outerHeight() + 'px',\n            float: 'left',\n            padding: 0\n        });\n\n        return actionPanelTemplate.insertBefore(li);\n    }\n\n    // Returns the total width occupied by all the children inside the element\n    private computeTotalChildrenWidth($ele: JQuery<HTMLElement>): number {\n        return reduce($ele.children(), (totalWidth, el) => {\n            return totalWidth + $(el).outerWidth();\n        }, 0);\n    }\n\n    // Returns amount of transition to be applied on element when swiped left or right\n    private computeTransitionProportions($ele: JQuery<HTMLElement>): number {\n        const totalWidth = this.computeTotalChildrenWidth($ele);\n        const reverse = this.position === 'right';\n        let d = 0;\n        // @ts-ignore\n        return map($ele.children(), e => {\n            const f = (totalWidth - d) / totalWidth;\n            d += $(e).outerWidth();\n            return reverse ? f : (d / totalWidth);\n        });\n    }\n\n    // Resets the transform applied on the element.\n    private resetElement(el: JQuery<HTMLElement>): void {\n        if (el) {\n            el.css({\n                transform: 'none',\n                transition: 'none'\n            });\n        }\n    }\n\n    private resetState(): void {\n        this.resetElement(this.li);\n        this.resetElement(this.actionPanel);\n        if (this.actionPanel) {\n            this.actionPanel = null;\n        }\n    }\n\n    // Returns the target button (child element) inside the left and right actionPanels.\n    private getChildActionElement(actionTemplate): JQuery<HTMLElement> {\n        if (actionTemplate.children().length) {\n            if (this.position === 'left') {\n                return actionTemplate.children().first();\n            }\n            return actionTemplate.children().last();\n        }\n    }\n\n    // create the actionPanels and set the background-color for remaining panel as that of first child element\n    // calculates the children's width and its transition proportionates.\n    private initActionPanel(actionTemplate: JQuery<HTMLElement>): void {\n        this.actionPanel = this.createActionPanel(this.li, actionTemplate);\n        this.actionPanel.css({\n            backgroundColor: this.getChildActionElement(this.actionPanel).css('background-color')\n        });\n        this.limit = this.computeTotalChildrenWidth(this.actionPanel);\n        this.transitionProportions = this.computeTransitionProportions(this.actionPanel);\n    }\n\n    public bounds(e?: any, $d?: number): any {\n        const target = $(e.target).closest('li');\n        // default bounds when action template markup is not available.\n        let bounds: {} = {\n            strictUpper: true,\n            strictLower: true,\n            lower: 0,\n            center: 0,\n            upper: 0\n        };\n        // apply swipe animation only on list items having \"app-list-item\" class.\n        if (!target.hasClass('app-list-item')) {\n            return bounds;\n        }\n        if (!this.li || this.li[0] !== target[0]) {\n            let selector =  $d > 0 ? '.app-list-item-left-action-panel' : '.app-list-item-right-action-panel';\n            let actionTemplate = this.$el.find('>' + selector);\n\n            // when groupby is set select the action panel from the list group items.\n            if (!actionTemplate.length && this.list.groupby) {\n                selector = 'li > ul.list-group >' + selector;\n                actionTemplate = this.$el.find('>' + selector);\n            }\n\n            // check for children visiblity. If children are visible then initiate the action panel.\n            if (!actionTemplate.length || !actionTemplate.find('button:visible').length) {\n                return bounds;\n            }\n\n            this.resetState();\n            this.li = target;\n\n            this.position = actionTemplate.attr('position');\n            this.initActionPanel(actionTemplate);\n\n            if ($d > 0) {\n                // bounds while swiping from right to left to open left action panel. It can be moved upto limit value (Upper bound).\n                bounds = {\n                    strictUpper: false,\n                    lower: 0,\n                    center: 0,\n                    upper: this.limit\n                };\n            } else {\n                // bounds while swiping from left to right to open right action panel. It can be moved in reverse direction with -limit value (lower bound).\n                bounds = {\n                    strictLower: false,\n                    lower: -this.limit,\n                    center: 0,\n                    upper: 0\n                };\n            }\n        } else if (this.position === 'left') {\n            // when left action panel is visible (i.e. center at limit value) then this can be moved by distance (limit) in reverse direction to close the view.\n            bounds = {\n                strictUpper: false,\n                lower: -this.limit,\n                center: this.limit\n            };\n        } else if (this.position === 'right') {\n            // when right action panel is visible (i.e. center at -limit value) then this can be moved by distance (limit) to close the view.\n            bounds = {\n                center: -this.limit,\n                upper: this.limit,\n                strictLower: false\n            };\n        }\n        return bounds;\n    }\n\n    public context(): any {\n        return {\n            computeActionTransition: (index: number, $d: number): number => {\n                const sign = $d > 0 ? 1 : -1;\n\n                if (sign * $d > this.limit) {\n                    // once the distance swiped is beyond the limit, then calculate the proportionate distance moved after the limit value.\n                    return ($d - sign * this.limit) + (this.transitionProportions[index] * sign * this.limit);\n                }\n                return this.transitionProportions[index] * $d;\n            }\n        };\n    }\n\n    public animation(): any {\n        return [{\n            target: () => this.li,\n            css: {\n                transform: 'translate3d(${{$D + $d}}px, 0, 0)'\n            }\n        }, { // styles to be applied on the child elements of action panel\n            target: () => (this.actionPanel && this.actionPanel.children()),\n            css: {\n                transform: 'translate3d(${{computeActionTransition($i, $D + $d)}}px, 0, 0)'\n            }\n        }];\n    }\n\n    // Triggers full swipe event on the target element.\n    public invokeFullSwipeEvt($event: Event): void {\n        let target, actions, index;\n        // Check if button are visible or not, invoke the tap event of the last button which is visible.\n        if (this.position === 'left') {\n            actions = this.actionItems.filter(btn => {\n                return btn.getAttr('swipe-position') === 'left' && btn.$element.is(':visible');\n            });\n            index = 0;\n        } else {\n            actions = this.actionItems.filter(btn => {\n                return btn.getAttr('swipe-position') === 'right' && btn.$element.is(':visible');\n            });\n            index = actions.length - 1;\n        }\n        target = actions[index];\n        if (target && target.hasEventCallback('tap')) {\n            target.invokeEventCallback('tap', {$event});\n        }\n        this.resetState();\n        this.li = null;\n    }\n\n    // Called when swipeEnd is triggered. d contains the total distance covered by the element until touchEnd.\n    public onAnimation($event: Event, d: number): void {\n        // set the selecteditem on the list component on swipe.\n        this.list.triggerListItemSelection(this.li, $event);\n        if (this.actionPanel && this.actionPanel.attr('enablefullswipe') === 'true') {\n            const sign = d > 0 ? 1 : -1;\n            const $el = this.getChildActionElement(this.actionPanel);\n            if ($el) {\n                const index = this.position === 'right' ? this.rightChildrenCount - 1 : 0;\n                // proportionate amount of distance covered by the target element.\n                const distPercentage = this.transitionProportions[index] * sign * d * 100 / (this.li.outerWidth() - this.limit + $el.width());\n\n                // If distance travelled by the target button element is more than 50% of the list item width then invoke the fullswipe.\n                if (distPercentage > 50) {\n                    // invoke fullswipe event\n                    this.invokeFullSwipeEvt($event);\n                }\n            }\n        }\n    }\n\n    public onLower(): void {\n        if (this.position === 'left') {\n            this.resetState();\n            this.li = null;\n        }\n    }\n\n    public onUpper(): void {\n        if (this.position === 'right') {\n            this.resetState();\n            this.li = null;\n        }\n    }\n\n    public threshold(): number {\n        return 10;\n    }\n}\n"]}