ngx-techlify-core 18.89.0 → 18.91.0

package/esm2022/lib/base-model/index.mjs

@@ -3,4 +3,6 @@ export * from './techlify-form/contract/techlify-form.contract';
 export * from './techlify-list/techlify-list.component';
 export * from './techlify-list/contract/techlify-list.contract';
 export * from './techlify-service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdGVjaGxpZnktY29yZS9zcmMvbGliL2Jhc2UtbW9kZWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5Q0FBeUMsQ0FBQTtBQUN2RCxjQUFjLGlEQUFpRCxDQUFBO0FBQy9ELGNBQWMseUNBQXlDLENBQUE7QUFDdkQsY0FBYyxpREFBaUQsQ0FBQTtBQUMvRCxjQUFjLG9CQUFvQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90ZWNobGlmeS1mb3JtL3RlY2hsaWZ5LWZvcm0uY29tcG9uZW50J1xuZXhwb3J0ICogZnJvbSAnLi90ZWNobGlmeS1mb3JtL2NvbnRyYWN0L3RlY2hsaWZ5LWZvcm0uY29udHJhY3QnXG5leHBvcnQgKiBmcm9tICcuL3RlY2hsaWZ5LWxpc3QvdGVjaGxpZnktbGlzdC5jb21wb25lbnQnXG5leHBvcnQgKiBmcm9tICcuL3RlY2hsaWZ5LWxpc3QvY29udHJhY3QvdGVjaGxpZnktbGlzdC5jb250cmFjdCdcbmV4cG9ydCAqIGZyb20gJy4vdGVjaGxpZnktc2VydmljZSdcbiJdfQ==
+export * from './techlify-show/techlify-show.component';
+export * from './techlify-show/contract/techlify-show.contract';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdGVjaGxpZnktY29yZS9zcmMvbGliL2Jhc2UtbW9kZWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5Q0FBeUMsQ0FBQTtBQUN2RCxjQUFjLGlEQUFpRCxDQUFBO0FBQy9ELGNBQWMseUNBQXlDLENBQUE7QUFDdkQsY0FBYyxpREFBaUQsQ0FBQTtBQUMvRCxjQUFjLG9CQUFvQixDQUFBO0FBQ2xDLGNBQWMseUNBQXlDLENBQUE7QUFDdkQsY0FBYyxpREFBaUQsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdGVjaGxpZnktZm9ybS90ZWNobGlmeS1mb3JtLmNvbXBvbmVudCdcbmV4cG9ydCAqIGZyb20gJy4vdGVjaGxpZnktZm9ybS9jb250cmFjdC90ZWNobGlmeS1mb3JtLmNvbnRyYWN0J1xuZXhwb3J0ICogZnJvbSAnLi90ZWNobGlmeS1saXN0L3RlY2hsaWZ5LWxpc3QuY29tcG9uZW50J1xuZXhwb3J0ICogZnJvbSAnLi90ZWNobGlmeS1saXN0L2NvbnRyYWN0L3RlY2hsaWZ5LWxpc3QuY29udHJhY3QnXG5leHBvcnQgKiBmcm9tICcuL3RlY2hsaWZ5LXNlcnZpY2UnXG5leHBvcnQgKiBmcm9tICcuL3RlY2hsaWZ5LXNob3cvdGVjaGxpZnktc2hvdy5jb21wb25lbnQnXG5leHBvcnQgKiBmcm9tICcuL3RlY2hsaWZ5LXNob3cvY29udHJhY3QvdGVjaGxpZnktc2hvdy5jb250cmFjdCdcbiJdfQ==

package/esm2022/lib/base-model/techlify-list/contract/techlify-list.contract.mjs

