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

package/esm2022/lib/datatable/data/data-table.schema.mjs

@@ -0,0 +1,132 @@
+/*!
+ * @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 { ContentChild, Input, Directive } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { AppConfigService } from '../../app-config/app-config.service';
+import { DataColumnListComponent } from '../data-column/data-column-list.component';
+import { ObjectDataColumn } from './object-datacolumn.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../app-config/app-config.service";
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class DataTableSchema {
+    constructor(appConfigService, presetKey, presetsModel) {
+        this.appConfigService = appConfigService;
+        this.presetKey = presetKey;
+        this.presetsModel = presetsModel;
+        this.columnsOrderedByKey = 'id';
+        this.layoutPresets = {};
+        this.columnsSchemaSubject$ = new BehaviorSubject(false);
+        this.isColumnSchemaCreated$ = this.columnsSchemaSubject$.asObservable();
+    }
+    createDatatableSchema() {
+        this.loadLayoutPresets();
+        if (!this.columns || this.columns.length === 0) {
+            this.createColumns();
+            this.columnsSchemaSubject$.next(true);
+        }
+        else {
+            this.columnsSchemaSubject$.next(true);
+        }
+    }
+    createColumns() {
+        const allColumns = this.mergeJsonAndHtmlSchema();
+        const allColumnsWithWidth = this.setColumnsWidth(allColumns);
+        const columns = this.setHiddenColumns(allColumnsWithWidth);
+        this.columns = this.sortColumnsByKey(columns);
+    }
+    loadLayoutPresets() {
+        const externalSettings = this.appConfigService.get(this.presetKey, null);
+        if (externalSettings) {
+            this.layoutPresets = Object.assign({}, this.presetsModel, externalSettings);
+        }
+        else {
+            this.layoutPresets = this.presetsModel;
+        }
+    }
+    mergeJsonAndHtmlSchema() {
+        const configSchemaColumns = this.getSchemaFromConfig(this.presetColumn);
+        const htmlSchemaColumns = this.getSchemaFromHtml(this.columnList);
+        let customSchemaColumns = [...configSchemaColumns, ...htmlSchemaColumns];
+        if (customSchemaColumns.length === 0) {
+            customSchemaColumns = this.getDefaultLayoutPreset();
+        }
+        else {
+            customSchemaColumns.sort((col1, col2) => (col1.order || 0) - (col2.order || 0));
+        }
+        return customSchemaColumns;
+    }
+    getSchemaFromHtml(columnList) {
+        let schema = [];
+        if (columnList?.columns?.length > 0) {
+            schema = columnList.columns.map((c) => c);
+        }
+        return schema;
+    }
+    getSchemaFromConfig(presetColumn) {
+        return presetColumn && this.layoutPresets[presetColumn] ? this.layoutPresets[presetColumn].map((col) => new ObjectDataColumn(col)) : [];
+    }
+    getDefaultLayoutPreset() {
+        return this.layoutPresets['default'].map((col) => new ObjectDataColumn(col));
+    }
+    setPresetKey(presetKey) {
+        this.presetKey = presetKey;
+    }
+    setPresetsModel(presetsModel) {
+        this.presetsModel = presetsModel;
+    }
+    sortColumnsByKey(columns) {
+        const defaultColumns = [...columns];
+        const columnsWithProperOrder = [];
+        (this.columnsOrder ?? []).forEach((columnKey) => {
+            const originalColumnIndex = defaultColumns.findIndex((defaultColumn) => defaultColumn[this.columnsOrderedByKey] === columnKey);
+            if (originalColumnIndex > -1) {
+                columnsWithProperOrder.push(defaultColumns[originalColumnIndex]);
+                defaultColumns.splice(originalColumnIndex, 1);
+            }
+        });
+        return [...columnsWithProperOrder, ...defaultColumns];
+    }
+    setHiddenColumns(columns) {
+        if (this.columnsVisibility) {
+            return columns.map((column) => {
+                const isColumnVisible = this.columnsVisibility[column.id];
+                return isColumnVisible === undefined ? column : { ...column, isHidden: !isColumnVisible };
+            });
+        }
+        return columns;
+    }
+    setColumnsWidth(columns) {
+        if (this.columnsWidths) {
+            return columns.map((column) => {
+                const columnWidth = this.columnsWidths[column.id];
+                return columnWidth === undefined ? column : { ...column, width: columnWidth };
+            });
+        }
+        return columns;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DataTableSchema, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: DataTableSchema, inputs: { presetColumn: "presetColumn" }, queries: [{ propertyName: "columnList", first: true, predicate: DataColumnListComponent, descendants: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DataTableSchema, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i1.AppConfigService }, { type: undefined }, { type: undefined }], propDecorators: { columnList: [{
+                type: ContentChild,
+                args: [DataColumnListComponent]
+            }], presetColumn: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-table.schema.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/datatable/data/data-table.schema.ts"],"names":[],"mappings":"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","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 { ContentChild, Input, Directive } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport { AppConfigService } from '../../app-config/app-config.service';\nimport { DataColumnListComponent } from '../data-column/data-column-list.component';\nimport { DataColumn } from './data-column.model';\nimport { ObjectDataColumn } from './object-datacolumn.model';\n\n@Directive()\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\nexport abstract class DataTableSchema<T = unknown> {\n    @ContentChild(DataColumnListComponent)\n    columnList: DataColumnListComponent;\n\n    /** Custom preset column schema in JSON format. */\n    @Input()\n    presetColumn: string;\n\n    columns: DataColumn<T>[];\n\n    protected columnsOrder: string[] | undefined;\n    protected columnsOrderedByKey: string = 'id';\n\n    protected columnsVisibility: { [columnId: string]: boolean } | undefined;\n    protected columnsWidths: { [columnId: string]: number } | undefined;\n\n    private layoutPresets = {};\n\n    protected columnsSchemaSubject$ = new BehaviorSubject<boolean>(false);\n    isColumnSchemaCreated$ = this.columnsSchemaSubject$.asObservable();\n\n    constructor(private appConfigService: AppConfigService, protected presetKey: string, protected presetsModel: any) {}\n\n    public createDatatableSchema(): void {\n        this.loadLayoutPresets();\n\n        if (!this.columns || this.columns.length === 0) {\n            this.createColumns();\n            this.columnsSchemaSubject$.next(true);\n        } else {\n            this.columnsSchemaSubject$.next(true);\n        }\n    }\n\n    public createColumns(): void {\n        const allColumns = this.mergeJsonAndHtmlSchema();\n        const allColumnsWithWidth = this.setColumnsWidth(allColumns);\n        const columns = this.setHiddenColumns(allColumnsWithWidth);\n        this.columns = this.sortColumnsByKey(columns);\n    }\n\n    public loadLayoutPresets(): void {\n        const externalSettings = this.appConfigService.get(this.presetKey, null);\n        if (externalSettings) {\n            this.layoutPresets = Object.assign({}, this.presetsModel, externalSettings);\n        } else {\n            this.layoutPresets = this.presetsModel;\n        }\n    }\n\n    public mergeJsonAndHtmlSchema(): any {\n        const configSchemaColumns = this.getSchemaFromConfig(this.presetColumn);\n        const htmlSchemaColumns = this.getSchemaFromHtml(this.columnList);\n\n        let customSchemaColumns = [...configSchemaColumns, ...htmlSchemaColumns];\n\n        if (customSchemaColumns.length === 0) {\n            customSchemaColumns = this.getDefaultLayoutPreset();\n        } else {\n            customSchemaColumns.sort((col1, col2) => (col1.order || 0) - (col2.order || 0));\n        }\n\n        return customSchemaColumns;\n    }\n\n    public getSchemaFromHtml(columnList: DataColumnListComponent): DataColumn[] {\n        let schema = [];\n        if (columnList?.columns?.length > 0) {\n            schema = columnList.columns.map((c) => c as DataColumn);\n        }\n        return schema;\n    }\n\n    public getSchemaFromConfig(presetColumn: string): DataColumn[] {\n        return presetColumn && this.layoutPresets[presetColumn] ? this.layoutPresets[presetColumn].map((col) => new ObjectDataColumn(col)) : [];\n    }\n\n    private getDefaultLayoutPreset(): DataColumn[] {\n        return this.layoutPresets['default'].map((col) => new ObjectDataColumn(col));\n    }\n\n    public setPresetKey(presetKey: string) {\n        this.presetKey = presetKey;\n    }\n\n    public setPresetsModel(presetsModel: any) {\n        this.presetsModel = presetsModel;\n    }\n\n    private sortColumnsByKey(columns: any[]): any[] {\n        const defaultColumns = [...columns];\n        const columnsWithProperOrder = [];\n\n        (this.columnsOrder ?? []).forEach((columnKey) => {\n            const originalColumnIndex = defaultColumns.findIndex((defaultColumn) => defaultColumn[this.columnsOrderedByKey] === columnKey);\n\n            if (originalColumnIndex > -1) {\n                columnsWithProperOrder.push(defaultColumns[originalColumnIndex]);\n                defaultColumns.splice(originalColumnIndex, 1);\n            }\n        });\n\n        return [...columnsWithProperOrder, ...defaultColumns];\n    }\n\n    private setHiddenColumns(columns: DataColumn[]): DataColumn[] {\n        if (this.columnsVisibility) {\n            return columns.map((column) => {\n                const isColumnVisible = this.columnsVisibility[column.id];\n\n                return isColumnVisible === undefined ? column : { ...column, isHidden: !isColumnVisible };\n            });\n        }\n\n        return columns;\n    }\n\n    private setColumnsWidth(columns: DataColumn[]): DataColumn[] {\n        if (this.columnsWidths) {\n            return columns.map((column) => {\n                const columnWidth = this.columnsWidths[column.id];\n                return columnWidth === undefined ? column : { ...column, width: columnWidth };\n            });\n        }\n        return columns;\n    }\n}\n"]}

