@alfresco/adf-core 8.1.0-16295066092 → 8.1.0-16320806191

package/esm2022/lib/datatable/components/datatable-cell/datatable-cell.component.mjs

@@ -0,0 +1,126 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ChangeDetectionStrategy, Component, DestroyRef, inject, Input, ViewEncapsulation } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { DataTableService } from '../../services/datatable.service';
+import { CommonModule } from '@angular/common';
+import { ClipboardDirective } from '../../../clipboard/clipboard.directive';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { TruncatePipe } from '../../../pipes/truncate.pipe';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class DataTableCellComponent {
+    constructor() {
+        /** Custom resolver function which is used to parse dynamic column objects */
+        this.resolverFn = null;
+        this.destroyRef = inject(DestroyRef);
+        this.dataTableService = inject(DataTableService, { optional: true });
+        this.value$ = new BehaviorSubject('');
+    }
+    ngOnInit() {
+        this.updateValue();
+        this.subscribeToRowUpdates();
+    }
+    updateValue() {
+        if (this.column?.key && this.row && this.data) {
+            const value = this.data.getValue(this.row, this.column, this.resolverFn);
+            this.value$.next(value);
+            if (!this.tooltip) {
+                this.tooltip = value;
+            }
+        }
+    }
+    subscribeToRowUpdates() {
+        if (!this.dataTableService || !this.row.obj) {
+            return;
+        }
+        this.dataTableService.rowUpdate.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((data) => {
+            if (data?.id === this.row?.id && data.obj) {
+                this.row.obj = data.obj;
+                this.row['cache'][this.column.key] = this.getNestedPropertyValue(data.obj, this.column.key);
+                this.updateValue();
+            }
+        });
+    }
+    getNestedPropertyValue(obj, path) {
+        return path.split('.').reduce((source, key) => (source ? source[key] : ''), obj);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DataTableCellComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: DataTableCellComponent, isStandalone: true, selector: "adf-datatable-cell", inputs: { data: "data", column: "column", row: "row", copyContent: "copyContent", tooltip: "tooltip", resolverFn: "resolverFn" }, host: { classAttribute: "adf-datatable-content-cell" }, ngImport: i0, template: `
+        <ng-container>
+            <span
+                *ngIf="copyContent; else defaultCell"
+                adf-clipboard="CLIPBOARD.CLICK_TO_COPY"
+                [clipboard-notification]="'CLIPBOARD.SUCCESS_COPY'"
+                [attr.aria-label]="value$ | async"
+                [title]="tooltip"
+                class="adf-datatable-cell-value"
+                >{{ column?.maxTextLength ? (value$ | async | truncate : column?.maxTextLength) : (value$ | async) }}</span
+            >
+        </ng-container>
+        <ng-template #defaultCell>
+            <span [title]="tooltip" class="adf-datatable-cell-value">{{
+                column?.maxTextLength ? (value$ | async | truncate : column?.maxTextLength) : (value$ | async)
+            }}</span>
+        </ng-template>
+    `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "directive", type: ClipboardDirective, selector: "[adf-clipboard]", inputs: ["adf-clipboard", "target", "clipboard-notification"], exportAs: ["adfClipboard"] }, { kind: "pipe", type: TruncatePipe, name: "truncate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DataTableCellComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'adf-datatable-cell',
+                    standalone: true,
+                    imports: [CommonModule, ClipboardDirective, TruncatePipe],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+        <ng-container>
+            <span
+                *ngIf="copyContent; else defaultCell"
+                adf-clipboard="CLIPBOARD.CLICK_TO_COPY"
+                [clipboard-notification]="'CLIPBOARD.SUCCESS_COPY'"
+                [attr.aria-label]="value$ | async"
+                [title]="tooltip"
+                class="adf-datatable-cell-value"
+                >{{ column?.maxTextLength ? (value$ | async | truncate : column?.maxTextLength) : (value$ | async) }}</span
+            >
+        </ng-container>
+        <ng-template #defaultCell>
+            <span [title]="tooltip" class="adf-datatable-cell-value">{{
+                column?.maxTextLength ? (value$ | async | truncate : column?.maxTextLength) : (value$ | async)
+            }}</span>
+        </ng-template>
+    `,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'adf-datatable-content-cell' }
+                }]
+        }], propDecorators: { data: [{
+                type: Input,
+                args: [{ required: true }]
+            }], column: [{
+                type: Input,
+                args: [{ required: true }]
+            }], row: [{
+                type: Input,
+                args: [{ required: true }]
+            }], copyContent: [{
+                type: Input
+            }], tooltip: [{
+                type: Input
+            }], resolverFn: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datatable-cell.component.js","sourceRoot":"","sources":["../../../../../../../../lib/core/src/lib/datatable/components/datatable-cell/datatable-cell.component.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAU,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAIzH,OAAO,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AACvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;;;AA4B5D,MAAM,OAAO,sBAAsB;IA1BnC;QA+CI,6EAA6E;QAE7E,eAAU,GAA2C,IAAI,CAAC;QAEhD,eAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAChC,qBAAgB,GAAG,MAAM,CAAC,gBAAgB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;QAC1E,WAAM,GAAG,IAAI,eAAe,CAAM,EAAE,CAAC,CAAC;KAqCzC;IAnCG,QAAQ;QACJ,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,qBAAqB,EAAE,CAAC;IACjC,CAAC;IAES,WAAW;QACjB,IAAI,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;YAEzE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAExB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;gBAChB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACzB,CAAC;QACL,CAAC;IACL,CAAC;IAEO,qBAAqB;QACzB,IAAI,CAAC,IAAI,CAAC,gBAAgB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;YAC1C,OAAO;QACX,CAAC;QAED,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;YACzF,IAAI,IAAI,EAAE,EAAE,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;gBACxC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC;gBACxB,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBAE5F,IAAI,CAAC,WAAW,EAAE,CAAC;YACvB,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,sBAAsB,CAAC,GAAQ,EAAE,IAAY;QACjD,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;IACrF,CAAC;+GA/DQ,sBAAsB;mGAAtB,sBAAsB,wQArBrB;;;;;;;;;;;;;;;;;KAiBT,2DAnBS,YAAY,wLAAE,kBAAkB,kJAAE,YAAY;;4FAuB/C,sBAAsB;kBA1BlC,SAAS;mBAAC;oBACP,QAAQ,EAAE,oBAAoB;oBAC9B,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE,CAAC,YAAY,EAAE,kBAAkB,EAAE,YAAY,CAAC;oBACzD,eAAe,EAAE,uBAAuB,CAAC,MAAM;oBAC/C,QAAQ,EAAE;;;;;;;;;;;;;;;;;KAiBT;oBACD,aAAa,EAAE,iBAAiB,CAAC,IAAI;oBACrC,IAAI,EAAE,EAAE,KAAK,EAAE,4BAA4B,EAAE;iBAChD;8BAIG,IAAI;sBADH,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAKzB,MAAM;sBADL,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAKzB,GAAG;sBADF,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAKzB,WAAW;sBADV,KAAK;gBAKN,OAAO;sBADN,KAAK;gBAKN,UAAU;sBADT,KAAK","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ChangeDetectionStrategy, Component, DestroyRef, inject, Input, OnInit, ViewEncapsulation } from '@angular/core';\nimport { DataColumn } from '../../data/data-column.model';\nimport { DataRow } from '../../data/data-row.model';\nimport { DataTableAdapter } from '../../data/datatable-adapter';\nimport { BehaviorSubject } from 'rxjs';\nimport { DataTableService } from '../../services/datatable.service';\nimport { CommonModule } from '@angular/common';\nimport { ClipboardDirective } from '../../../clipboard/clipboard.directive';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { TruncatePipe } from '../../../pipes/truncate.pipe';\n\n@Component({\n    selector: 'adf-datatable-cell',\n    standalone: true,\n    imports: [CommonModule, ClipboardDirective, TruncatePipe],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    template: `\n        <ng-container>\n            <span\n                *ngIf=\"copyContent; else defaultCell\"\n                adf-clipboard=\"CLIPBOARD.CLICK_TO_COPY\"\n                [clipboard-notification]=\"'CLIPBOARD.SUCCESS_COPY'\"\n                [attr.aria-label]=\"value$ | async\"\n                [title]=\"tooltip\"\n                class=\"adf-datatable-cell-value\"\n                >{{ column?.maxTextLength ? (value$ | async | truncate : column?.maxTextLength) : (value$ | async) }}</span\n            >\n        </ng-container>\n        <ng-template #defaultCell>\n            <span [title]=\"tooltip\" class=\"adf-datatable-cell-value\">{{\n                column?.maxTextLength ? (value$ | async | truncate : column?.maxTextLength) : (value$ | async)\n            }}</span>\n        </ng-template>\n    `,\n    encapsulation: ViewEncapsulation.None,\n    host: { class: 'adf-datatable-content-cell' }\n})\nexport class DataTableCellComponent implements OnInit {\n    /** Data table adapter instance. */\n    @Input({ required: true })\n    data: DataTableAdapter;\n\n    /** Data that defines the column. */\n    @Input({ required: true })\n    column: DataColumn;\n\n    /** Data that defines the row. */\n    @Input({ required: true })\n    row: DataRow;\n\n    /** Enables/disables a Clipboard directive to allow copying of the cell's content. */\n    @Input()\n    copyContent: boolean;\n\n    /** Text for the cell's tooltip. */\n    @Input()\n    tooltip: string;\n\n    /** Custom resolver function which is used to parse dynamic column objects */\n    @Input()\n    resolverFn: (row: DataRow, col: DataColumn) => any = null;\n\n    protected destroyRef = inject(DestroyRef);\n    protected dataTableService = inject(DataTableService, { optional: true });\n    value$ = new BehaviorSubject<any>('');\n\n    ngOnInit() {\n        this.updateValue();\n        this.subscribeToRowUpdates();\n    }\n\n    protected updateValue() {\n        if (this.column?.key && this.row && this.data) {\n            const value = this.data.getValue(this.row, this.column, this.resolverFn);\n\n            this.value$.next(value);\n\n            if (!this.tooltip) {\n                this.tooltip = value;\n            }\n        }\n    }\n\n    private subscribeToRowUpdates() {\n        if (!this.dataTableService || !this.row.obj) {\n            return;\n        }\n\n        this.dataTableService.rowUpdate.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((data) => {\n            if (data?.id === this.row?.id && data.obj) {\n                this.row.obj = data.obj;\n                this.row['cache'][this.column.key] = this.getNestedPropertyValue(data.obj, this.column.key);\n\n                this.updateValue();\n            }\n        });\n    }\n\n    private getNestedPropertyValue(obj: any, path: string) {\n        return path.split('.').reduce((source, key) => (source ? source[key] : ''), obj);\n    }\n}\n"]}

