@mediusinc/mng-commons 5.3.0-rc.1 → 5.3.0-rc.3

package/esm2022/table/components/filter/filter-overlay-with-tag/filter-overlay-with-tag.component.mjs

@@ -0,0 +1,135 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, computed, contentChildren, inject, input, signal, viewChild } from '@angular/core';
+import { TranslateModule } from '@ngx-translate/core';
+import { Button } from 'primeng/button';
+import { OverlayPanel, OverlayPanelModule } from 'primeng/overlaypanel';
+import { Table } from 'primeng/table';
+import { TagModule } from 'primeng/tag';
+import { COMMONS_MODULE_CONFIG_IT, FilterMatchMode, TemplateDirective, findTemplateByName } from '@mediusinc/mng-commons/core';
+import { filterApplySerializationConfigToCmp, filterGetDateConfig, filterSetMetadataOnChange, filterSetMetadataOnDisplayChange } from '../../../helpers/filters';
+import { DataListService } from '../../../services/data-list.service';
+import { FilterActiveTagComponent } from '../filter-active-tag/filter-active-tag.component';
+import { FilterFormComponent } from '../filter-form/filter-form.component';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/overlaypanel";
+export class FilterOverlayWithTagComponent {
+    constructor() {
+        this.primeTable = inject(Table);
+        this.dataListService = inject((DataListService));
+        this.moduleConfig = inject(COMMONS_MODULE_CONFIG_IT, { optional: true });
+        this.descriptors = input.required();
+        this.model = input.required();
+        this.filterOverlay = viewChild.required(OverlayPanel);
+        this.templates = contentChildren(TemplateDirective);
+        this.titleTemplate = computed(() => findTemplateByName([...this.templates()], 'title'));
+        this.filters = computed(() => {
+            return this.setInitialFilters(this.dataListService.filterMeta());
+        });
+        this.activeFilters = computed(() => {
+            const filterEntry = this.filters();
+            return this.descriptors()
+                .filter(d => {
+                const filter = filterEntry[d.property];
+                return (filter &&
+                    filter.matchMode !== undefined &&
+                    filter.displayMatchMode !== undefined &&
+                    (filter.matchMode === FilterMatchMode.Exists ||
+                        filter.matchMode === FilterMatchMode.DoesNotExist ||
+                        (filter.value !== undefined && filter.displayValue !== undefined)));
+            })
+                .map(d => filterEntry[d.property]);
+        });
+        this.activeFilterProperties = computed(() => this.activeFilters().map(f => f.descriptor.property));
+        this.filterEdit = signal(undefined);
+        this.serializationCfg = {};
+        // UI utilities
+        this.clickedOnFilterEvent = undefined;
+        filterApplySerializationConfigToCmp(this.moduleConfig, this.serializationCfg);
+    }
+    onFilterFormApply(event) {
+        const descriptor = this.descriptors().find(d => d.property === event.property);
+        if (!descriptor) {
+            return;
+        }
+        this.updatePrimeTableFilter({
+            ...filterSetMetadataOnDisplayChange({ caseSensitive: event.caseSensitive }, event.matchMode, event.value, descriptor.filterType, filterGetDateConfig(descriptor, this.serializationCfg)),
+            descriptor: descriptor
+        });
+        // Resetting the form is done in the onOverlayHide callback because resetting the
+        // values here renders empty inputs for a split second before closing the overlay
+        this.filterOverlay().hide();
+    }
+    onFilterRemove(event) {
+        this.updatePrimeTableFilter({
+            ...this.filters()[event.filter.descriptor.property],
+            matchMode: undefined,
+            displayMatchMode: undefined,
+            value: undefined,
+            displayValue: undefined
+        });
+    }
+    onFilterEdit(event) {
+        this.onFilterAddOrEdit(event.filter, event.event);
+    }
+    onFilterAdd(event) {
+        this.onFilterAddOrEdit(undefined, event);
+    }
+    onOverlayHide() {
+        if (this.clickedOnFilterEvent) {
+            // show the overlay again if the user clicked another filter
+            setTimeout(() => {
+                this.filterOverlay().show(this.clickedOnFilterEvent);
+                this.clickedOnFilterEvent = undefined;
+            }, 0);
+            return;
+        }
+        else {
+            // clean state
+            this.filterEdit.set(undefined);
+        }
+    }
+    onFilterAddOrEdit(filter, event) {
+        // If user clicks on the same filter or add that is already open, close the overlay
+        if (this.filterOverlay().overlayVisible && this.filterEdit()?.descriptor.property === filter?.descriptor.property) {
+            this.filterOverlay().hide();
+            this.filterEdit.set(undefined);
+            return;
+        }
+        this.filterEdit.set(filter);
+        if (this.filterOverlay().overlayVisible) {
+            // In case the user clicks another filter, 're-showing' the overlay in
+            // the new position is done in the onOverlayHide callback
+            this.clickedOnFilterEvent = event;
+            this.filterOverlay().hide();
+        }
+        else {
+            this.filterOverlay().show(event);
+        }
+    }
+    setInitialFilters(filtersInit) {
+        const filtersResult = {};
+        for (const property in filtersInit) {
+            const filterInit = filtersInit[property];
+            const descriptor = this.descriptors().find(filterDescriptor => filterDescriptor.property === property);
+            if (!descriptor) {
+                continue;
+            }
+            filtersResult[property] = {
+                ...filterSetMetadataOnChange(filterInit, filterInit.matchMode, filterInit.value, descriptor.filterType, filterGetDateConfig(descriptor, this.serializationCfg)),
+                descriptor: descriptor
+            };
+        }
+        return filtersResult;
+    }
+    updatePrimeTableFilter(filter) {
+        this.primeTable.filters[filter.descriptor.property] = { ...filter };
+        this.primeTable._filter();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: FilterOverlayWithTagComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.5", type: FilterOverlayWithTagComponent, isStandalone: true, selector: "mng-filter-overlay-with-tag", inputs: { descriptors: { classPropertyName: "descriptors", publicName: "descriptors", isSignal: true, isRequired: true, transformFunction: null }, model: { classPropertyName: "model", publicName: "model", isSignal: true, isRequired: true, transformFunction: null } }, queries: [{ propertyName: "templates", predicate: TemplateDirective, isSignal: true }], viewQueries: [{ propertyName: "filterOverlay", first: true, predicate: OverlayPanel, descendants: true, isSignal: true }], ngImport: i0, template: "<div class=\"flex align-items-center flex-grow-1\">\n    @if (titleTemplate()) {\n        <ng-container *ngTemplateOutlet=\"titleTemplate()\"></ng-container>\n    }\n    <p-button\n        icon=\"pi pi-filter\"\n        rounded=\"true\"\n        [severity]=\"activeFilters().length > 0 ? 'primary' : 'secondary'\"\n        size=\"small\"\n        (click)=\"onFilterAdd($event)\"\n        [styleClass]=\"'my-1 mr-2' + (titleTemplate() ? ' ml-3' : '')\">\n    </p-button>\n</div>\n@if (activeFilters().length > 0) {\n    <div class=\"flex align-items-center flex-wrap mt-2\">\n        @for (filter of activeFilters(); track filter.descriptor.property) {\n            <mng-filter-active-tag [model]=\"model()\" [filter]=\"filter\" (edit)=\"onFilterEdit($event)\" (remove)=\"onFilterRemove($event)\" />\n        }\n    </div>\n}\n<p-overlayPanel #op [showCloseIcon]=\"true\" (onHide)=\"onOverlayHide()\" appendTo=\"body\">\n    <mng-filter-form\n        [model]=\"model()\"\n        [descriptors]=\"descriptors()\"\n        [filter]=\"filterEdit()\"\n        [disabledProperties]=\"activeFilterProperties()\"\n        [overlay]=\"op\"\n        (apply)=\"onFilterFormApply($event)\" />\n</p-overlayPanel>\n", dependencies: [{ kind: "ngmodule", type: OverlayPanelModule }, { kind: "component", type: i1.OverlayPanel, selector: "p-overlayPanel", inputs: ["ariaLabel", "ariaLabelledBy", "dismissable", "showCloseIcon", "style", "styleClass", "appendTo", "autoZIndex", "ariaCloseLabel", "baseZIndex", "focusOnShow", "showTransitionOptions", "hideTransitionOptions"], outputs: ["onShow", "onHide"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "ngmodule", type: TagModule }, { kind: "component", type: FilterFormComponent, selector: "mng-filter-form", inputs: ["title", "descriptors", "model", "filter", "overlay", "disabledProperties"], outputs: ["apply"] }, { kind: "component", type: Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "raised", "rounded", "text", "plain", "severity", "outlined", "link", "tabindex", "size", "style", "styleClass", "badgeClass", "ariaLabel", "autofocus"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "component", type: FilterActiveTagComponent, selector: "mng-filter-active-tag", inputs: ["model", "filter"], outputs: ["edit", "remove"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: FilterOverlayWithTagComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'mng-filter-overlay-with-tag', imports: [OverlayPanelModule, TranslateModule, TagModule, FilterFormComponent, Button, FilterActiveTagComponent, NgTemplateOutlet], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"flex align-items-center flex-grow-1\">\n    @if (titleTemplate()) {\n        <ng-container *ngTemplateOutlet=\"titleTemplate()\"></ng-container>\n    }\n    <p-button\n        icon=\"pi pi-filter\"\n        rounded=\"true\"\n        [severity]=\"activeFilters().length > 0 ? 'primary' : 'secondary'\"\n        size=\"small\"\n        (click)=\"onFilterAdd($event)\"\n        [styleClass]=\"'my-1 mr-2' + (titleTemplate() ? ' ml-3' : '')\">\n    </p-button>\n</div>\n@if (activeFilters().length > 0) {\n    <div class=\"flex align-items-center flex-wrap mt-2\">\n        @for (filter of activeFilters(); track filter.descriptor.property) {\n            <mng-filter-active-tag [model]=\"model()\" [filter]=\"filter\" (edit)=\"onFilterEdit($event)\" (remove)=\"onFilterRemove($event)\" />\n        }\n    </div>\n}\n<p-overlayPanel #op [showCloseIcon]=\"true\" (onHide)=\"onOverlayHide()\" appendTo=\"body\">\n    <mng-filter-form\n        [model]=\"model()\"\n        [descriptors]=\"descriptors()\"\n        [filter]=\"filterEdit()\"\n        [disabledProperties]=\"activeFilterProperties()\"\n        [overlay]=\"op\"\n        (apply)=\"onFilterFormApply($event)\" />\n</p-overlayPanel>\n" }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-overlay-with-tag.component.js","sourceRoot":"","sources":["../../../../../../table/src/components/filter/filter-overlay-with-tag/filter-overlay-with-tag.component.ts","../../../../../../table/src/components/filter/filter-overlay-with-tag/filter-overlay-with-tag.component.html"],"names":[],"mappings":"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","sourcesContent":["import {NgTemplateOutlet} from '@angular/common';\nimport {ChangeDetectionStrategy, Component, Signal, TemplateRef, computed, contentChildren, inject, input, signal, viewChild} from '@angular/core';\n\nimport {TranslateModule} from '@ngx-translate/core';\nimport {Button} from 'primeng/button';\nimport {OverlayPanel, OverlayPanelModule} from 'primeng/overlaypanel';\nimport {Table} from 'primeng/table';\nimport {TagModule} from 'primeng/tag';\n\nimport {COMMONS_MODULE_CONFIG_IT, CommonsFilterMetadata, CommonsSerializationConfig, FilterMatchMode, TemplateDirective, findTemplateByName} from '@mediusinc/mng-commons/core';\nimport {FilterDescriptor} from '@mediusinc/mng-commons/filter';\nimport {ModelDescriptor} from '@mediusinc/mng-commons/model';\n\nimport {filterApplySerializationConfigToCmp, filterGetDateConfig, filterSetMetadataOnChange, filterSetMetadataOnDisplayChange} from '../../../helpers/filters';\nimport {CommonsFilterMetadataWithDescriptor, FilterActiveTagEvent, FilterFormEmitEvent} from '../../../models/filter.model';\nimport {DataListService} from '../../../services/data-list.service';\nimport {FilterActiveTagComponent} from '../filter-active-tag/filter-active-tag.component';\nimport {FilterFormComponent} from '../filter-form/filter-form.component';\n\n@Component({\n    standalone: true,\n    selector: 'mng-filter-overlay-with-tag',\n    templateUrl: './filter-overlay-with-tag.component.html',\n    imports: [OverlayPanelModule, TranslateModule, TagModule, FilterFormComponent, Button, FilterActiveTagComponent, NgTemplateOutlet],\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class FilterOverlayWithTagComponent {\n    private readonly primeTable = inject(Table);\n    private readonly dataListService = inject(DataListService<any>);\n    private readonly moduleConfig = inject(COMMONS_MODULE_CONFIG_IT, {optional: true});\n\n    public descriptors = input.required<FilterDescriptor<any, any>[]>();\n    public model = input.required<ModelDescriptor<any>>();\n\n    private filterOverlay = viewChild.required(OverlayPanel);\n\n    public templates = contentChildren(TemplateDirective);\n    public titleTemplate: Signal<TemplateRef<any> | null> = computed(() => findTemplateByName([...this.templates()], 'title'));\n\n    public filters = computed(() => {\n        return this.setInitialFilters(this.dataListService.filterMeta());\n    });\n\n    public activeFilters = computed(() => {\n        const filterEntry = this.filters();\n        return this.descriptors()\n            .filter(d => {\n                const filter = filterEntry[d.property];\n                return (\n                    filter &&\n                    filter.matchMode !== undefined &&\n                    filter.displayMatchMode !== undefined &&\n                    (filter.matchMode === FilterMatchMode.Exists ||\n                        filter.matchMode === FilterMatchMode.DoesNotExist ||\n                        (filter.value !== undefined && filter.displayValue !== undefined))\n                );\n            })\n            .map(d => filterEntry[d.property]!);\n    });\n    public activeFilterProperties = computed(() => this.activeFilters().map(f => f.descriptor.property));\n    public filterEdit = signal<CommonsFilterMetadataWithDescriptor | undefined>(undefined);\n\n    private serializationCfg: CommonsSerializationConfig = {};\n\n    // UI utilities\n    private clickedOnFilterEvent: Event | undefined = undefined;\n\n    constructor() {\n        filterApplySerializationConfigToCmp(this.moduleConfig, this.serializationCfg);\n    }\n\n    onFilterFormApply(event: FilterFormEmitEvent) {\n        const descriptor = this.descriptors().find(d => d.property === event.property);\n        if (!descriptor) {\n            return;\n        }\n\n        this.updatePrimeTableFilter({\n            ...filterSetMetadataOnDisplayChange(\n                {caseSensitive: event.caseSensitive},\n                event.matchMode,\n                event.value,\n                descriptor.filterType,\n                filterGetDateConfig(descriptor, this.serializationCfg)\n            ),\n            descriptor: descriptor\n        });\n\n        // Resetting the form is done in the onOverlayHide callback because resetting the\n        // values here renders empty inputs for a split second before closing the overlay\n        this.filterOverlay().hide();\n    }\n\n    onFilterRemove(event: FilterActiveTagEvent) {\n        this.updatePrimeTableFilter({\n            ...this.filters()[event.filter.descriptor.property],\n            matchMode: undefined,\n            displayMatchMode: undefined,\n            value: undefined,\n            displayValue: undefined\n        });\n    }\n\n    onFilterEdit(event: FilterActiveTagEvent) {\n        this.onFilterAddOrEdit(event.filter, event.event);\n    }\n\n    onFilterAdd(event: Event) {\n        this.onFilterAddOrEdit(undefined, event);\n    }\n\n    onOverlayHide() {\n        if (this.clickedOnFilterEvent) {\n            // show the overlay again if the user clicked another filter\n            setTimeout(() => {\n                this.filterOverlay().show(this.clickedOnFilterEvent);\n                this.clickedOnFilterEvent = undefined;\n            }, 0);\n            return;\n        } else {\n            // clean state\n            this.filterEdit.set(undefined);\n        }\n    }\n\n    private onFilterAddOrEdit(filter?: CommonsFilterMetadataWithDescriptor, event?: Event) {\n        // If user clicks on the same filter or add that is already open, close the overlay\n        if (this.filterOverlay().overlayVisible && this.filterEdit()?.descriptor.property === filter?.descriptor.property) {\n            this.filterOverlay().hide();\n            this.filterEdit.set(undefined);\n            return;\n        }\n\n        this.filterEdit.set(filter);\n        if (this.filterOverlay().overlayVisible) {\n            // In case the user clicks another filter, 're-showing' the overlay in\n            // the new position is done in the onOverlayHide callback\n            this.clickedOnFilterEvent = event;\n            this.filterOverlay().hide();\n        } else {\n            this.filterOverlay().show(event);\n        }\n    }\n\n    private setInitialFilters(filtersInit: Record<string, CommonsFilterMetadata>) {\n        const filtersResult: {[p: string]: CommonsFilterMetadataWithDescriptor} = {};\n\n        for (const property in filtersInit) {\n            const filterInit = filtersInit[property];\n\n            const descriptor = this.descriptors().find(filterDescriptor => filterDescriptor.property === property);\n            if (!descriptor) {\n                continue;\n            }\n\n            filtersResult[property] = {\n                ...filterSetMetadataOnChange(filterInit, filterInit.matchMode, filterInit.value, descriptor.filterType, filterGetDateConfig(descriptor, this.serializationCfg)),\n                descriptor: descriptor\n            };\n        }\n\n        return filtersResult;\n    }\n\n    private updatePrimeTableFilter(filter: CommonsFilterMetadataWithDescriptor) {\n        this.primeTable.filters[filter.descriptor.property] = {...filter};\n        this.primeTable._filter();\n    }\n}\n","<div class=\"flex align-items-center flex-grow-1\">\n    @if (titleTemplate()) {\n        <ng-container *ngTemplateOutlet=\"titleTemplate()\"></ng-container>\n    }\n    <p-button\n        icon=\"pi pi-filter\"\n        rounded=\"true\"\n        [severity]=\"activeFilters().length > 0 ? 'primary' : 'secondary'\"\n        size=\"small\"\n        (click)=\"onFilterAdd($event)\"\n        [styleClass]=\"'my-1 mr-2' + (titleTemplate() ? ' ml-3' : '')\">\n    </p-button>\n</div>\n@if (activeFilters().length > 0) {\n    <div class=\"flex align-items-center flex-wrap mt-2\">\n        @for (filter of activeFilters(); track filter.descriptor.property) {\n            <mng-filter-active-tag [model]=\"model()\" [filter]=\"filter\" (edit)=\"onFilterEdit($event)\" (remove)=\"onFilterRemove($event)\" />\n        }\n    </div>\n}\n<p-overlayPanel #op [showCloseIcon]=\"true\" (onHide)=\"onOverlayHide()\" appendTo=\"body\">\n    <mng-filter-form\n        [model]=\"model()\"\n        [descriptors]=\"descriptors()\"\n        [filter]=\"filterEdit()\"\n        [disabledProperties]=\"activeFilterProperties()\"\n        [overlay]=\"op\"\n        (apply)=\"onFilterFormApply($event)\" />\n</p-overlayPanel>\n"]}