package/esm2022/lib/datatable/data/datatable-adapter.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/datatable/data/object-datacolumn.model.mjs

@@ -0,0 +1,46 @@
+/*!
+ * @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.
+ */
+// Simple implementation of the DataColumn interface.
+export class ObjectDataColumn {
+    constructor(input) {
+        this.id = input.id ?? '';
+        this.key = input.key;
+        this.type = input.type || 'text';
+        this.format = input.format;
+        this.sortable = input.sortable;
+        this.title = input.title;
+        this.subtitle = input.subtitle;
+        this.srTitle = input.srTitle;
+        this.cssClass = input.cssClass;
+        this.template = input.template;
+        this.copyContent = input.copyContent;
+        this.focus = input.focus;
+        this.sortingKey = input.sortingKey;
+        this.header = input.header;
+        this.draggable = input.draggable ?? false;
+        this.resizable = input.resizable ?? true;
+        this.isHidden = input.isHidden ?? false;
+        this.customData = input.customData;
+        this.width = input.width;
+        this.order = input.order;
+        this.currencyConfig = input.currencyConfig;
+        this.decimalConfig = input.decimalConfig;
+        this.dateConfig = input.dateConfig;
+        this.maxTextLength = input.maxTextLength;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/datatable/data/object-datarow.model.mjs

@@ -0,0 +1,41 @@
+/*!
+ * @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 { ObjectUtils } from '../../common/utils';
+// Simple implementation of the DataRow interface.
+export class ObjectDataRow {
+    constructor(obj, isSelected = false, isSelectable = true) {
+        this.obj = obj;
+        this.isSelected = isSelected;
+        this.isSelectable = isSelectable;
+        if (!obj) {
+            throw new Error('Object source not found');
+        }
+    }
+    getSourceObject() {
+        return this.obj;
+    }
+    getValue(key) {
+        return ObjectUtils.getValue(this.obj, key);
+    }
+    hasValue(key) {
+        return this.getValue(key) !== undefined;
+    }
+    imageErrorResolver() {
+        return '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/datatable/data/object-datatable-adapter.mjs

@@ -0,0 +1,134 @@
+/*!
+ * @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 { ObjectDataRow } from './object-datarow.model';
+import { ObjectDataColumn } from './object-datacolumn.model';
+import { DataSorting } from './data-sorting.model';
+import { Subject } from 'rxjs';
+// Simple implementation of the DataTableAdapter interface.
+export class ObjectDataTableAdapter {
+    static generateSchema(data) {
+        const schema = [];
+        if (data?.length) {
+            const rowToExamine = data[0];
+            if (typeof rowToExamine === 'object') {
+                for (const key in rowToExamine) {
+                    if (Object.prototype.hasOwnProperty.call(rowToExamine, key)) {
+                        schema.push({
+                            type: 'text',
+                            key,
+                            title: key,
+                            sortable: false
+                        });
+                    }
+                }
+            }
+        }
+        return schema;
+    }
+    get sortingMode() {
+        return this._sortingMode;
+    }
+    set sortingMode(sortingMode) {
+        if (!sortingMode) {
+            sortingMode = 'client';
+        }
+        this._sortingMode = sortingMode;
+    }
+    constructor(data = [], schema = [], sortingMode = 'client') {
+        this._rows = [];
+        this._columns = [];
+        this.sortingMode = sortingMode;
+        if (data && data.length > 0) {
+            this._rows = data.map((item) => new ObjectDataRow(item));
+        }
+        if (schema && schema.length > 0) {
+            this._columns = schema.map((item) => new ObjectDataColumn(item));
+            // Sort by first sortable or just first column
+            const sortable = this._columns.filter((column) => column.sortable);
+            if (sortable.length > 0) {
+                this.sort(sortable[0].key, 'asc');
+            }
+        }
+        this.rowsChanged = new Subject();
+    }
+    getColumnType(_row, col) {
+        return col.type;
+    }
+    getRows() {
+        return this._rows;
+    }
+    setRows(rows) {
+        this._rows = rows || [];
+        this.sort();
+        this.rowsChanged.next(this._rows);
+    }
+    getColumns() {
+        return this._columns;
+    }
+    setColumns(columns) {
+        this._columns = columns || [];
+    }
+    getValue(row, col, resolver) {
+        if (!row) {
+            throw new Error('Row not found');
+        }
+        if (!col) {
+            throw new Error('Column not found');
+        }
+        if (resolver) {
+            return resolver(row, col);
+        }
+        return row.getValue(col.key);
+    }
+    getSorting() {
+        return this._sorting;
+    }
+    setSorting(sorting) {
+        this._sorting = sorting;
+        if (this._sortingMode === 'server') {
+            return;
+        }
+        if (sorting?.key) {
+            this._rows.sort((a, b) => {
+                let left = a.getValue(sorting.key) ?? '';
+                let right = b.getValue(sorting.key) ?? '';
+                if (typeof left !== 'string') {
+                    left = left.valueOf().toString();
+                }
+                if (typeof right !== 'string') {
+                    right = right.valueOf().toString();
+                }
+                return sorting.direction === 'asc'
+                    ? left.localeCompare(right, undefined, sorting.options)
+                    : right.localeCompare(left, undefined, sorting.options);
+            });
+        }
+    }
+    sort(key, direction, options) {
+        const sorting = this._sorting || new DataSorting();
+        if (key) {
+            sorting.key = key;
+            sorting.direction = direction || 'asc';
+            sorting.options = {
+                numeric: true,
+                ...options
+            };
+        }
+        this.setSorting(sorting);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-datatable-adapter.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/datatable/data/object-datatable-adapter.ts"],"names":[],"mappings":"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","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 { DataColumn } from './data-column.model';\nimport { DataRow } from './data-row.model';\nimport { ObjectDataRow } from './object-datarow.model';\nimport { ObjectDataColumn } from './object-datacolumn.model';\nimport { DataSorting } from './data-sorting.model';\nimport { DataTableAdapter } from './datatable-adapter';\nimport { Subject } from 'rxjs';\n\nexport type SortingMode = 'client' | 'server';\n\n// Simple implementation of the DataTableAdapter interface.\nexport class ObjectDataTableAdapter implements DataTableAdapter {\n    private _sorting: DataSorting;\n    private _rows: DataRow[];\n    private _columns: DataColumn[];\n    private _sortingMode: SortingMode;\n\n    selectedRow: DataRow;\n    rowsChanged: Subject<Array<DataRow>>;\n\n    static generateSchema(data: any[]) {\n        const schema = [];\n\n        if (data?.length) {\n            const rowToExamine = data[0];\n\n            if (typeof rowToExamine === 'object') {\n                for (const key in rowToExamine) {\n                    if (Object.prototype.hasOwnProperty.call(rowToExamine, key)) {\n                        schema.push({\n                            type: 'text',\n                            key,\n                            title: key,\n                            sortable: false\n                        });\n                    }\n                }\n            }\n        }\n        return schema;\n    }\n\n    get sortingMode(): SortingMode {\n        return this._sortingMode;\n    }\n    set sortingMode(sortingMode: SortingMode) {\n        if (!sortingMode) {\n            sortingMode = 'client';\n        }\n\n        this._sortingMode = sortingMode;\n    }\n\n    constructor(data: any[] = [], schema: DataColumn[] = [], sortingMode: SortingMode = 'client') {\n        this._rows = [];\n        this._columns = [];\n        this.sortingMode = sortingMode;\n\n        if (data && data.length > 0) {\n            this._rows = data.map((item) => new ObjectDataRow(item));\n        }\n\n        if (schema && schema.length > 0) {\n            this._columns = schema.map((item) => new ObjectDataColumn(item));\n\n            // Sort by first sortable or just first column\n            const sortable = this._columns.filter((column) => column.sortable);\n            if (sortable.length > 0) {\n                this.sort(sortable[0].key, 'asc');\n            }\n        }\n\n        this.rowsChanged = new Subject<Array<DataRow>>();\n    }\n\n    getColumnType(_row: DataRow, col: DataColumn): string {\n        return col.type;\n    }\n\n    getRows(): Array<DataRow> {\n        return this._rows;\n    }\n\n    setRows(rows: Array<DataRow>) {\n        this._rows = rows || [];\n        this.sort();\n        this.rowsChanged.next(this._rows);\n    }\n\n    getColumns(): Array<DataColumn> {\n        return this._columns;\n    }\n\n    setColumns(columns: Array<DataColumn>) {\n        this._columns = columns || [];\n    }\n\n    getValue(row: DataRow, col: DataColumn, resolver?: (_row: DataRow, _col: DataColumn) => any): any {\n        if (!row) {\n            throw new Error('Row not found');\n        }\n        if (!col) {\n            throw new Error('Column not found');\n        }\n\n        if (resolver) {\n            return resolver(row, col);\n        }\n\n        return row.getValue(col.key);\n    }\n\n    getSorting(): DataSorting {\n        return this._sorting;\n    }\n\n    setSorting(sorting: DataSorting): void {\n        this._sorting = sorting;\n\n        if (this._sortingMode === 'server') {\n            return;\n        }\n\n        if (sorting?.key) {\n            this._rows.sort((a: DataRow, b: DataRow) => {\n                let left = a.getValue(sorting.key) ?? '';\n                let right = b.getValue(sorting.key) ?? '';\n\n                if (typeof left !== 'string') {\n                    left = left.valueOf().toString();\n                }\n\n                if (typeof right !== 'string') {\n                    right = right.valueOf().toString();\n                }\n\n                return sorting.direction === 'asc'\n                    ? left.localeCompare(right, undefined, sorting.options)\n                    : right.localeCompare(left, undefined, sorting.options);\n            });\n        }\n    }\n\n    sort(key?: string, direction?: string, options?: Intl.CollatorOptions): void {\n        const sorting = this._sorting || new DataSorting();\n        if (key) {\n            sorting.key = key;\n            sorting.direction = direction || 'asc';\n            sorting.options = {\n                numeric: true,\n                ...options\n            };\n        }\n        this.setSorting(sorting);\n    }\n}\n"]}

package/esm2022/lib/datatable/data-column/data-column-header.component.mjs

@@ -0,0 +1,45 @@
+/*!
+ * @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.
+ */
+/* eslint-disable @angular-eslint/component-selector, @angular-eslint/no-input-rename */
+import { Component, ContentChild, TemplateRef } from '@angular/core';
+import { DataColumnComponent } from './data-column.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./data-column.component";
+export class DateColumnHeaderComponent {
+    constructor(columnComponent) {
+        this.columnComponent = columnComponent;
+    }
+    ngAfterContentInit() {
+        if (this.columnComponent) {
+            this.columnComponent.header = this.header;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DateColumnHeaderComponent, deps: [{ token: i1.DataColumnComponent }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: DateColumnHeaderComponent, isStandalone: true, selector: "adf-data-column-header", queries: [{ propertyName: "header", first: true, predicate: TemplateRef, descendants: true }], ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DateColumnHeaderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'adf-data-column-header',
+                    standalone: true,
+                    template: ''
+                }]
+        }], ctorParameters: () => [{ type: i1.DataColumnComponent }], propDecorators: { header: [{
+                type: ContentChild,
+                args: [TemplateRef]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/datatable/data-column/data-column-list.component.mjs

@@ -0,0 +1,36 @@
+/*!
+ * @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.
+ */
+/* eslint-disable @angular-eslint/component-selector */
+import { Component, ContentChildren, QueryList } from '@angular/core';
+import { DataColumnComponent } from './data-column.component';
+import * as i0 from "@angular/core";
+export class DataColumnListComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DataColumnListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: DataColumnListComponent, isStandalone: true, selector: "data-columns", queries: [{ propertyName: "columns", predicate: DataColumnComponent }], ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DataColumnListComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'data-columns',
+                    standalone: true,
+                    template: ''
+                }]
+        }], propDecorators: { columns: [{
+                type: ContentChildren,
+                args: [DataColumnComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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