@@ -24,7 +24,7 @@ export function techlifyListContract(options) {
         it('should reload when filter changes', fakeAsync(() => {
             const component = options.getComponent();
             const filterField = options.filterField ?? 'search';
-            if (!component.filterForm?.contains(filterField)) {
+            if (!component.filterForm?.get(filterField)) {
                 pending(`Filter '${filterField}' does not exist.`);
                 return;
             }
@@ -66,4 +66,4 @@ export function techlifyListContract(options) {
         });
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"techlify-list.contract.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-techlify-core/src/lib/base-model/techlify-list/contract/techlify-list.contract.ts"],"names":[],"mappings":"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","sourcesContent":["import { fakeAsync, tick, ComponentFixture } from '@angular/core/testing';\nimport { TechlifyListComponent } from '../techlify-list.component';\n\nexport interface TechlifyListContractOptions {\n    getFixture: () => ComponentFixture<any>;\n    getComponent: () => TechlifyListComponent;\n    getService: () => any;\n    filterField?: string;\n}\n\nexport function techlifyListContract(\n    options: TechlifyListContractOptions\n): void {\n    describe('TechlifyListComponent Contract', () => {\n        it('should pass a service to the base class', () => {\n            const component = options.getComponent();\n            expect((component as any).service).toBe(options.getService());\n        });\n\n        it('should have a filter form', () => {\n            const component = options.getComponent();\n            expect(component.filterForm).toBeTruthy();\n        });\n\n        it('should call loadData on init', () => {\n            const component = options.getComponent();\n            spyOn(component as any, 'loadData');\n            (component as any).ngOnInit();\n            expect(component.loadData).toHaveBeenCalled();\n        });\n\n        it('should patch filters from route on init', () => {\n            const component = options.getComponent();\n            spyOn(component as any, 'patchFiltersFromRoute');\n            (component as any).ngOnInit();\n            expect(component.patchFiltersFromRoute).toHaveBeenCalled();\n        });\n\n        it('should reload when filter changes', fakeAsync(() => {\n            const component = options.getComponent();\n            const filterField = options.filterField ?? 'search';\n            if (!component.filterForm?.contains(filterField)) {\n                pending(`Filter '${filterField}' does not exist.`);\n                return;\n            }\n            spyOn(component as any, 'reload');\n            component.listenFilterChanges();\n            component.filterForm.get(filterField)?.setValue('abc');\n            tick(501);\n            expect(component.reload).toHaveBeenCalled();\n\n        }));\n\n        it('should load next page on scroll', () => {\n            const component = options.getComponent();\n            component.page = 1;\n            component.lastPage = 3;\n            component.isWorking = false;\n            spyOn(component as any, 'loadData');\n            component.onScroll();\n            expect(component.page).toBe(2);\n            expect(component.loadData).toHaveBeenCalled();\n        });\n\n        it('should not load next page while already loading', () => {\n            const component = options.getComponent();\n            component.page = 1;\n            component.lastPage = 3;\n            component.isWorking = true;\n            spyOn(component as any, 'loadData');\n            component.onScroll();\n            expect(component.loadData).not.toHaveBeenCalled();\n        });\n\n        it('should update sort_by filter', () => {\n            const component = options.getComponent();\n            const control = component.filterForm.get('sort_by');\n            if (!control) {\n                pending('No sort_by control.');\n                return;\n            }\n            spyOn(control, 'setValue');\n            component.sortColumn({ active: 'name', direction: 'asc' });\n            expect(control.setValue).toHaveBeenCalledWith('name|ASC');\n        });\n\n    });\n\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"techlify-list.contract.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-techlify-core/src/lib/base-model/techlify-list/contract/techlify-list.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,IAAI,EAAoB,MAAM,uBAAuB,CAAC;AAU1E,MAAM,UAAU,oBAAoB,CAChC,OAAoC;IAEpC,QAAQ,CAAC,gCAAgC,EAAE,GAAG,EAAE;QAC5C,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;YAC/C,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;YACzC,MAAM,CAAE,SAAiB,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,2BAA2B,EAAE,GAAG,EAAE;YACjC,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;YACzC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,UAAU,EAAE,CAAC;QAC9C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,8BAA8B,EAAE,GAAG,EAAE;YACpC,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;YACzC,KAAK,CAAC,SAAgB,EAAE,UAAU,CAAC,CAAC;YACnC,SAAiB,CAAC,QAAQ,EAAE,CAAC;YAC9B,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,gBAAgB,EAAE,CAAC;QAClD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;YAC/C,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;YACzC,KAAK,CAAC,SAAgB,EAAE,uBAAuB,CAAC,CAAC;YAChD,SAAiB,CAAC,QAAQ,EAAE,CAAC;YAC9B,MAAM,CAAC,SAAS,CAAC,qBAAqB,CAAC,CAAC,gBAAgB,EAAE,CAAC;QAC/D,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mCAAmC,EAAE,SAAS,CAAC,GAAG,EAAE;YACnD,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;YACzC,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,QAAQ,CAAC;YACpD,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;gBAC1C,OAAO,CAAC,WAAW,WAAW,mBAAmB,CAAC,CAAC;gBACnD,OAAO;YACX,CAAC;YACD,KAAK,CAAC,SAAgB,EAAE,QAAQ,CAAC,CAAC;YAClC,SAAS,CAAC,mBAAmB,EAAE,CAAC;YAChC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;YACvD,IAAI,CAAC,GAAG,CAAC,CAAC;YACV,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,gBAAgB,EAAE,CAAC;QAEhD,CAAC,CAAC,CAAC,CAAC;QAEJ,EAAE,CAAC,iCAAiC,EAAE,GAAG,EAAE;YACvC,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;YACzC,SAAS,CAAC,IAAI,GAAG,CAAC,CAAC;YACnB,SAAS,CAAC,QAAQ,GAAG,CAAC,CAAC;YACvB,SAAS,CAAC,SAAS,GAAG,KAAK,CAAC;YAC5B,KAAK,CAAC,SAAgB,EAAE,UAAU,CAAC,CAAC;YACpC,SAAS,CAAC,QAAQ,EAAE,CAAC;YACrB,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC/B,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,gBAAgB,EAAE,CAAC;QAClD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;YACvD,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;YACzC,SAAS,CAAC,IAAI,GAAG,CAAC,CAAC;YACnB,SAAS,CAAC,QAAQ,GAAG,CAAC,CAAC;YACvB,SAAS,CAAC,SAAS,GAAG,IAAI,CAAC;YAC3B,KAAK,CAAC,SAAgB,EAAE,UAAU,CAAC,CAAC;YACpC,SAAS,CAAC,QAAQ,EAAE,CAAC;YACrB,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,gBAAgB,EAAE,CAAC;QACtD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,8BAA8B,EAAE,GAAG,EAAE;YACpC,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;YACzC,MAAM,OAAO,GAAG,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACpD,IAAI,CAAC,OAAO,EAAE,CAAC;gBACX,OAAO,CAAC,qBAAqB,CAAC,CAAC;gBAC/B,OAAO;YACX,CAAC;YACD,KAAK,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;YAC3B,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;YAC3D,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC;QAC9D,CAAC,CAAC,CAAC;IAEP,CAAC,CAAC,CAAC;AAEP,CAAC","sourcesContent":["import { fakeAsync, tick, ComponentFixture } from '@angular/core/testing';\nimport { TechlifyListComponent } from '../techlify-list.component';\n\nexport interface TechlifyListContractOptions {\n    getFixture: () => ComponentFixture<any>;\n    getComponent: () => TechlifyListComponent;\n    getService: () => any;\n    filterField?: string;\n}\n\nexport function techlifyListContract(\n    options: TechlifyListContractOptions\n): void {\n    describe('TechlifyListComponent Contract', () => {\n        it('should pass a service to the base class', () => {\n            const component = options.getComponent();\n            expect((component as any).service).toBe(options.getService());\n        });\n\n        it('should have a filter form', () => {\n            const component = options.getComponent();\n            expect(component.filterForm).toBeTruthy();\n        });\n\n        it('should call loadData on init', () => {\n            const component = options.getComponent();\n            spyOn(component as any, 'loadData');\n            (component as any).ngOnInit();\n            expect(component.loadData).toHaveBeenCalled();\n        });\n\n        it('should patch filters from route on init', () => {\n            const component = options.getComponent();\n            spyOn(component as any, 'patchFiltersFromRoute');\n            (component as any).ngOnInit();\n            expect(component.patchFiltersFromRoute).toHaveBeenCalled();\n        });\n\n        it('should reload when filter changes', fakeAsync(() => {\n            const component = options.getComponent();\n            const filterField = options.filterField ?? 'search';\n            if (!component.filterForm?.get(filterField)) {\n                pending(`Filter '${filterField}' does not exist.`);\n                return;\n            }\n            spyOn(component as any, 'reload');\n            component.listenFilterChanges();\n            component.filterForm.get(filterField)?.setValue('abc');\n            tick(501);\n            expect(component.reload).toHaveBeenCalled();\n\n        }));\n\n        it('should load next page on scroll', () => {\n            const component = options.getComponent();\n            component.page = 1;\n            component.lastPage = 3;\n            component.isWorking = false;\n            spyOn(component as any, 'loadData');\n            component.onScroll();\n            expect(component.page).toBe(2);\n            expect(component.loadData).toHaveBeenCalled();\n        });\n\n        it('should not load next page while already loading', () => {\n            const component = options.getComponent();\n            component.page = 1;\n            component.lastPage = 3;\n            component.isWorking = true;\n            spyOn(component as any, 'loadData');\n            component.onScroll();\n            expect(component.loadData).not.toHaveBeenCalled();\n        });\n\n        it('should update sort_by filter', () => {\n            const component = options.getComponent();\n            const control = component.filterForm.get('sort_by');\n            if (!control) {\n                pending('No sort_by control.');\n                return;\n            }\n            spyOn(control, 'setValue');\n            component.sortColumn({ active: 'name', direction: 'asc' });\n            expect(control.setValue).toHaveBeenCalledWith('name|ASC');\n        });\n\n    });\n\n}"]}

package/esm2022/lib/base-model/techlify-show/contract/techlify-show.contract.mjs

@@ -0,0 +1,84 @@
+import { of } from 'rxjs';
+import { convertToParamMap } from '@angular/router';
+/**
+ * Reusable test contract for components extending TechlifyShowComponent.
+ *
+ * Ensures all view components follow the same base behaviour:
+ * - Service injection
+ * - Default state initialization
+ * - Reading the id from the route
+ * - Loading the model through service.show()
+ * - Model update handling
+ */
+export function techlifyShowContract(options) {
+    describe('TechlifyShowComponent Contract', () => {
+        /**
+         * Ensures child components correctly pass their service
+         * to the base view component.
+         */
+        it('should pass a service to the base class', () => {
+            const component = options.getComponent();
+            expect(component.service)
+                .toBe(options.getService());
+        });
+        /**
+         * Ensures route listening is started on init.
+         */
+        it('should listen route changes on init', () => {
+            const component = options.getComponent();
+            spyOn(component, 'listenRouteChanges');
+            component.ngOnInit();
+            expect(component.listenRouteChanges)
+                .toHaveBeenCalled();
+        });
+        /**
+         * Ensures the id is read from the configured route param.
+         */
+        it('should get id from route params', () => {
+            const component = options.getComponent();
+            const routeParamName = options.routeParamName ?? 'id';
+            const params = convertToParamMap({ [routeParamName]: '5' });
+            expect(component.getIdFromRoute(params))
+                .toBe('5');
+        });
+        /**
+         * Ensures the model is loaded using the show service.
+         */
+        it('should load the model using show', () => {
+            const component = options.getComponent();
+            options.getService().show
+                .and.returnValue(of({
+                item: { id: 5 }
+            }));
+            component.id = 5;
+            component.loadData();
+            expect(options.getService().show)
+                .toHaveBeenCalledWith(5, jasmine.anything());
+            expect(component.model)
+                .toEqual({ id: 5 });
+            expect(component.isWorking)
+                .toBeFalse();
+        });
+        /**
+         * Ensures no request is made without an id.
+         */
+        it('should not load without an id', () => {
+            const component = options.getComponent();
+            options.getService().show.calls.reset();
+            component.id = null;
+            component.loadData();
+            expect(options.getService().show)
+                .not.toHaveBeenCalled();
+        });
+        /**
+         * Ensures the model is replaced on update.
+         */
+        it('should replace the model on modelUpdated', () => {
+            const component = options.getComponent();
+            component.modelUpdated({ id: 7 });
+            expect(component.model)
+                .toEqual({ id: 7 });
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/base-model/techlify-show/techlify-show.component.mjs

@@ -0,0 +1,120 @@
+import { Directive, inject, Optional } from '@angular/core';
+import { Title } from '@angular/platform-browser';
+import { ActivatedRoute } from '@angular/router';
+import { finalize } from 'rxjs';
+import { EnvironmentService } from '../../core/environment.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../techlify-service";
+/**
+ * Interface used to ensure we have a consistent structure across our view (show) pages
+ *
+ * Every view page follows the same workflow:
+ * route param -> id -> service.show(id) -> model
+ */
+export class TechlifyShowComponent {
+    /**
+     * Child classes can override this.
+     * If left undefined/empty, falls back to environment.appTitle
+     */
+    get pageTitle() {
+        return undefined; // default
+    }
+    constructor(service) {
+        this.service = service;
+        //Boolean to denote the page is in API progress
+        this.isWorking = false;
+        /**
+         * Name of the route param holding the model id.
+         * Override in child class if the route uses a different name, eg: 'memoId'
+         */
+        this.routeParamName = 'id';
+        this.titleService = inject(Title, { optional: true });
+        this.environmentService = inject(EnvironmentService, { optional: true });
+        //Activated route to be inherited and used if needed
+        this.route = inject(ActivatedRoute, { optional: true });
+        const resolvedTitle = this.pageTitle && this.pageTitle.trim().length > 0
+            ? this.pageTitle
+            : this.environmentService?.get().appTitle;
+        this.titleService?.setTitle(resolvedTitle);
+    }
+    /**
+     * Function that listens for route param changes
+     * Sets the id and reloads the model whenever it changes,
+     * so navigating between two records on the same page works
+     */
+    listenRouteChanges() {
+        this.route?.paramMap.subscribe((params) => {
+            this.id = this.getIdFromRoute(params);
+            this.loadData();
+        });
+    }
+    /**
+     * Reads the model id from the route params
+     * Uses the current route snapshot when params are not given
+     *
+     * @param params optional route params
+     */
+    getIdFromRoute(params) {
+        const routeParams = params ?? this.route?.snapshot?.paramMap;
+        return routeParams?.get(this.routeParamName) ?? null;
+    }
+    /**
+     * Query params passed to the show request, eg: relations to load
+     * Override in child class if needed
+     */
+    getShowParams() {
+        return {};
+    }
+    /**
+     * Function that loads the main model of the page
+     */
+    loadData() {
+        if (!this.service) {
+            throw new Error(`${this.constructor.name}: Service is required to load the data`);
+        }
+        if (!this.id) {
+            return;
+        }
+        this.loadSubscription?.unsubscribe();
+        this.isWorking = true;
+        this.loadSubscription = this.service.show(this.id, this.getShowParams())
+            .pipe(finalize(() => this.isWorking = false))
+            .subscribe((result) => {
+            this.model = result?.item;
+            this.modelLoaded(this.model);
+        });
+    }
+    /**
+     * Reload the model of the page
+     */
+    reload() {
+        this.loadData();
+    }
+    /**
+     * Hook called once the model is loaded
+     * Override in child class to compute derived data from the model
+     *
+     * @param model The loaded model
+     */
+    modelLoaded(model) {
+    }
+    /**
+     * Replaces the model of the page, eg: after an update form or status change
+     *
+     * @param model The updated model
+     */
+    modelUpdated(model) {
+        if (model) {
+            this.model = model;
+            this.modelLoaded(this.model);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TechlifyShowComponent, deps: [{ token: i1.TechlifyService, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TechlifyShowComponent, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TechlifyShowComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i1.TechlifyService, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"techlify-show.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-techlify-core/src/lib/base-model/techlify-show/techlify-show.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, inject, Optional } from '@angular/core';\nimport { Title } from '@angular/platform-browser';\nimport { ActivatedRoute, ParamMap } from '@angular/router';\nimport { finalize, Subscription } from 'rxjs';\nimport { EnvironmentService } from '../../core/environment.service';\nimport { TechlifyService } from '../techlify-service';\n\n/**\n * Interface used to ensure we have a consistent structure across our view (show) pages\n *\n * Every view page follows the same workflow:\n * route param -> id -> service.show(id) -> model\n */\n@Directive()\nexport abstract class TechlifyShowComponent {\n\n  //The main model of the page\n  model: any;\n\n  //Id of the model, taken from the route\n  id: any;\n\n  //Boolean to denote the page is in API progress\n  isWorking: boolean = false;\n\n  /**\n   * Name of the route param holding the model id.\n   * Override in child class if the route uses a different name, eg: 'memoId'\n   */\n  protected routeParamName = 'id';\n\n  /**\n   * Child classes can override this.\n   * If left undefined/empty, falls back to environment.appTitle\n   */\n  protected get pageTitle(): string | undefined {\n    return undefined; // default\n  }\n\n  //Active show request, cancelled when a new load starts\n  private loadSubscription?: Subscription;\n\n  private titleService = inject(Title, { optional: true });\n  private environmentService = inject(EnvironmentService, { optional: true });\n\n  //Activated route to be inherited and used if needed\n  protected route = inject(ActivatedRoute, { optional: true });\n\n  constructor(@Optional() protected service?: TechlifyService) {\n    const resolvedTitle =\n      this.pageTitle && this.pageTitle.trim().length > 0\n        ? this.pageTitle\n        : this.environmentService?.get().appTitle;\n    this.titleService?.setTitle(resolvedTitle);\n  }\n\n  /**\n   * Function that listens for route param changes\n   * Sets the id and reloads the model whenever it changes,\n   * so navigating between two records on the same page works\n   */\n  listenRouteChanges(): void {\n    this.route?.paramMap.subscribe((params: ParamMap) => {\n      this.id = this.getIdFromRoute(params);\n      this.loadData();\n    });\n  }\n\n  /**\n   * Reads the model id from the route params\n   * Uses the current route snapshot when params are not given\n   *\n   * @param params optional route params\n   */\n  getIdFromRoute(params?: ParamMap): any {\n    const routeParams = params ?? this.route?.snapshot?.paramMap;\n    return routeParams?.get(this.routeParamName) ?? null;\n  }\n\n  /**\n   * Query params passed to the show request, eg: relations to load\n   * Override in child class if needed\n   */\n  protected getShowParams(): any {\n    return {};\n  }\n\n  /**\n   * Function that loads the main model of the page\n   */\n  loadData(): void {\n    if (!this.service) {\n      throw new Error(\n        `${this.constructor.name}: Service is required to load the data`\n      );\n    }\n    if (!this.id) {\n      return;\n    }\n    this.loadSubscription?.unsubscribe();\n    this.isWorking = true;\n    this.loadSubscription = this.service.show(this.id, this.getShowParams())\n      .pipe(finalize(() => this.isWorking = false))\n      .subscribe((result: any) => {\n        this.model = result?.item;\n        this.modelLoaded(this.model);\n      });\n  }\n\n  /**\n   * Reload the model of the page\n   */\n  reload(): void {\n    this.loadData();\n  }\n\n  /**\n   * Hook called once the model is loaded\n   * Override in child class to compute derived data from the model\n   *\n   * @param model The loaded model\n   */\n  protected modelLoaded(model: any): void {\n  }\n\n  /**\n   * Replaces the model of the page, eg: after an update form or status change\n   *\n   * @param model The updated model\n   */\n  modelUpdated(model: any): void {\n    if (model) {\n      this.model = model;\n      this.modelLoaded(this.model);\n    }\n  }\n}\n"]}

package/esm2022/lib/detail-layout/techlify-detail-layout.component.mjs

@@ -0,0 +1,11 @@
+import { Component, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TechlifyDetailLayoutComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TechlifyDetailLayoutComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: TechlifyDetailLayoutComponent, isStandalone: true, selector: "app-techlify-detail-layout", ngImport: i0, template: "<ng-content></ng-content>\n", styles: ["app-techlify-detail-layout{display:flex;flex-direction:column;width:100%}app-techlify-detail-layout .detail-row{display:flex;align-items:center;margin-top:.5rem}app-techlify-detail-layout .detail-row.detail-row-start{align-items:flex-start}app-techlify-detail-layout .detail-row-head{min-width:var(--detail-row-head-width, 100px);flex-shrink:0;font-size:.875em;color:var(--bs-secondary-color, #6c757d)}app-techlify-detail-layout .detail-row-data{min-width:0}\n"], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TechlifyDetailLayoutComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-techlify-detail-layout', standalone: true, encapsulation: ViewEncapsulation.None, template: "<ng-content></ng-content>\n", styles: ["app-techlify-detail-layout{display:flex;flex-direction:column;width:100%}app-techlify-detail-layout .detail-row{display:flex;align-items:center;margin-top:.5rem}app-techlify-detail-layout .detail-row.detail-row-start{align-items:flex-start}app-techlify-detail-layout .detail-row-head{min-width:var(--detail-row-head-width, 100px);flex-shrink:0;font-size:.875em;color:var(--bs-secondary-color, #6c757d)}app-techlify-detail-layout .detail-row-data{min-width:0}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVjaGxpZnktZGV0YWlsLWxheW91dC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdGVjaGxpZnktY29yZS9zcmMvbGliL2RldGFpbC1sYXlvdXQvdGVjaGxpZnktZGV0YWlsLWxheW91dC5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdGVjaGxpZnktY29yZS9zcmMvbGliL2RldGFpbC1sYXlvdXQvdGVjaGxpZnktZGV0YWlsLWxheW91dC5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVM3RCxNQUFNLE9BQU8sNkJBQTZCOytHQUE3Qiw2QkFBNkI7bUdBQTdCLDZCQUE2QixzRkNUMUMsNkJBQ0E7OzRGRFFhLDZCQUE2QjtrQkFQekMsU0FBUzsrQkFDSSw0QkFBNEIsY0FDMUIsSUFBSSxpQkFHRCxpQkFBaUIsQ0FBQyxJQUFJIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBWaWV3RW5jYXBzdWxhdGlvbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ2FwcC10ZWNobGlmeS1kZXRhaWwtbGF5b3V0JyxcbiAgICBzdGFuZGFsb25lOiB0cnVlLFxuICAgIHRlbXBsYXRlVXJsOiAnLi90ZWNobGlmeS1kZXRhaWwtbGF5b3V0LmNvbXBvbmVudC5odG1sJyxcbiAgICBzdHlsZVVybHM6IFsnLi90ZWNobGlmeS1kZXRhaWwtbGF5b3V0LmNvbXBvbmVudC5zY3NzJ10sXG4gICAgZW5jYXBzdWxhdGlvbjogVmlld0VuY2Fwc3VsYXRpb24uTm9uZVxufSlcbmV4cG9ydCBjbGFzcyBUZWNobGlmeURldGFpbExheW91dENvbXBvbmVudCB7IH1cbiIsIjxuZy1jb250ZW50PjwvbmctY29udGVudD5cbiJdfQ==

package/esm2022/lib/locked-date/locked-date-lock-unlock-button/locked-date-lock-unlock-button.component.mjs

@@ -9,15 +9,15 @@ export class LockedDateLockUnlockButtonComponent {
     }
     lock() {
         this.lockedDateService.lock(this.lockedDate).subscribe({
-            next: () => {
-                this.onSave.emit();
+            next: (response) => {
+                this.onSave.emit(response.item);
             }
         });
     }
     unlock() {
         this.lockedDateService.unlock(this.lockedDate).subscribe({
-            next: () => {
-                this.onSave.emit();
+            next: (response) => {
+                this.onSave.emit(response.item);
             }
         });
     }
@@ -32,4 +32,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             }], onSave: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/locked-date/locked-dates-list/locked-date-list.component.mjs

@@ -1,26 +1,28 @@
 import { Component, signal } from '@angular/core';
 import { TechlifyListComponent } from '../../base-model';
-import { DatePipe } from '@angular/common';
 import { LockedDateFormComponent } from '../locked-date-form/locked-date-form.component';
 import * as i0 from "@angular/core";
 import * as i1 from "../locked-date.service";
 import * as i2 from "@angular/forms";
-import * as i3 from "@angular/common";
-import * as i4 from "ngx-infinite-scroll";
-import * as i5 from "@angular/material/sort";
-import * as i6 from "@angular/material/table";
-import * as i7 from "@angular/material/card";
-import * as i8 from "../../delete-button/techlify-delete-button.component";
-import * as i9 from "../../timeline-filter/timeline-filter.component";
-import * as i10 from "../../form-button/techlify-form-button.component";
-import * as i11 from "../locked-date-lock-unlock-button/locked-date-lock-unlock-button.component";
+import * as i3 from "../../user-config/user-config.service";
+import * as i4 from "@angular/common";
+import * as i5 from "ngx-infinite-scroll";
+import * as i6 from "@angular/material/sort";
+import * as i7 from "@angular/material/table";
+import * as i8 from "@angular/material/card";
+import * as i9 from "@angular/material/tooltip";
+import * as i10 from "../../delete-button/techlify-delete-button.component";
+import * as i11 from "../../timeline-filter/timeline-filter.component";
+import * as i12 from "../../form-button/techlify-form-button.component";
+import * as i13 from "../locked-date-lock-unlock-button/locked-date-lock-unlock-button.component";
 export class LockedDateListComponent extends TechlifyListComponent {
-    constructor(service, fb, datePipe) {
-        super();
+    constructor(service, fb, userConfigService) {
+        super(service);
         this.service = service;
         this.fb = fb;
-        this.datePipe = datePipe;
+        this.userConfigService = userConfigService;
         this.formComponent = signal(LockedDateFormComponent);
+        this.scrollContainer = '.mat-sidenav-content';
         this.displayedColumns = [
             'index',
             'date',
@@ -29,6 +31,16 @@ export class LockedDateListComponent extends TechlifyListComponent {
             'locked_by',
             'actions'
         ];
+        const config = this.userConfigService.getConfig();
+        if (config?.scrollContainer) {
+            this.scrollContainer = config.scrollContainer === 'root'
+                ? null
+                : config.scrollContainer;
+        }
+        this.filterFormConfiguration = {
+            date_from: { date: true },
+            date_to: { date: true },
+        };
         this.filterForm = this.fb.group({
             date_from: [''],
             date_to: [''],
@@ -36,32 +48,15 @@ export class LockedDateListComponent extends TechlifyListComponent {
         });
     }
     ngOnInit() {
+        this.patchFiltersFromRoute();
         this.listenFilterChanges();
         this.loadData();
     }
-    loadData() {
-        this.isWorking = true;
-        let filters = this.filterForm.value;
-        filters.page = this.page;
-        filters.date_from = filters.date_from
-            ? this.datePipe.transform(filters.date_from, 'yyyy-MM-dd')
-            : '';
-        filters.date_to = filters.date_to
-            ? this.datePipe.transform(filters.date_to, 'yyyy-MM-dd')
-            : '';
-        this.service.index(filters).subscribe({
-            next: (response) => {
-                this.models = this.models.concat(response.data);
-                this.lastPage = response.last_page;
-                this.isWorking = false;
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LockedDateListComponent, deps: [{ token: i1.LockedDateService }, { token: i2.FormBuilder }, { token: i3.DatePipe }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: LockedDateListComponent, selector: "app-locked-date-list", providers: [DatePipe], usesInheritance: true, ngImport: i0, template: "<div class=\"d-flex flex-column gap-2\">\n  <mat-card appearance=\"outlined\" class=\"d-print-none\">\n    <mat-card-content class=\"d-flex flex-row align-items-center justify-content-between\">\n      <div class=\"d-flex flex-row gap-2 align-items-center justify-content-between\">\n        <h5 class=\"mb-0\">Locked Dates</h5>\n        <app-techlify-form-button [component]=\"formComponent()\"\n          (saved)=\"modelCreated($event)\"></app-techlify-form-button>\n      </div>\n\n      <form [formGroup]=\"filterForm\" class='d-flex flex-row gap-2'>\n        <app-timeline-filter labelText=\"Period\" [form]='filterForm'></app-timeline-filter>\n      </form>\n    </mat-card-content>\n  </mat-card>\n\n  <mat-card>\n    <mat-card-content>\n      <table class='w-100' mat-table [dataSource]=\"models\" matSort multiTemplateDataRows infiniteScroll\n        [infiniteScrollDistance]=\"1\" [infiniteScrollThrottle]=\"50\" (scrolled)=\"onScroll()\" [scrollWindow]=\"false\"\n        [infiniteScrollContainer]=\"'.mat-sidenav-content'\" [fromRoot]=\"true\" (matSortChange)=\"sortColumn($event)\">\n\n        <ng-container matColumnDef=\"index\">\n          <th mat-header-cell *matHeaderCellDef> # </th>\n          <td mat-cell *matCellDef=\"let element; let i = dataIndex\"> {{ i+1 }} </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"date\">\n          <th mat-header-cell *matHeaderCellDef mat-sort-header> Date </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{element?.date | date: 'longDate'}}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"locked_on\">\n          <th mat-header-cell *matHeaderCellDef> Locked On </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.created_at | date:'medium' }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"locked_by\">\n          <th mat-header-cell *matHeaderCellDef> Locked By </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.creator?.name }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"details\">\n          <th mat-header-cell *matHeaderCellDef> Details </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.details }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"actions\">\n          <th mat-header-cell *matHeaderCellDef> Actions </th>\n          <td mat-cell *matCellDef=\"let element\">\n            <div class=\"d-flex flex-row gap-2 text-secondary\">\n              <app-locked-date-lock-unlock-button [lockedDate]='element'\n                (onSave)='reload()'></app-locked-date-lock-unlock-button>\n              <app-techlify-delete-button [service]=\"service\" [model]=\"element\"\n                [data]=\"{type: 'Locked Date', title: element?.date | date:'longDate'}\"\n                (deleted)=\"modelsDeletedById($event)\"></app-techlify-delete-button>\n            </div>\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <tr mat-header-row *matHeaderRowDef=\"displayedColumns; sticky: true\"></tr>\n        <tr mat-row *matRowDef=\"let row; columns: displayedColumns;\"></tr>\n      </table>\n    </mat-card-content>\n  </mat-card>\n</div>", dependencies: [{ kind: "directive", type: i2.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i4.InfiniteScrollDirective, selector: "[infiniteScroll], [infinite-scroll], [data-infinite-scroll]", inputs: ["infiniteScrollDistance", "infiniteScrollUpDistance", "infiniteScrollThrottle", "infiniteScrollDisabled", "infiniteScrollContainer", "scrollWindow", "immediateCheck", "horizontal", "alwaysCallback", "fromRoot"], outputs: ["scrolled", "scrolledUp"] }, { kind: "directive", type: i5.MatSort, selector: "[matSort]", inputs: ["matSortActive", "matSortStart", "matSortDirection", "matSortDisableClear", "matSortDisabled"], outputs: ["matSortChange"], exportAs: ["matSort"] }, { kind: "component", type: i5.MatSortHeader, selector: "[mat-sort-header]", inputs: ["mat-sort-header", "arrowPosition", "start", "disabled", "sortActionDescription", "disableClear"], exportAs: ["matSortHeader"] }, { kind: "component", type: i6.MatTable, selector: "mat-table, table[mat-table]", exportAs: ["matTable"] }, { kind: "directive", type: i6.MatHeaderCellDef, selector: "[matHeaderCellDef]" }, { kind: "directive", type: i6.MatHeaderRowDef, selector: "[matHeaderRowDef]", inputs: ["matHeaderRowDef", "matHeaderRowDefSticky"] }, { kind: "directive", type: i6.MatColumnDef, selector: "[matColumnDef]", inputs: ["matColumnDef"] }, { kind: "directive", type: i6.MatCellDef, selector: "[matCellDef]" }, { kind: "directive", type: i6.MatRowDef, selector: "[matRowDef]", inputs: ["matRowDefColumns", "matRowDefWhen"] }, { kind: "directive", type: i6.MatFooterCellDef, selector: "[matFooterCellDef]" }, { kind: "directive", type: i6.MatHeaderCell, selector: "mat-header-cell, th[mat-header-cell]" }, { kind: "directive", type: i6.MatCell, selector: "mat-cell, td[mat-cell]" }, { kind: "directive", type: i6.MatFooterCell, selector: "mat-footer-cell, td[mat-footer-cell]" }, { kind: "component", type: i6.MatHeaderRow, selector: "mat-header-row, tr[mat-header-row]", exportAs: ["matHeaderRow"] }, { kind: "component", type: i6.MatRow, selector: "mat-row, tr[mat-row]", exportAs: ["matRow"] }, { kind: "component", type: i7.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i7.MatCardContent, selector: "mat-card-content" }, { kind: "directive", type: i2.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i8.TechlifyDeleteButtonComponent, selector: "app-techlify-delete-button", inputs: ["data", "model", "message", "service"], outputs: ["deleted"] }, { kind: "component", type: i9.TimelineFilterComponent, selector: "app-timeline-filter", inputs: ["defaultValue", "required", "disabled", "value", "timelines", "dateFrom", "dateTo", "appearance", "showClearButton", "form", "labelText"], outputs: ["selectionChange"] }, { kind: "component", type: i10.TechlifyFormButtonComponent, selector: "app-techlify-form-button", inputs: ["component", "model", "data", "width"], outputs: ["saved"] }, { kind: "component", type: i11.LockedDateLockUnlockButtonComponent, selector: "app-locked-date-lock-unlock-button", inputs: ["lockedDate"], outputs: ["onSave"] }, { kind: "pipe", type: i3.DatePipe, name: "date" }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LockedDateListComponent, deps: [{ token: i1.LockedDateService }, { token: i2.FormBuilder }, { token: i3.UserConfigService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: LockedDateListComponent, selector: "app-locked-date-list", usesInheritance: true, ngImport: i0, template: "<div class=\"d-flex flex-column gap-2\">\n  <mat-card appearance=\"outlined\" class=\"d-print-none\">\n    <mat-card-content class=\"d-flex flex-row align-items-center justify-content-between\">\n      <div class=\"d-flex flex-row gap-2 align-items-center justify-content-between\">\n        <h5 class=\"mb-0\">Locked Dates</h5>\n        <app-techlify-form-button [component]=\"formComponent()\"\n          (saved)=\"modelCreated($event)\"></app-techlify-form-button>\n      </div>\n\n      <form [formGroup]=\"filterForm\" class='d-flex flex-row gap-2'>\n        <app-timeline-filter labelText=\"Period\" [form]='filterForm'></app-timeline-filter>\n      </form>\n    </mat-card-content>\n  </mat-card>\n\n  <mat-card>\n    <mat-card-content>\n      <table class='w-100' mat-table [dataSource]=\"models\" matSort multiTemplateDataRows infiniteScroll\n        [infiniteScrollDistance]=\"1\" [infiniteScrollThrottle]=\"50\" (scrolled)=\"onScroll()\"\n        [infiniteScrollContainer]=\"scrollContainer\" [fromRoot]=\"true\" (matSortChange)=\"sortColumn($event)\">\n\n        <ng-container matColumnDef=\"index\">\n          <th mat-header-cell *matHeaderCellDef> # </th>\n          <td mat-cell *matCellDef=\"let element; let i = dataIndex\"> {{ i+1 }} </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"date\">\n          <th mat-header-cell *matHeaderCellDef mat-sort-header> Date </th>\n          <td mat-cell *matCellDef=\"let element\">\n            <div class=\"d-flex flex-row align-items-center gap-2\">\n              <span>{{element?.date | date: 'longDate'}}</span>\n              <span>\n                <i class=\"fa-solid fa-lock text-danger\" *ngIf=\"element?.status_id == 1\" matTooltip=\"Locked\"></i>\n                <i class=\"fa-solid fa-lock-open text-success\" *ngIf=\"element?.status_id == 2\" matTooltip=\"Unlocked\"></i>\n              </span>\n            </div>\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"locked_on\">\n          <th mat-header-cell *matHeaderCellDef> Locked On </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.created_at | date:'medium' }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"locked_by\">\n          <th mat-header-cell *matHeaderCellDef> Locked By </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.creator?.name }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"details\">\n          <th mat-header-cell *matHeaderCellDef> Details </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.details }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"actions\">\n          <th mat-header-cell *matHeaderCellDef> Actions </th>\n          <td mat-cell *matCellDef=\"let element\">\n            <div class=\"d-flex flex-row gap-2 text-secondary\">\n              <app-locked-date-lock-unlock-button [lockedDate]='element'\n                (onSave)='modelsUpdatedById($event)'></app-locked-date-lock-unlock-button>\n              <app-techlify-delete-button [service]=\"service\" [model]=\"element\"\n                [data]=\"{type: 'Locked Date', title: element?.date | date:'longDate'}\"\n                (deleted)=\"modelsDeletedById($event)\"></app-techlify-delete-button>\n            </div>\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <tr mat-header-row *matHeaderRowDef=\"displayedColumns; sticky: true\"></tr>\n        <tr mat-row *matRowDef=\"let row; columns: displayedColumns;\"></tr>\n      </table>\n    </mat-card-content>\n  </mat-card>\n</div>", dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i5.InfiniteScrollDirective, selector: "[infiniteScroll], [infinite-scroll], [data-infinite-scroll]", inputs: ["infiniteScrollDistance", "infiniteScrollUpDistance", "infiniteScrollThrottle", "infiniteScrollDisabled", "infiniteScrollContainer", "scrollWindow", "immediateCheck", "horizontal", "alwaysCallback", "fromRoot"], outputs: ["scrolled", "scrolledUp"] }, { kind: "directive", type: i6.MatSort, selector: "[matSort]", inputs: ["matSortActive", "matSortStart", "matSortDirection", "matSortDisableClear", "matSortDisabled"], outputs: ["matSortChange"], exportAs: ["matSort"] }, { kind: "component", type: i6.MatSortHeader, selector: "[mat-sort-header]", inputs: ["mat-sort-header", "arrowPosition", "start", "disabled", "sortActionDescription", "disableClear"], exportAs: ["matSortHeader"] }, { kind: "component", type: i7.MatTable, selector: "mat-table, table[mat-table]", exportAs: ["matTable"] }, { kind: "directive", type: i7.MatHeaderCellDef, selector: "[matHeaderCellDef]" }, { kind: "directive", type: i7.MatHeaderRowDef, selector: "[matHeaderRowDef]", inputs: ["matHeaderRowDef", "matHeaderRowDefSticky"] }, { kind: "directive", type: i7.MatColumnDef, selector: "[matColumnDef]", inputs: ["matColumnDef"] }, { kind: "directive", type: i7.MatCellDef, selector: "[matCellDef]" }, { kind: "directive", type: i7.MatRowDef, selector: "[matRowDef]", inputs: ["matRowDefColumns", "matRowDefWhen"] }, { kind: "directive", type: i7.MatFooterCellDef, selector: "[matFooterCellDef]" }, { kind: "directive", type: i7.MatHeaderCell, selector: "mat-header-cell, th[mat-header-cell]" }, { kind: "directive", type: i7.MatCell, selector: "mat-cell, td[mat-cell]" }, { kind: "directive", type: i7.MatFooterCell, selector: "mat-footer-cell, td[mat-footer-cell]" }, { kind: "component", type: i7.MatHeaderRow, selector: "mat-header-row, tr[mat-header-row]", exportAs: ["matHeaderRow"] }, { kind: "component", type: i7.MatRow, selector: "mat-row, tr[mat-row]", exportAs: ["matRow"] }, { kind: "component", type: i8.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i8.MatCardContent, selector: "mat-card-content" }, { kind: "directive", type: i9.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "directive", type: i2.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i10.TechlifyDeleteButtonComponent, selector: "app-techlify-delete-button", inputs: ["data", "model", "message", "service"], outputs: ["deleted"] }, { kind: "component", type: i11.TimelineFilterComponent, selector: "app-timeline-filter", inputs: ["defaultValue", "required", "disabled", "value", "timelines", "dateFrom", "dateTo", "appearance", "showClearButton", "form", "labelText"], outputs: ["selectionChange"] }, { kind: "component", type: i12.TechlifyFormButtonComponent, selector: "app-techlify-form-button", inputs: ["component", "model", "data", "width"], outputs: ["saved"] }, { kind: "component", type: i13.LockedDateLockUnlockButtonComponent, selector: "app-locked-date-lock-unlock-button", inputs: ["lockedDate"], outputs: ["onSave"] }, { kind: "pipe", type: i4.DatePipe, name: "date" }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LockedDateListComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'app-locked-date-list', providers: [DatePipe], template: "<div class=\"d-flex flex-column gap-2\">\n  <mat-card appearance=\"outlined\" class=\"d-print-none\">\n    <mat-card-content class=\"d-flex flex-row align-items-center justify-content-between\">\n      <div class=\"d-flex flex-row gap-2 align-items-center justify-content-between\">\n        <h5 class=\"mb-0\">Locked Dates</h5>\n        <app-techlify-form-button [component]=\"formComponent()\"\n          (saved)=\"modelCreated($event)\"></app-techlify-form-button>\n      </div>\n\n      <form [formGroup]=\"filterForm\" class='d-flex flex-row gap-2'>\n        <app-timeline-filter labelText=\"Period\" [form]='filterForm'></app-timeline-filter>\n      </form>\n    </mat-card-content>\n  </mat-card>\n\n  <mat-card>\n    <mat-card-content>\n      <table class='w-100' mat-table [dataSource]=\"models\" matSort multiTemplateDataRows infiniteScroll\n        [infiniteScrollDistance]=\"1\" [infiniteScrollThrottle]=\"50\" (scrolled)=\"onScroll()\" [scrollWindow]=\"false\"\n        [infiniteScrollContainer]=\"'.mat-sidenav-content'\" [fromRoot]=\"true\" (matSortChange)=\"sortColumn($event)\">\n\n        <ng-container matColumnDef=\"index\">\n          <th mat-header-cell *matHeaderCellDef> # </th>\n          <td mat-cell *matCellDef=\"let element; let i = dataIndex\"> {{ i+1 }} </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"date\">\n          <th mat-header-cell *matHeaderCellDef mat-sort-header> Date </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{element?.date | date: 'longDate'}}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"locked_on\">\n          <th mat-header-cell *matHeaderCellDef> Locked On </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.created_at | date:'medium' }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"locked_by\">\n          <th mat-header-cell *matHeaderCellDef> Locked By </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.creator?.name }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"details\">\n          <th mat-header-cell *matHeaderCellDef> Details </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.details }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"actions\">\n          <th mat-header-cell *matHeaderCellDef> Actions </th>\n          <td mat-cell *matCellDef=\"let element\">\n            <div class=\"d-flex flex-row gap-2 text-secondary\">\n              <app-locked-date-lock-unlock-button [lockedDate]='element'\n                (onSave)='reload()'></app-locked-date-lock-unlock-button>\n              <app-techlify-delete-button [service]=\"service\" [model]=\"element\"\n                [data]=\"{type: 'Locked Date', title: element?.date | date:'longDate'}\"\n                (deleted)=\"modelsDeletedById($event)\"></app-techlify-delete-button>\n            </div>\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <tr mat-header-row *matHeaderRowDef=\"displayedColumns; sticky: true\"></tr>\n        <tr mat-row *matRowDef=\"let row; columns: displayedColumns;\"></tr>\n      </table>\n    </mat-card-content>\n  </mat-card>\n</div>" }]
-        }], ctorParameters: () => [{ type: i1.LockedDateService }, { type: i2.FormBuilder }, { type: i3.DatePipe }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"locked-date-list.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-techlify-core/src/lib/locked-date/locked-dates-list/locked-date-list.component.ts","../../../../../../projects/ngx-techlify-core/src/lib/locked-date/locked-dates-list/locked-date-list.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,MAAM,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAGzD,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,uBAAuB,EAAE,MAAM,gDAAgD,CAAC;;;;;;;;;;;;;AAOzF,MAAM,OAAO,uBAAwB,SAAQ,qBAAqB;IAahE,YAA+B,OAA0B,EAC/C,EAAe,EACf,QAAkB;QAE1B,KAAK,EAAE,CAAC;QAJqB,YAAO,GAAP,OAAO,CAAmB;QAC/C,OAAE,GAAF,EAAE,CAAa;QACf,aAAQ,GAAR,QAAQ,CAAU;QAb5B,kBAAa,GAAG,MAAM,CAAC,uBAAuB,CAAC,CAAC;QAEhD,qBAAgB,GAAa;YAC3B,OAAO;YACP,MAAM;YACN,SAAS;YACT,WAAW;YACX,WAAW;YACX,SAAS;SACV,CAAC;QAQA,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC;YAC9B,SAAS,EAAE,CAAC,EAAE,CAAC;YACf,OAAO,EAAE,CAAC,EAAE,CAAC;YACb,OAAO,EAAE,CAAC,WAAW,CAAC;SACvB,CAAC,CAAC;IACL,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAEQ,QAAQ;QACf,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QAEtB,IAAI,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC;QACpC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACzB,OAAO,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS;YACnC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,EAAE,YAAY,CAAC;YAC1D,CAAC,CAAC,EAAE,CAAC;QACP,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO;YAC/B,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC;YACxD,CAAC,CAAC,EAAE,CAAC;QAEP,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC;YACpC,IAAI,EAAE,CAAC,QAAa,EAAE,EAAE;gBACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;gBAChD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,SAAS,CAAC;gBACnC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACzB,CAAC;SACF,CAAC,CAAC;IACL,CAAC;+GAlDU,uBAAuB;mGAAvB,uBAAuB,+CAFvB,CAAC,QAAQ,CAAC,iDCVvB,yiHA8EM;;4FDlEO,uBAAuB;kBALnC,SAAS;+BACE,sBAAsB,aAErB,CAAC,QAAQ,CAAC","sourcesContent":["import { Component, OnInit, signal } from '@angular/core';\nimport { TechlifyListComponent } from '../../base-model';\nimport { LockedDateService } from '../locked-date.service';\nimport { FormBuilder } from '@angular/forms';\nimport { DatePipe } from '@angular/common';\nimport { LockedDateFormComponent } from '../locked-date-form/locked-date-form.component';\n\n@Component({\n  selector: 'app-locked-date-list',\n  templateUrl: './locked-date-list.component.html',\n  providers: [DatePipe]\n})\nexport class LockedDateListComponent extends TechlifyListComponent implements OnInit {\n\n  formComponent = signal(LockedDateFormComponent);\n\n  displayedColumns: string[] = [\n    'index',\n    'date',\n    'details',\n    'locked_on',\n    'locked_by',\n    'actions'\n  ];\n\n  constructor(protected override service: LockedDateService,\n    private fb: FormBuilder,\n    private datePipe: DatePipe\n  ) {\n    super();\n\n    this.filterForm = this.fb.group({\n      date_from: [''],\n      date_to: [''],\n      sort_by: ['date|DESC'],\n    });\n  }\n\n  ngOnInit() {\n    this.listenFilterChanges();\n    this.loadData();\n  }\n\n  override loadData() {\n    this.isWorking = true;\n\n    let filters = this.filterForm.value;\n    filters.page = this.page;\n    filters.date_from = filters.date_from\n      ? this.datePipe.transform(filters.date_from, 'yyyy-MM-dd')\n      : '';\n    filters.date_to = filters.date_to\n      ? this.datePipe.transform(filters.date_to, 'yyyy-MM-dd')\n      : '';\n\n    this.service.index(filters).subscribe({\n      next: (response: any) => {\n        this.models = this.models.concat(response.data);\n        this.lastPage = response.last_page;\n        this.isWorking = false;\n      }\n    });\n  }\n}\n","<div class=\"d-flex flex-column gap-2\">\n  <mat-card appearance=\"outlined\" class=\"d-print-none\">\n    <mat-card-content class=\"d-flex flex-row align-items-center justify-content-between\">\n      <div class=\"d-flex flex-row gap-2 align-items-center justify-content-between\">\n        <h5 class=\"mb-0\">Locked Dates</h5>\n        <app-techlify-form-button [component]=\"formComponent()\"\n          (saved)=\"modelCreated($event)\"></app-techlify-form-button>\n      </div>\n\n      <form [formGroup]=\"filterForm\" class='d-flex flex-row gap-2'>\n        <app-timeline-filter labelText=\"Period\" [form]='filterForm'></app-timeline-filter>\n      </form>\n    </mat-card-content>\n  </mat-card>\n\n  <mat-card>\n    <mat-card-content>\n      <table class='w-100' mat-table [dataSource]=\"models\" matSort multiTemplateDataRows infiniteScroll\n        [infiniteScrollDistance]=\"1\" [infiniteScrollThrottle]=\"50\" (scrolled)=\"onScroll()\" [scrollWindow]=\"false\"\n        [infiniteScrollContainer]=\"'.mat-sidenav-content'\" [fromRoot]=\"true\" (matSortChange)=\"sortColumn($event)\">\n\n        <ng-container matColumnDef=\"index\">\n          <th mat-header-cell *matHeaderCellDef> # </th>\n          <td mat-cell *matCellDef=\"let element; let i = dataIndex\"> {{ i+1 }} </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"date\">\n          <th mat-header-cell *matHeaderCellDef mat-sort-header> Date </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{element?.date | date: 'longDate'}}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"locked_on\">\n          <th mat-header-cell *matHeaderCellDef> Locked On </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.created_at | date:'medium' }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"locked_by\">\n          <th mat-header-cell *matHeaderCellDef> Locked By </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.creator?.name }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"details\">\n          <th mat-header-cell *matHeaderCellDef> Details </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.details }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"actions\">\n          <th mat-header-cell *matHeaderCellDef> Actions </th>\n          <td mat-cell *matCellDef=\"let element\">\n            <div class=\"d-flex flex-row gap-2 text-secondary\">\n              <app-locked-date-lock-unlock-button [lockedDate]='element'\n                (onSave)='reload()'></app-locked-date-lock-unlock-button>\n              <app-techlify-delete-button [service]=\"service\" [model]=\"element\"\n                [data]=\"{type: 'Locked Date', title: element?.date | date:'longDate'}\"\n                (deleted)=\"modelsDeletedById($event)\"></app-techlify-delete-button>\n            </div>\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <tr mat-header-row *matHeaderRowDef=\"displayedColumns; sticky: true\"></tr>\n        <tr mat-row *matRowDef=\"let row; columns: displayedColumns;\"></tr>\n      </table>\n    </mat-card-content>\n  </mat-card>\n</div>"]}
+            args: [{ selector: 'app-locked-date-list', template: "<div class=\"d-flex flex-column gap-2\">\n  <mat-card appearance=\"outlined\" class=\"d-print-none\">\n    <mat-card-content class=\"d-flex flex-row align-items-center justify-content-between\">\n      <div class=\"d-flex flex-row gap-2 align-items-center justify-content-between\">\n        <h5 class=\"mb-0\">Locked Dates</h5>\n        <app-techlify-form-button [component]=\"formComponent()\"\n          (saved)=\"modelCreated($event)\"></app-techlify-form-button>\n      </div>\n\n      <form [formGroup]=\"filterForm\" class='d-flex flex-row gap-2'>\n        <app-timeline-filter labelText=\"Period\" [form]='filterForm'></app-timeline-filter>\n      </form>\n    </mat-card-content>\n  </mat-card>\n\n  <mat-card>\n    <mat-card-content>\n      <table class='w-100' mat-table [dataSource]=\"models\" matSort multiTemplateDataRows infiniteScroll\n        [infiniteScrollDistance]=\"1\" [infiniteScrollThrottle]=\"50\" (scrolled)=\"onScroll()\"\n        [infiniteScrollContainer]=\"scrollContainer\" [fromRoot]=\"true\" (matSortChange)=\"sortColumn($event)\">\n\n        <ng-container matColumnDef=\"index\">\n          <th mat-header-cell *matHeaderCellDef> # </th>\n          <td mat-cell *matCellDef=\"let element; let i = dataIndex\"> {{ i+1 }} </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"date\">\n          <th mat-header-cell *matHeaderCellDef mat-sort-header> Date </th>\n          <td mat-cell *matCellDef=\"let element\">\n            <div class=\"d-flex flex-row align-items-center gap-2\">\n              <span>{{element?.date | date: 'longDate'}}</span>\n              <span>\n                <i class=\"fa-solid fa-lock text-danger\" *ngIf=\"element?.status_id == 1\" matTooltip=\"Locked\"></i>\n                <i class=\"fa-solid fa-lock-open text-success\" *ngIf=\"element?.status_id == 2\" matTooltip=\"Unlocked\"></i>\n              </span>\n            </div>\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"locked_on\">\n          <th mat-header-cell *matHeaderCellDef> Locked On </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.created_at | date:'medium' }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"locked_by\">\n          <th mat-header-cell *matHeaderCellDef> Locked By </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.creator?.name }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"details\">\n          <th mat-header-cell *matHeaderCellDef> Details </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.details }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"actions\">\n          <th mat-header-cell *matHeaderCellDef> Actions </th>\n          <td mat-cell *matCellDef=\"let element\">\n            <div class=\"d-flex flex-row gap-2 text-secondary\">\n              <app-locked-date-lock-unlock-button [lockedDate]='element'\n                (onSave)='modelsUpdatedById($event)'></app-locked-date-lock-unlock-button>\n              <app-techlify-delete-button [service]=\"service\" [model]=\"element\"\n                [data]=\"{type: 'Locked Date', title: element?.date | date:'longDate'}\"\n                (deleted)=\"modelsDeletedById($event)\"></app-techlify-delete-button>\n            </div>\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <tr mat-header-row *matHeaderRowDef=\"displayedColumns; sticky: true\"></tr>\n        <tr mat-row *matRowDef=\"let row; columns: displayedColumns;\"></tr>\n      </table>\n    </mat-card-content>\n  </mat-card>\n</div>" }]
+        }], ctorParameters: () => [{ type: i1.LockedDateService }, { type: i2.FormBuilder }, { type: i3.UserConfigService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"locked-date-list.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-techlify-core/src/lib/locked-date/locked-dates-list/locked-date-list.component.ts","../../../../../../projects/ngx-techlify-core/src/lib/locked-date/locked-dates-list/locked-date-list.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,MAAM,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAGzD,OAAO,EAAE,uBAAuB,EAAE,MAAM,gDAAgD,CAAC;;;;;;;;;;;;;;;AAOzF,MAAM,OAAO,uBAAwB,SAAQ,qBAAqB;IAahE,YAA+B,OAA0B,EAC/C,EAAe,EACf,iBAAoC;QAE5C,KAAK,CAAC,OAAO,CAAC,CAAC;QAJc,YAAO,GAAP,OAAO,CAAmB;QAC/C,OAAE,GAAF,EAAE,CAAa;QACf,sBAAiB,GAAjB,iBAAiB,CAAmB;QAd9C,kBAAa,GAAG,MAAM,CAAC,uBAAuB,CAAC,CAAC;QAChD,oBAAe,GAAG,sBAAsB,CAAC;QAEzC,qBAAgB,GAAa;YAC3B,OAAO;YACP,MAAM;YACN,SAAS;YACT,WAAW;YACX,WAAW;YACX,SAAS;SACV,CAAC;QAQA,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,CAAC;QAClD,IAAI,MAAM,EAAE,eAAe,EAAE,CAAC;YAC5B,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,KAAK,MAAM;gBACtD,CAAC,CAAC,IAAI;gBACN,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC;QAC7B,CAAC;QAED,IAAI,CAAC,uBAAuB,GAAG;YAC7B,SAAS,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE;YACzB,OAAO,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE;SACxB,CAAC;QACF,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC;YAC9B,SAAS,EAAE,CAAC,EAAE,CAAC;YACf,OAAO,EAAE,CAAC,EAAE,CAAC;YACb,OAAO,EAAE,CAAC,WAAW,CAAC;SACvB,CAAC,CAAC;IACL,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC7B,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;+GAzCU,uBAAuB;mGAAvB,uBAAuB,mFCXpC,w6HAoFM;;4FDzEO,uBAAuB;kBAJnC,SAAS;+BACE,sBAAsB","sourcesContent":["import { Component, OnInit, signal } from '@angular/core';\nimport { TechlifyListComponent } from '../../base-model';\nimport { LockedDateService } from '../locked-date.service';\nimport { FormBuilder } from '@angular/forms';\nimport { LockedDateFormComponent } from '../locked-date-form/locked-date-form.component';\nimport { UserConfigService } from '../../user-config/user-config.service';\n\n@Component({\n  selector: 'app-locked-date-list',\n  templateUrl: './locked-date-list.component.html'\n})\nexport class LockedDateListComponent extends TechlifyListComponent implements OnInit {\n  formComponent = signal(LockedDateFormComponent);\n  scrollContainer = '.mat-sidenav-content';\n\n  displayedColumns: string[] = [\n    'index',\n    'date',\n    'details',\n    'locked_on',\n    'locked_by',\n    'actions'\n  ];\n\n  constructor(protected override service: LockedDateService,\n    private fb: FormBuilder,\n    private userConfigService: UserConfigService\n  ) {\n    super(service);\n\n    const config = this.userConfigService.getConfig();\n    if (config?.scrollContainer) {\n      this.scrollContainer = config.scrollContainer === 'root'\n        ? null\n        : config.scrollContainer;\n    }\n\n    this.filterFormConfiguration = {\n      date_from: { date: true },\n      date_to: { date: true },\n    };\n    this.filterForm = this.fb.group({\n      date_from: [''],\n      date_to: [''],\n      sort_by: ['date|DESC'],\n    });\n  }\n\n  ngOnInit() {\n    this.patchFiltersFromRoute();\n    this.listenFilterChanges();\n    this.loadData();\n  }\n}\n","<div class=\"d-flex flex-column gap-2\">\n  <mat-card appearance=\"outlined\" class=\"d-print-none\">\n    <mat-card-content class=\"d-flex flex-row align-items-center justify-content-between\">\n      <div class=\"d-flex flex-row gap-2 align-items-center justify-content-between\">\n        <h5 class=\"mb-0\">Locked Dates</h5>\n        <app-techlify-form-button [component]=\"formComponent()\"\n          (saved)=\"modelCreated($event)\"></app-techlify-form-button>\n      </div>\n\n      <form [formGroup]=\"filterForm\" class='d-flex flex-row gap-2'>\n        <app-timeline-filter labelText=\"Period\" [form]='filterForm'></app-timeline-filter>\n      </form>\n    </mat-card-content>\n  </mat-card>\n\n  <mat-card>\n    <mat-card-content>\n      <table class='w-100' mat-table [dataSource]=\"models\" matSort multiTemplateDataRows infiniteScroll\n        [infiniteScrollDistance]=\"1\" [infiniteScrollThrottle]=\"50\" (scrolled)=\"onScroll()\"\n        [infiniteScrollContainer]=\"scrollContainer\" [fromRoot]=\"true\" (matSortChange)=\"sortColumn($event)\">\n\n        <ng-container matColumnDef=\"index\">\n          <th mat-header-cell *matHeaderCellDef> # </th>\n          <td mat-cell *matCellDef=\"let element; let i = dataIndex\"> {{ i+1 }} </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"date\">\n          <th mat-header-cell *matHeaderCellDef mat-sort-header> Date </th>\n          <td mat-cell *matCellDef=\"let element\">\n            <div class=\"d-flex flex-row align-items-center gap-2\">\n              <span>{{element?.date | date: 'longDate'}}</span>\n              <span>\n                <i class=\"fa-solid fa-lock text-danger\" *ngIf=\"element?.status_id == 1\" matTooltip=\"Locked\"></i>\n                <i class=\"fa-solid fa-lock-open text-success\" *ngIf=\"element?.status_id == 2\" matTooltip=\"Unlocked\"></i>\n              </span>\n            </div>\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"locked_on\">\n          <th mat-header-cell *matHeaderCellDef> Locked On </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.created_at | date:'medium' }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"locked_by\">\n          <th mat-header-cell *matHeaderCellDef> Locked By </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.creator?.name }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"details\">\n          <th mat-header-cell *matHeaderCellDef> Details </th>\n          <td mat-cell *matCellDef=\"let element\">\n            {{ element?.details }}\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <ng-container matColumnDef=\"actions\">\n          <th mat-header-cell *matHeaderCellDef> Actions </th>\n          <td mat-cell *matCellDef=\"let element\">\n            <div class=\"d-flex flex-row gap-2 text-secondary\">\n              <app-locked-date-lock-unlock-button [lockedDate]='element'\n                (onSave)='modelsUpdatedById($event)'></app-locked-date-lock-unlock-button>\n              <app-techlify-delete-button [service]=\"service\" [model]=\"element\"\n                [data]=\"{type: 'Locked Date', title: element?.date | date:'longDate'}\"\n                (deleted)=\"modelsDeletedById($event)\"></app-techlify-delete-button>\n            </div>\n          </td>\n          <td mat-footer-cell *matFooterCellDef></td>\n        </ng-container>\n\n        <tr mat-header-row *matHeaderRowDef=\"displayedColumns; sticky: true\"></tr>\n        <tr mat-row *matRowDef=\"let row; columns: displayedColumns;\"></tr>\n      </table>\n    </mat-card-content>\n  </mat-card>\n</div>"]}