package/esm2022/lib/datatable/components/datatable-row/datatable-row.component.mjs

@@ -0,0 +1,98 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component, ElementRef, EventEmitter, HostBinding, HostListener, Input, Output, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DataTableRowComponent {
+    get isSelected() {
+        if (!this.row) {
+            return false;
+        }
+        return this.row.isSelected;
+    }
+    get isAriaSelected() {
+        if (!this.row) {
+            return false;
+        }
+        return this.row.isSelected;
+    }
+    get ariaLabel() {
+        if (!this.row) {
+            return null;
+        }
+        if (this.row.isSelected) {
+            return this.row.getValue('name') + ' selected' || '';
+        }
+        else {
+            return this.row.getValue('name') || '';
+        }
+    }
+    get tabindex() {
+        return this.disabled ? null : 0;
+    }
+    onKeyDown(event) {
+        if (event.target.tagName === this.element.nativeElement.tagName) {
+            event.preventDefault();
+            this.select.emit(event);
+        }
+    }
+    constructor(element) {
+        this.element = element;
+        this.disabled = false;
+        this.select = new EventEmitter();
+    }
+    focus() {
+        this.element.nativeElement.focus();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DataTableRowComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: DataTableRowComponent, isStandalone: true, selector: "adf-datatable-row", inputs: { row: "row", disabled: "disabled" }, outputs: { select: "select" }, host: { attributes: { "tabindex": "0", "role": "row" }, listeners: { "keydown.space": "onKeyDown($event)" }, properties: { "class.adf-is-selected": "this.isSelected", "attr.aria-selected": "this.isAriaSelected", "attr.aria-label": "this.ariaLabel", "attr.tabindex": "this.tabindex" }, classAttribute: "adf-datatable-row" }, ngImport: i0, template: `<ng-content />`, isInline: true, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DataTableRowComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'adf-datatable-row',
+                    standalone: true,
+                    template: `<ng-content />`,
+                    encapsulation: ViewEncapsulation.None,
+                    host: {
+                        class: 'adf-datatable-row',
+                        tabindex: '0',
+                        role: 'row'
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { row: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], select: [{
+                type: Output
+            }], isSelected: [{
+                type: HostBinding,
+                args: ['class.adf-is-selected']
+            }], isAriaSelected: [{
+                type: HostBinding,
+                args: ['attr.aria-selected']
+            }], ariaLabel: [{
+                type: HostBinding,
+                args: ['attr.aria-label']
+            }], tabindex: [{
+                type: HostBinding,
+                args: ['attr.tabindex']
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown.space', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXRhYmxlLXJvdy5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL2RhdGF0YWJsZS9jb21wb25lbnRzL2RhdGF0YWJsZS1yb3cvZGF0YXRhYmxlLXJvdy5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsT0FBTyxFQUFFLFNBQVMsRUFBRSxVQUFVLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFlakksTUFBTSxPQUFPLHFCQUFxQjtJQVE5QixJQUNJLFVBQVU7UUFDVixJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1lBQ1osT0FBTyxLQUFLLENBQUM7UUFDakIsQ0FBQztRQUNELE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUM7SUFDL0IsQ0FBQztJQUVELElBQ0ksY0FBYztRQUNkLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7WUFDWixPQUFPLEtBQUssQ0FBQztRQUNqQixDQUFDO1FBQ0QsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQztJQUMvQixDQUFDO0lBRUQsSUFDSSxTQUFTO1FBQ1QsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUNaLE9BQU8sSUFBSSxDQUFDO1FBQ2hCLENBQUM7UUFDRCxJQUFJLElBQUksQ0FBQyxHQUFHLENBQUMsVUFBVSxFQUFFLENBQUM7WUFDdEIsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsR0FBRyxXQUFXLElBQUksRUFBRSxDQUFDO1FBQ3pELENBQUM7YUFBTSxDQUFDO1lBQ0osT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDM0MsQ0FBQztJQUNMLENBQUM7SUFFRCxJQUNJLFFBQVE7UUFDUixPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3BDLENBQUM7SUFHRCxTQUFTLENBQUMsS0FBb0I7UUFDMUIsSUFBSyxLQUFLLENBQUMsTUFBa0IsQ0FBQyxPQUFPLEtBQUssSUFBSSxDQUFDLE9BQU8sQ0FBQyxhQUFhLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDM0UsS0FBSyxDQUFDLGNBQWMsRUFBRSxDQUFDO1lBQ3ZCLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQzVCLENBQUM7SUFDTCxDQUFDO0lBRUQsWUFBb0IsT0FBbUI7UUFBbkIsWUFBTyxHQUFQLE9BQU8sQ0FBWTtRQTlDOUIsYUFBUSxHQUFHLEtBQUssQ0FBQztRQUcxQixXQUFNLEdBQXNCLElBQUksWUFBWSxFQUFPLENBQUM7SUEyQ1YsQ0FBQztJQUUzQyxLQUFLO1FBQ0QsSUFBSSxDQUFDLE9BQU8sQ0FBQyxhQUFhLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDdkMsQ0FBQzsrR0FyRFEscUJBQXFCO21HQUFyQixxQkFBcUIsOGRBUnBCLGdCQUFnQjs7NEZBUWpCLHFCQUFxQjtrQkFYakMsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsbUJBQW1CO29CQUM3QixVQUFVLEVBQUUsSUFBSTtvQkFDaEIsUUFBUSxFQUFFLGdCQUFnQjtvQkFDMUIsYUFBYSxFQUFFLGlCQUFpQixDQUFDLElBQUk7b0JBQ3JDLElBQUksRUFBRTt3QkFDRixLQUFLLEVBQUUsbUJBQW1CO3dCQUMxQixRQUFRLEVBQUUsR0FBRzt3QkFDYixJQUFJLEVBQUUsS0FBSztxQkFDZDtpQkFDSjsrRUFFWSxHQUFHO3NCQUFYLEtBQUs7Z0JBRUcsUUFBUTtzQkFBaEIsS0FBSztnQkFHTixNQUFNO3NCQURMLE1BQU07Z0JBSUgsVUFBVTtzQkFEYixXQUFXO3VCQUFDLHVCQUF1QjtnQkFTaEMsY0FBYztzQkFEakIsV0FBVzt1QkFBQyxvQkFBb0I7Z0JBUzdCLFNBQVM7c0JBRFosV0FBVzt1QkFBQyxpQkFBaUI7Z0JBYTFCLFFBQVE7c0JBRFgsV0FBVzt1QkFBQyxlQUFlO2dCQU01QixTQUFTO3NCQURSLFlBQVk7dUJBQUMsZUFBZSxFQUFFLENBQUMsUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQgeyBDb21wb25lbnQsIEVsZW1lbnRSZWYsIEV2ZW50RW1pdHRlciwgSG9zdEJpbmRpbmcsIEhvc3RMaXN0ZW5lciwgSW5wdXQsIE91dHB1dCwgVmlld0VuY2Fwc3VsYXRpb24gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEZvY3VzYWJsZU9wdGlvbiB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9hMTF5JztcbmltcG9ydCB7IERhdGFSb3cgfSBmcm9tICcuLi8uLi9kYXRhL2RhdGEtcm93Lm1vZGVsJztcblxuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICdhZGYtZGF0YXRhYmxlLXJvdycsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgICB0ZW1wbGF0ZTogYDxuZy1jb250ZW50IC8+YCxcbiAgICBlbmNhcHN1bGF0aW9uOiBWaWV3RW5jYXBzdWxhdGlvbi5Ob25lLFxuICAgIGhvc3Q6IHtcbiAgICAgICAgY2xhc3M6ICdhZGYtZGF0YXRhYmxlLXJvdycsXG4gICAgICAgIHRhYmluZGV4OiAnMCcsXG4gICAgICAgIHJvbGU6ICdyb3cnXG4gICAgfVxufSlcbmV4cG9ydCBjbGFzcyBEYXRhVGFibGVSb3dDb21wb25lbnQgaW1wbGVtZW50cyBGb2N1c2FibGVPcHRpb24ge1xuICAgIEBJbnB1dCgpIHJvdzogRGF0YVJvdztcblxuICAgIEBJbnB1dCgpIGRpc2FibGVkID0gZmFsc2U7XG5cbiAgICBAT3V0cHV0KClcbiAgICBzZWxlY3Q6IEV2ZW50RW1pdHRlcjxhbnk+ID0gbmV3IEV2ZW50RW1pdHRlcjxhbnk+KCk7XG5cbiAgICBASG9zdEJpbmRpbmcoJ2NsYXNzLmFkZi1pcy1zZWxlY3RlZCcpXG4gICAgZ2V0IGlzU2VsZWN0ZWQoKTogYm9vbGVhbiB7XG4gICAgICAgIGlmICghdGhpcy5yb3cpIHtcbiAgICAgICAgICAgIHJldHVybiBmYWxzZTtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gdGhpcy5yb3cuaXNTZWxlY3RlZDtcbiAgICB9XG5cbiAgICBASG9zdEJpbmRpbmcoJ2F0dHIuYXJpYS1zZWxlY3RlZCcpXG4gICAgZ2V0IGlzQXJpYVNlbGVjdGVkKCk6IGJvb2xlYW4ge1xuICAgICAgICBpZiAoIXRoaXMucm93KSB7XG4gICAgICAgICAgICByZXR1cm4gZmFsc2U7XG4gICAgICAgIH1cbiAgICAgICAgcmV0dXJuIHRoaXMucm93LmlzU2VsZWN0ZWQ7XG4gICAgfVxuXG4gICAgQEhvc3RCaW5kaW5nKCdhdHRyLmFyaWEtbGFiZWwnKVxuICAgIGdldCBhcmlhTGFiZWwoKTogc3RyaW5nIHwgbnVsbCB7XG4gICAgICAgIGlmICghdGhpcy5yb3cpIHtcbiAgICAgICAgICAgIHJldHVybiBudWxsO1xuICAgICAgICB9XG4gICAgICAgIGlmICh0aGlzLnJvdy5pc1NlbGVjdGVkKSB7XG4gICAgICAgICAgICByZXR1cm4gdGhpcy5yb3cuZ2V0VmFsdWUoJ25hbWUnKSArICcgc2VsZWN0ZWQnIHx8ICcnO1xuICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgcmV0dXJuIHRoaXMucm93LmdldFZhbHVlKCduYW1lJykgfHwgJyc7XG4gICAgICAgIH1cbiAgICB9XG5cbiAgICBASG9zdEJpbmRpbmcoJ2F0dHIudGFiaW5kZXgnKVxuICAgIGdldCB0YWJpbmRleCgpOiBudW1iZXIgfCBudWxsIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuZGlzYWJsZWQgPyBudWxsIDogMDtcbiAgICB9XG5cbiAgICBASG9zdExpc3RlbmVyKCdrZXlkb3duLnNwYWNlJywgWyckZXZlbnQnXSlcbiAgICBvbktleURvd24oZXZlbnQ6IEtleWJvYXJkRXZlbnQpIHtcbiAgICAgICAgaWYgKChldmVudC50YXJnZXQgYXMgRWxlbWVudCkudGFnTmFtZSA9PT0gdGhpcy5lbGVtZW50Lm5hdGl2ZUVsZW1lbnQudGFnTmFtZSkge1xuICAgICAgICAgICAgZXZlbnQucHJldmVudERlZmF1bHQoKTtcbiAgICAgICAgICAgIHRoaXMuc2VsZWN0LmVtaXQoZXZlbnQpO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBlbGVtZW50OiBFbGVtZW50UmVmKSB7fVxuXG4gICAgZm9jdXMoKSB7XG4gICAgICAgIHRoaXMuZWxlbWVudC5uYXRpdmVFbGVtZW50LmZvY3VzKCk7XG4gICAgfVxufVxuIl19

package/esm2022/lib/datatable/components/date-cell/date-cell.component.mjs

@@ -0,0 +1,78 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ChangeDetectionStrategy, Component, Input, ViewEncapsulation, inject } from '@angular/core';
+import { DataTableCellComponent } from '../datatable-cell/datatable-cell.component';
+import { AppConfigService } from '../../../app-config/app-config.service';
+import { CommonModule } from '@angular/common';
+import { LocalizedDatePipe, TimeAgoPipe } from '../../../pipes';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class DateCellComponent extends DataTableCellComponent {
+    constructor() {
+        super(...arguments);
+        this.config = {};
+        this.appConfig = inject(AppConfigService);
+        this.defaultDateConfig = {
+            format: 'medium',
+            tooltipFormat: 'medium',
+            locale: undefined
+        };
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.setConfig();
+    }
+    setConfig() {
+        if (this.dateConfig) {
+            this.setCustomConfig();
+        }
+        else {
+            this.setDefaultConfig();
+        }
+    }
+    setCustomConfig() {
+        this.config.format = this.dateConfig?.format || this.getDefaultFormat();
+        this.config.tooltipFormat = this.dateConfig?.tooltipFormat || this.getDefaultTooltipFormat();
+        this.config.locale = this.dateConfig?.locale || this.getDefaultLocale();
+    }
+    setDefaultConfig() {
+        this.config.format = this.getDefaultFormat();
+        this.config.tooltipFormat = this.getDefaultTooltipFormat();
+        this.config.locale = this.getDefaultLocale();
+    }
+    getDefaultFormat() {
+        return this.column?.format || this.getAppConfigPropertyValue('dateValues.defaultDateFormat', this.defaultDateConfig.format);
+    }
+    getDefaultLocale() {
+        return this.getAppConfigPropertyValue('dateValues.defaultLocale', this.defaultDateConfig.locale);
+    }
+    getDefaultTooltipFormat() {
+        return this.getAppConfigPropertyValue('dateValues.defaultTooltipDateFormat', this.defaultDateConfig.tooltipFormat);
+    }
+    getAppConfigPropertyValue(key, defaultValue) {
+        return this.appConfig.get(key, defaultValue);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DateCellComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: DateCellComponent, isStandalone: true, selector: "adf-date-cell", inputs: { dateConfig: "dateConfig" }, host: { classAttribute: "adf-datatable-content-cell" }, usesInheritance: true, ngImport: i0, template: "<ng-container *ngIf=\"value$ | async as date\">\n    <span\n        [title]=\"tooltip | adfLocalizedDate: config.tooltipFormat: config.locale\"\n        class=\"adf-datatable-cell-value\"\n        *ngIf=\"config.format === 'timeAgo'; else standard_date\">\n            {{ date | adfTimeAgo: config.locale }}\n    </span>\n    <ng-template #standard_date>\n        <span\n            class=\"adf-datatable-cell-value\"\n            [title]=\"tooltip | adfLocalizedDate: config.tooltipFormat: config.locale\">\n                {{ date | adfLocalizedDate: config.format: config.locale }}\n        </span>\n    </ng-template>\n</ng-container>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: LocalizedDatePipe, name: "adfLocalizedDate" }, { kind: "pipe", type: TimeAgoPipe, name: "adfTimeAgo" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DateCellComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [CommonModule, LocalizedDatePipe, TimeAgoPipe], selector: 'adf-date-cell', encapsulation: ViewEncapsulation.None, host: { class: 'adf-datatable-content-cell' }, changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"value$ | async as date\">\n    <span\n        [title]=\"tooltip | adfLocalizedDate: config.tooltipFormat: config.locale\"\n        class=\"adf-datatable-cell-value\"\n        *ngIf=\"config.format === 'timeAgo'; else standard_date\">\n            {{ date | adfTimeAgo: config.locale }}\n    </span>\n    <ng-template #standard_date>\n        <span\n            class=\"adf-datatable-cell-value\"\n            [title]=\"tooltip | adfLocalizedDate: config.tooltipFormat: config.locale\">\n                {{ date | adfLocalizedDate: config.format: config.locale }}\n        </span>\n    </ng-template>\n</ng-container>\n" }]
+        }], propDecorators: { dateConfig: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-cell.component.js","sourceRoot":"","sources":["../../../../../../../../lib/core/src/lib/datatable/components/date-cell/date-cell.component.ts","../../../../../../../../lib/core/src/lib/datatable/components/date-cell/date-cell.component.html"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,KAAK,EAAU,iBAAiB,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC7G,OAAO,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AACpF,OAAO,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAE1E,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;;;AAWhE,MAAM,OAAO,iBAAkB,SAAQ,sBAAsB;IAT7D;;QAaI,WAAM,GAAe,EAAE,CAAC;QAEP,cAAS,GAAqB,MAAM,CAAC,gBAAgB,CAAC,CAAC;QAE/D,sBAAiB,GAAe;YACrC,MAAM,EAAE,QAAQ;YAChB,aAAa,EAAE,QAAQ;YACvB,MAAM,EAAE,SAAS;SACpB,CAAC;KA0CL;IAxCG,QAAQ;QACJ,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjB,IAAI,CAAC,SAAS,EAAE,CAAC;IACrB,CAAC;IAEO,SAAS;QACb,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,IAAI,CAAC,eAAe,EAAE,CAAC;QAC3B,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC5B,CAAC;IACL,CAAC;IAEO,eAAe;QACnB,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxE,IAAI,CAAC,MAAM,CAAC,aAAa,GAAG,IAAI,CAAC,UAAU,EAAE,aAAa,IAAI,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC7F,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC5E,CAAC;IAEO,gBAAgB;QACpB,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC7C,IAAI,CAAC,MAAM,CAAC,aAAa,GAAG,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC3D,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjD,CAAC;IAEO,gBAAgB;QACpB,OAAO,IAAI,CAAC,MAAM,EAAE,MAAM,IAAI,IAAI,CAAC,yBAAyB,CAAC,8BAA8B,EAAE,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAChI,CAAC;IAEO,gBAAgB;QACpB,OAAO,IAAI,CAAC,yBAAyB,CAAC,0BAA0B,EAAE,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACrG,CAAC;IAEO,uBAAuB;QAC3B,OAAO,IAAI,CAAC,yBAAyB,CAAC,qCAAqC,EAAE,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC;IACvH,CAAC;IAEO,yBAAyB,CAAC,GAAW,EAAE,YAAoB;QAC/D,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;IACjD,CAAC;+GArDQ,iBAAiB;mGAAjB,iBAAiB,8LCjC9B,koBAeA,2CDWc,YAAY,mLAAE,iBAAiB,oDAAE,WAAW;;4FAO7C,iBAAiB;kBAT7B,SAAS;iCACM,IAAI,WACP,CAAC,YAAY,EAAE,iBAAiB,EAAE,WAAW,CAAC,YAC7C,eAAe,iBAEV,iBAAiB,CAAC,IAAI,QAC/B,EAAE,KAAK,EAAE,4BAA4B,EAAE,mBAC5B,uBAAuB,CAAC,MAAM;8BAI/C,UAAU;sBADT,KAAK","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ChangeDetectionStrategy, Component, Input, OnInit, ViewEncapsulation, inject } from '@angular/core';\nimport { DataTableCellComponent } from '../datatable-cell/datatable-cell.component';\nimport { AppConfigService } from '../../../app-config/app-config.service';\nimport { DateConfig } from '../../data/data-column.model';\nimport { CommonModule } from '@angular/common';\nimport { LocalizedDatePipe, TimeAgoPipe } from '../../../pipes';\n\n@Component({\n    standalone: true,\n    imports: [CommonModule, LocalizedDatePipe, TimeAgoPipe],\n    selector: 'adf-date-cell',\n    templateUrl: './date-cell.component.html',\n    encapsulation: ViewEncapsulation.None,\n    host: { class: 'adf-datatable-content-cell' },\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class DateCellComponent extends DataTableCellComponent implements OnInit {\n    @Input()\n    dateConfig: DateConfig;\n\n    config: DateConfig = {};\n\n    private readonly appConfig: AppConfigService = inject(AppConfigService);\n\n    readonly defaultDateConfig: DateConfig = {\n        format: 'medium',\n        tooltipFormat: 'medium',\n        locale: undefined\n    };\n\n    ngOnInit(): void {\n        super.ngOnInit();\n        this.setConfig();\n    }\n\n    private setConfig(): void {\n        if (this.dateConfig) {\n            this.setCustomConfig();\n        } else {\n            this.setDefaultConfig();\n        }\n    }\n\n    private setCustomConfig(): void {\n        this.config.format = this.dateConfig?.format || this.getDefaultFormat();\n        this.config.tooltipFormat = this.dateConfig?.tooltipFormat || this.getDefaultTooltipFormat();\n        this.config.locale = this.dateConfig?.locale || this.getDefaultLocale();\n    }\n\n    private setDefaultConfig(): void {\n        this.config.format = this.getDefaultFormat();\n        this.config.tooltipFormat = this.getDefaultTooltipFormat();\n        this.config.locale = this.getDefaultLocale();\n    }\n\n    private getDefaultFormat(): string {\n        return this.column?.format || this.getAppConfigPropertyValue('dateValues.defaultDateFormat', this.defaultDateConfig.format);\n    }\n\n    private getDefaultLocale(): string {\n        return this.getAppConfigPropertyValue('dateValues.defaultLocale', this.defaultDateConfig.locale);\n    }\n\n    private getDefaultTooltipFormat(): string {\n        return this.getAppConfigPropertyValue('dateValues.defaultTooltipDateFormat', this.defaultDateConfig.tooltipFormat);\n    }\n\n    private getAppConfigPropertyValue(key: string, defaultValue: string): string {\n        return this.appConfig.get(key, defaultValue);\n    }\n}\n","<ng-container *ngIf=\"value$ | async as date\">\n    <span\n        [title]=\"tooltip | adfLocalizedDate: config.tooltipFormat: config.locale\"\n        class=\"adf-datatable-cell-value\"\n        *ngIf=\"config.format === 'timeAgo'; else standard_date\">\n            {{ date | adfTimeAgo: config.locale }}\n    </span>\n    <ng-template #standard_date>\n        <span\n            class=\"adf-datatable-cell-value\"\n            [title]=\"tooltip | adfLocalizedDate: config.tooltipFormat: config.locale\">\n                {{ date | adfLocalizedDate: config.format: config.locale }}\n        </span>\n    </ng-template>\n</ng-container>\n"]}

package/esm2022/lib/datatable/components/empty-list/empty-list.component.mjs

@@ -0,0 +1,60 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component, Directive, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+export class EmptyListComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EmptyListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: EmptyListComponent, isStandalone: true, selector: "adf-empty-list", ngImport: i0, template: "<div class=\"adf-empty-list_template\">\n    <ng-content select=\"[adf-empty-list-header]\" />\n    <ng-content select=\"[adf-empty-list-body]\" />\n    <ng-content select=\"[adf-empty-list-footer]\" />\n    <ng-content />\n</div>", styles: [".adf-empty-list_template{text-align:center;margin-top:20px;margin-bottom:20px}\n"], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EmptyListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-empty-list', standalone: true, encapsulation: ViewEncapsulation.None, template: "<div class=\"adf-empty-list_template\">\n    <ng-content select=\"[adf-empty-list-header]\" />\n    <ng-content select=\"[adf-empty-list-body]\" />\n    <ng-content select=\"[adf-empty-list-footer]\" />\n    <ng-content />\n</div>", styles: [".adf-empty-list_template{text-align:center;margin-top:20px;margin-bottom:20px}\n"] }]
+        }] });
+export class EmptyListHeaderDirective {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EmptyListHeaderDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: EmptyListHeaderDirective, isStandalone: true, selector: "[adf-empty-list-header]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EmptyListHeaderDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[adf-empty-list-header]',
+                    standalone: true
+                }]
+        }] });
+export class EmptyListBodyDirective {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EmptyListBodyDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: EmptyListBodyDirective, isStandalone: true, selector: "[adf-empty-list-body]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EmptyListBodyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[adf-empty-list-body]',
+                    standalone: true
+                }]
+        }] });
+export class EmptyListFooterDirective {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EmptyListFooterDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: EmptyListFooterDirective, isStandalone: true, selector: "[adf-empty-list-footer]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EmptyListFooterDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[adf-empty-list-footer]',
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1wdHktbGlzdC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL2RhdGF0YWJsZS9jb21wb25lbnRzL2VtcHR5LWxpc3QvZW1wdHktbGlzdC5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL2RhdGF0YWJsZS9jb21wb25lbnRzL2VtcHR5LWxpc3QvZW1wdHktbGlzdC5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxPQUFPLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFTeEUsTUFBTSxPQUFPLGtCQUFrQjsrR0FBbEIsa0JBQWtCO21HQUFsQixrQkFBa0IsMEVDMUIvQix3T0FLTTs7NEZEcUJPLGtCQUFrQjtrQkFQOUIsU0FBUzsrQkFDSSxnQkFBZ0IsY0FDZCxJQUFJLGlCQUdELGlCQUFpQixDQUFDLElBQUk7O0FBUXpDLE1BQU0sT0FBTyx3QkFBd0I7K0dBQXhCLHdCQUF3QjttR0FBeEIsd0JBQXdCOzs0RkFBeEIsd0JBQXdCO2tCQUpwQyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSx5QkFBeUI7b0JBQ25DLFVBQVUsRUFBRSxJQUFJO2lCQUNuQjs7QUFPRCxNQUFNLE9BQU8sc0JBQXNCOytHQUF0QixzQkFBc0I7bUdBQXRCLHNCQUFzQjs7NEZBQXRCLHNCQUFzQjtrQkFKbEMsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsdUJBQXVCO29CQUNqQyxVQUFVLEVBQUUsSUFBSTtpQkFDbkI7O0FBT0QsTUFBTSxPQUFPLHdCQUF3QjsrR0FBeEIsd0JBQXdCO21HQUF4Qix3QkFBd0I7OzRGQUF4Qix3QkFBd0I7a0JBSnBDLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLHlCQUF5QjtvQkFDbkMsVUFBVSxFQUFFLElBQUk7aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQgeyBDb21wb25lbnQsIERpcmVjdGl2ZSwgVmlld0VuY2Fwc3VsYXRpb24gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICdhZGYtZW1wdHktbGlzdCcsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgICBzdHlsZVVybHM6IFsnLi9lbXB0eS1saXN0LmNvbXBvbmVudC5zY3NzJ10sXG4gICAgdGVtcGxhdGVVcmw6ICcuL2VtcHR5LWxpc3QuY29tcG9uZW50Lmh0bWwnLFxuICAgIGVuY2Fwc3VsYXRpb246IFZpZXdFbmNhcHN1bGF0aW9uLk5vbmVcbn0pXG5leHBvcnQgY2xhc3MgRW1wdHlMaXN0Q29tcG9uZW50IHt9XG5cbkBEaXJlY3RpdmUoe1xuICAgIHNlbGVjdG9yOiAnW2FkZi1lbXB0eS1saXN0LWhlYWRlcl0nLFxuICAgIHN0YW5kYWxvbmU6IHRydWVcbn0pXG5leHBvcnQgY2xhc3MgRW1wdHlMaXN0SGVhZGVyRGlyZWN0aXZlIHt9XG5cbkBEaXJlY3RpdmUoe1xuICAgIHNlbGVjdG9yOiAnW2FkZi1lbXB0eS1saXN0LWJvZHldJyxcbiAgICBzdGFuZGFsb25lOiB0cnVlXG59KVxuZXhwb3J0IGNsYXNzIEVtcHR5TGlzdEJvZHlEaXJlY3RpdmUge31cblxuQERpcmVjdGl2ZSh7XG4gICAgc2VsZWN0b3I6ICdbYWRmLWVtcHR5LWxpc3QtZm9vdGVyXScsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZVxufSlcbmV4cG9ydCBjbGFzcyBFbXB0eUxpc3RGb290ZXJEaXJlY3RpdmUge31cbiIsIjxkaXYgY2xhc3M9XCJhZGYtZW1wdHktbGlzdF90ZW1wbGF0ZVwiPlxuICAgIDxuZy1jb250ZW50IHNlbGVjdD1cIlthZGYtZW1wdHktbGlzdC1oZWFkZXJdXCIgLz5cbiAgICA8bmctY29udGVudCBzZWxlY3Q9XCJbYWRmLWVtcHR5LWxpc3QtYm9keV1cIiAvPlxuICAgIDxuZy1jb250ZW50IHNlbGVjdD1cIlthZGYtZW1wdHktbGlzdC1mb290ZXJdXCIgLz5cbiAgICA8bmctY29udGVudCAvPlxuPC9kaXY+Il19

package/esm2022/lib/datatable/components/filesize-cell/filesize-cell.component.mjs

@@ -0,0 +1,49 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component, ViewEncapsulation } from '@angular/core';
+import { DataTableCellComponent } from '../datatable-cell/datatable-cell.component';
+import { CommonModule } from '@angular/common';
+import { FileSizePipe } from '../../../pipes';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class FileSizeCellComponent extends DataTableCellComponent {
+    ngOnInit() {
+        super.ngOnInit();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FileSizeCellComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: FileSizeCellComponent, isStandalone: true, selector: "adf-filesize-cell", host: { classAttribute: "adf-filesize-cell" }, usesInheritance: true, ngImport: i0, template: `
+        <ng-container *ngIf="value$ | async | adfFileSize as fileSize">
+            <span [title]="tooltip">{{ fileSize }}</span>
+        </ng-container>
+    `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: FileSizePipe, name: "adfFileSize" }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FileSizeCellComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'adf-filesize-cell',
+                    standalone: true,
+                    imports: [CommonModule, FileSizePipe],
+                    template: `
+        <ng-container *ngIf="value$ | async | adfFileSize as fileSize">
+            <span [title]="tooltip">{{ fileSize }}</span>
+        </ng-container>
+    `,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'adf-filesize-cell' }
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/datatable/components/icon-cell/icon-cell.component.mjs

@@ -0,0 +1,67 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ViewEncapsulation } from '@angular/core';
+import { MatIconModule } from '@angular/material/icon';
+import { DataTableCellComponent } from '../datatable-cell/datatable-cell.component';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/icon";
+export class IconCellComponent extends DataTableCellComponent {
+    constructor(changeDetectorRef) {
+        super();
+        this.changeDetectorRef = changeDetectorRef;
+        this.icon = '';
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.value$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((value) => {
+            const newIcon = this.validateIconValue(value) ? value : '';
+            if (this.icon !== newIcon) {
+                this.icon = newIcon;
+                this.changeDetectorRef.detectChanges();
+            }
+        });
+    }
+    validateIconValue(value) {
+        return typeof value === 'string';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IconCellComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: IconCellComponent, isStandalone: true, selector: "adf-icon-cell", host: { classAttribute: "adf-datatable-content-cell" }, usesInheritance: true, ngImport: i0, template: `
+        <ng-container *ngIf="icon">
+            <mat-icon [title]="tooltip" aria-hidden="true">{{ icon }}</mat-icon>
+        </ng-container>
+    `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i2.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IconCellComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    imports: [CommonModule, MatIconModule],
+                    selector: 'adf-icon-cell',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+        <ng-container *ngIf="icon">
+            <mat-icon [title]="tooltip" aria-hidden="true">{{ icon }}</mat-icon>
+        </ng-container>
+    `,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'adf-datatable-content-cell' }
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }] });
+//# sourceMappingURL=data:application/json;base64,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