@onecx/angular-accelerator 4.43.1 → 5.0.0

package/esm2022/lib/components/data-list-grid-sorting/data-list-grid-sorting.component.mjs

@@ -0,0 +1,92 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/api";
+import * as i2 from "primeng/dropdown";
+import * as i3 from "primeng/button";
+import * as i4 from "@angular/forms";
+import * as i5 from "@ngx-translate/core";
+export class DataListGridSortingComponent {
+    constructor() {
+        this.columns = [];
+        this.sortStates = ["ASCENDING" /* DataSortDirection.ASCENDING */, "DESCENDING" /* DataSortDirection.DESCENDING */];
+        this._sortDirection$ = new BehaviorSubject("NONE" /* DataSortDirection.NONE */);
+        this._sortField$ = new BehaviorSubject('');
+        this.sortChange = new EventEmitter();
+        this.sortDirectionChange = new EventEmitter();
+        this.columnsChange = new EventEmitter();
+        this.dropdownOptions = [];
+    }
+    get sortDirection() {
+        return this._sortDirection$.getValue();
+    }
+    set sortDirection(value) {
+        this._sortDirection$.next(value);
+    }
+    get sortField() {
+        return this?._sortField$.getValue();
+    }
+    set sortField(value) {
+        this._sortField$.next(value);
+    }
+    ngOnInit() {
+        this.columns.forEach((element) => this.dropdownOptions.push({ columnId: element.id, columnName: element.nameKey }));
+        this.selectedSortingOption = this.dropdownOptions.find((e) => e.columnId === this?.sortField);
+    }
+    selectSorting(event) {
+        this._sortField$.next(event.value);
+        this.sortChange.emit(event.value.columnId);
+    }
+    sortDirectionChanged() {
+        const newSortDirection = this.nextSortDirection();
+        this._sortDirection$.next(newSortDirection);
+        this.sortDirectionChange.emit(newSortDirection);
+    }
+    nextSortDirection() {
+        return this.sortStates[(this.sortStates.indexOf(this.sortDirection) + 1) % this.sortStates.length];
+    }
+    sortIcon() {
+        switch (this.sortDirection) {
+            case "ASCENDING" /* DataSortDirection.ASCENDING */:
+                return 'pi-sort-amount-up';
+            case "DESCENDING" /* DataSortDirection.DESCENDING */:
+                return 'pi-sort-amount-down';
+            default:
+                return 'pi-sort-alt';
+        }
+    }
+    sortIconTitle() {
+        return this.sortDirectionToTitle(this.sortDirection);
+    }
+    sortDirectionToTitle(sortDirection) {
+        switch (sortDirection) {
+            case "ASCENDING" /* DataSortDirection.ASCENDING */:
+                return 'OCX_LIST_GRID_SORT.TOGGLE_BUTTON.ASCENDING_TITLE';
+            case "DESCENDING" /* DataSortDirection.DESCENDING */:
+                return 'OCX_LIST_GRID_SORT.TOGGLE_BUTTON.DESCENDING_TITLE';
+            default:
+                return 'OCX_LIST_GRID_SORT.TOGGLE_BUTTON.DEFAULT_TITLE';
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: DataListGridSortingComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.5", type: DataListGridSortingComponent, selector: "ocx-data-list-grid-sorting", inputs: { columns: "columns", sortStates: "sortStates", sortDirection: "sortDirection", sortField: "sortField" }, outputs: { sortChange: "sortChange", sortDirectionChange: "sortDirectionChange", columnsChange: "columnsChange" }, ngImport: i0, template: "<div class=\"flex align-items-center gap-2\">\n  <p-dropdown\n    id=\"dataListGridSortingDropdown\"\n    [(ngModel)]=\"selectedSortingOption\"\n    class=\"sort-dropdown\"\n    [options]=\"dropdownOptions\"\n    [placeholder]=\"('OCX_LIST_GRID_SORT.DROPDOWN.PLACEHOLDER' | translate)\"\n    (onChange)=\"selectSorting($event)\"\n    [title]=\"('OCX_LIST_GRID_SORT.DROPDOWN.TITLE' | translate)\"\n  >\n    <ng-template let-item pTemplate=\"item\"> {{ item?.columnName ? (item.columnName | translate) : ''}} </ng-template>\n    <ng-template let-item pTemplate=\"selectedItem\">\n      {{ item?.columnName ? (item.columnName | translate) : ''}}\n    </ng-template></p-dropdown\n  >\n  <p-button\n    id=\"dataListGridSortingButton\"\n    icon=\"pi {{sortIcon()}}\"\n    styleClass=\"p-button-outlined\"\n    (onClick)=\"sortDirectionChanged()\"\n    [title]=\"(sortIconTitle() | translate)\"\n    [attr.aria-label]=\"('OCX_LIST_GRID_SORT.SORTING_BUTTON_ARIA_LABEL' | translate:{direction: (sortDirectionToTitle(nextSortDirection())) | translate})\"\n  ></p-button>\n</div>\n", styles: [".pi{border-radius:var(--border-radius);border-width:thin;background:none;cursor:pointer}\n"], dependencies: [{ kind: "directive", type: i1.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "component", type: i2.Dropdown, selector: "p-dropdown", inputs: ["id", "scrollHeight", "filter", "name", "style", "panelStyle", "styleClass", "panelStyleClass", "readonly", "required", "editable", "appendTo", "tabindex", "placeholder", "loadingIcon", "filterPlaceholder", "filterLocale", "variant", "inputId", "dataKey", "filterBy", "filterFields", "autofocus", "resetFilterOnHide", "checkmark", "dropdownIcon", "loading", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "autoDisplayFirst", "group", "showClear", "emptyFilterMessage", "emptyMessage", "lazy", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "overlayOptions", "ariaFilterLabel", "ariaLabel", "ariaLabelledBy", "filterMatchMode", "maxlength", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "focusOnHover", "selectOnFocus", "autoOptionFocus", "autofocusFilter", "disabled", "itemSize", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "filterValue", "options"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onShow", "onHide", "onClear", "onLazyLoad"] }, { kind: "component", type: i3.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "raised", "rounded", "text", "plain", "severity", "outlined", "link", "tabindex", "size", "style", "styleClass", "badgeClass", "ariaLabel", "autofocus"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "directive", type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.5", ngImport: i0, type: DataListGridSortingComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ocx-data-list-grid-sorting', template: "<div class=\"flex align-items-center gap-2\">\n  <p-dropdown\n    id=\"dataListGridSortingDropdown\"\n    [(ngModel)]=\"selectedSortingOption\"\n    class=\"sort-dropdown\"\n    [options]=\"dropdownOptions\"\n    [placeholder]=\"('OCX_LIST_GRID_SORT.DROPDOWN.PLACEHOLDER' | translate)\"\n    (onChange)=\"selectSorting($event)\"\n    [title]=\"('OCX_LIST_GRID_SORT.DROPDOWN.TITLE' | translate)\"\n  >\n    <ng-template let-item pTemplate=\"item\"> {{ item?.columnName ? (item.columnName | translate) : ''}} </ng-template>\n    <ng-template let-item pTemplate=\"selectedItem\">\n      {{ item?.columnName ? (item.columnName | translate) : ''}}\n    </ng-template></p-dropdown\n  >\n  <p-button\n    id=\"dataListGridSortingButton\"\n    icon=\"pi {{sortIcon()}}\"\n    styleClass=\"p-button-outlined\"\n    (onClick)=\"sortDirectionChanged()\"\n    [title]=\"(sortIconTitle() | translate)\"\n    [attr.aria-label]=\"('OCX_LIST_GRID_SORT.SORTING_BUTTON_ARIA_LABEL' | translate:{direction: (sortDirectionToTitle(nextSortDirection())) | translate})\"\n  ></p-button>\n</div>\n", styles: [".pi{border-radius:var(--border-radius);border-width:thin;background:none;cursor:pointer}\n"] }]
+        }], propDecorators: { columns: [{
+                type: Input
+            }], sortStates: [{
+                type: Input
+            }], sortDirection: [{
+                type: Input
+            }], sortField: [{
+                type: Input
+            }], sortChange: [{
+                type: Output
+            }], sortDirectionChange: [{
+                type: Output
+            }], columnsChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-list-grid-sorting.component.js","sourceRoot":"","sources":["../../../../../../../libs/angular-accelerator/src/lib/components/data-list-grid-sorting/data-list-grid-sorting.component.ts","../../../../../../../libs/angular-accelerator/src/lib/components/data-list-grid-sorting/data-list-grid-sorting.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core'\nimport { BehaviorSubject } from 'rxjs'\nimport { DataSortDirection } from '../../model/data-sort-direction'\nimport { DataColumnNameId } from '../../model/data-column-name-id.model'\nimport { DataTableColumn } from '../../model/data-table-column.model'\n\n@Component({\n  selector: 'ocx-data-list-grid-sorting',\n  templateUrl: './data-list-grid-sorting.component.html',\n  styleUrls: ['./data-list-grid-sorting.component.scss'],\n})\nexport class DataListGridSortingComponent implements OnInit {\n  @Input() columns: DataTableColumn[] = []\n  @Input() sortStates: DataSortDirection[] = [DataSortDirection.ASCENDING, DataSortDirection.DESCENDING]\n  _sortDirection$ = new BehaviorSubject<DataSortDirection>(DataSortDirection.NONE)\n  @Input()\n  get sortDirection(): DataSortDirection {\n    return this._sortDirection$.getValue()\n  }\n  set sortDirection(value: DataSortDirection) {\n    this._sortDirection$.next(value)\n  }\n  _sortField$ = new BehaviorSubject<string>('')\n  @Input()\n  get sortField(): string {\n    return this?._sortField$.getValue()\n  }\n  set sortField(value: string) {\n    this._sortField$.next(value)\n  }\n\n  @Output() sortChange: EventEmitter<string> = new EventEmitter()\n  @Output() sortDirectionChange: EventEmitter<DataSortDirection> = new EventEmitter()\n  @Output() columnsChange: EventEmitter<string[]> = new EventEmitter()\n  selectedSortingOption: DataColumnNameId | undefined\n  dropdownOptions: DataColumnNameId[] = []\n\n  ngOnInit(): void {\n    this.columns.forEach((element) => this.dropdownOptions.push({ columnId: element.id, columnName: element.nameKey }))\n    this.selectedSortingOption = this.dropdownOptions.find((e) => e.columnId === this?.sortField)\n  }\n\n  selectSorting(event: any): void {\n    this._sortField$.next(event.value)\n    this.sortChange.emit(event.value.columnId)\n  }\n  sortDirectionChanged(): void {\n    const newSortDirection = this.nextSortDirection()\n    this._sortDirection$.next(newSortDirection)\n    this.sortDirectionChange.emit(newSortDirection)\n  }\n\n  nextSortDirection() {\n    return this.sortStates[(this.sortStates.indexOf(this.sortDirection) + 1) % this.sortStates.length]\n  }\n\n  sortIcon() {\n    switch (this.sortDirection) {\n      case DataSortDirection.ASCENDING:\n        return 'pi-sort-amount-up'\n      case DataSortDirection.DESCENDING:\n        return 'pi-sort-amount-down'\n      default:\n        return 'pi-sort-alt'\n    }\n  }\n\n  sortIconTitle() {\n    return this.sortDirectionToTitle(this.sortDirection)\n  }\n\n  sortDirectionToTitle(sortDirection: DataSortDirection) {\n    switch (sortDirection) {\n      case DataSortDirection.ASCENDING:\n        return 'OCX_LIST_GRID_SORT.TOGGLE_BUTTON.ASCENDING_TITLE'\n      case DataSortDirection.DESCENDING:\n        return 'OCX_LIST_GRID_SORT.TOGGLE_BUTTON.DESCENDING_TITLE'\n      default:\n        return 'OCX_LIST_GRID_SORT.TOGGLE_BUTTON.DEFAULT_TITLE'\n    }\n  }\n}\n","<div class=\"flex align-items-center gap-2\">\n  <p-dropdown\n    id=\"dataListGridSortingDropdown\"\n    [(ngModel)]=\"selectedSortingOption\"\n    class=\"sort-dropdown\"\n    [options]=\"dropdownOptions\"\n    [placeholder]=\"('OCX_LIST_GRID_SORT.DROPDOWN.PLACEHOLDER' | translate)\"\n    (onChange)=\"selectSorting($event)\"\n    [title]=\"('OCX_LIST_GRID_SORT.DROPDOWN.TITLE' | translate)\"\n  >\n    <ng-template let-item pTemplate=\"item\"> {{ item?.columnName ? (item.columnName | translate) : ''}} </ng-template>\n    <ng-template let-item pTemplate=\"selectedItem\">\n      {{ item?.columnName ? (item.columnName | translate) : ''}}\n    </ng-template></p-dropdown\n  >\n  <p-button\n    id=\"dataListGridSortingButton\"\n    icon=\"pi {{sortIcon()}}\"\n    styleClass=\"p-button-outlined\"\n    (onClick)=\"sortDirectionChanged()\"\n    [title]=\"(sortIconTitle() | translate)\"\n    [attr.aria-label]=\"('OCX_LIST_GRID_SORT.SORTING_BUTTON_ARIA_LABEL' | translate:{direction: (sortDirectionToTitle(nextSortDirection())) | translate})\"\n  ></p-button>\n</div>\n"]}

package/esm2022/lib/components/data-sort-base/data-sort-base.mjs

@@ -0,0 +1,110 @@
+import { map, of } from 'rxjs';
+import { flattenObject } from '../../functions/flatten-object';
+import { ColumnType } from '../../model/column-type.model';
+import { ObjectUtils } from '../../utils/objectutils';
+export class DataSortBase {
+    constructor(locale, translateService) {
+        this.locale = locale;
+        this.translateService = translateService;
+    }
+    translateItems([items, filters, sortColumn, sortDirection], columns, clientSideFiltering, clientSideSorting) {
+        if (clientSideFiltering || clientSideSorting) {
+            let translationKeys = [];
+            const translatedColumns = columns.filter((c) => c.columnType === ColumnType.TRANSLATION_KEY);
+            translatedColumns.forEach((c) => {
+                translationKeys = [...translationKeys, ...items.map((i) => ObjectUtils.resolveFieldData(i, c.id)?.toString())];
+            });
+            if (translationKeys.length) {
+                return this.translateService.get(translationKeys).pipe(map((translatedValues) => {
+                    const translations = {};
+                    translatedColumns.forEach((c) => {
+                        translations[c.id] = Object.fromEntries(items.map((i) => [
+                            ObjectUtils.resolveFieldData(i, c.id)?.toString() || '',
+                            translatedValues[ObjectUtils.resolveFieldData(i, c.id)?.toString()],
+                        ]));
+                    });
+                    return [items, filters, sortColumn, sortDirection, translations];
+                }));
+            }
+        }
+        return of([items, filters, sortColumn, sortDirection, {}]);
+    }
+    filterItems([items, filters, sortColumn, sortDirection, translations], clientSideFiltering) {
+        if (!clientSideFiltering) {
+            return [items, filters, sortColumn, sortDirection, translations];
+        }
+        return [
+            items.filter((item) => filters
+                .map((filter) => filter.columnId)
+                .filter((value, index, self) => self.indexOf(value) === index && value != null)
+                .every((filterColumnId) => filters
+                .filter((filter) => filter.columnId === filterColumnId)
+                .some((filter) => (translations[filter.columnId]?.[ObjectUtils.resolveFieldData(item, filter.columnId).toString()] ||
+                ObjectUtils.resolveFieldData(item, filter.columnId)).toString() === filter.value.toString()))),
+            filters,
+            sortColumn,
+            sortDirection,
+            translations,
+        ];
+    }
+    sortItems([items, filters, sortColumn, sortDirection, translations], columns, clientSideSorting) {
+        if (!clientSideSorting || sortColumn === '') {
+            return [items, filters, sortColumn, sortDirection, translations];
+        }
+        let translatedColValues = Object.fromEntries(items.map((i) => [
+            ObjectUtils.resolveFieldData(i, sortColumn)?.toString(),
+            ObjectUtils.resolveFieldData(i, sortColumn)?.toString(),
+        ]));
+        if (columns.find((h) => h.id === sortColumn)?.columnType === ColumnType.TRANSLATION_KEY) {
+            translatedColValues = translations[sortColumn];
+        }
+        return [
+            [...items].sort(this.createCompareFunction(translatedColValues, sortColumn, sortDirection)),
+            filters,
+            sortColumn,
+            sortDirection,
+            translations,
+        ];
+    }
+    flattenItems(items) {
+        return items.map((i) => flattenObject(i));
+    }
+    createCompareFunction(translatedColValues, sortColumn, sortDirection) {
+        let direction = 0;
+        if (sortDirection === "ASCENDING" /* DataSortDirection.ASCENDING */) {
+            direction = 1;
+        }
+        else if (sortDirection === "DESCENDING" /* DataSortDirection.DESCENDING */) {
+            direction = -1;
+        }
+        return (data1, data2) => {
+            if (direction === 0) {
+                return 0;
+            }
+            let result;
+            const value1 = translatedColValues[ObjectUtils.resolveFieldData(data1, sortColumn)];
+            const value2 = translatedColValues[ObjectUtils.resolveFieldData(data2, sortColumn)];
+            if (value1 == null && value2 != null)
+                result = -1;
+            else if (value1 != null && value2 == null)
+                result = 1;
+            else if (value1 == null && value2 == null)
+                result = 0;
+            else if (typeof value1 === 'string' && typeof value2 === 'string')
+                result = value1.localeCompare(value2, [this.locale, 'en', 'de'], { numeric: true });
+            else {
+                if (value1 < value2) {
+                    result = -1;
+                }
+                else if (value1 > value2) {
+                    result = 1;
+                }
+                else {
+                    result = 0;
+                }
+            }
+            return direction * result;
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-sort-base.js","sourceRoot":"","sources":["../../../../../../../libs/angular-accelerator/src/lib/components/data-sort-base/data-sort-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { TranslateService } from '@ngx-translate/core'\nimport { Observable, map, of } from 'rxjs'\nimport { flattenObject } from '../../functions/flatten-object'\nimport { ColumnType } from '../../model/column-type.model'\nimport { DataSortDirection } from '../../model/data-sort-direction'\nimport { DataTableColumn } from '../../model/data-table-column.model'\nimport { ListGridData } from '../../components/data-list-grid/data-list-grid.component'\nimport { Row, Filter } from '../../components/data-table/data-table.component'\nimport { ObjectUtils } from '../../utils/objectutils'\n\ntype RowListGridData = ListGridData | Row\n\nexport class DataSortBase {\n  constructor(protected locale: string, protected translateService: TranslateService) {}\n\n  translateItems(\n    [items, filters, sortColumn, sortDirection]: [RowListGridData[], Filter[], string, DataSortDirection],\n    columns: DataTableColumn[],\n    clientSideFiltering: boolean,\n    clientSideSorting: boolean\n  ): Observable<[RowListGridData[], Filter[], string, DataSortDirection, Record<string, Record<string, string>>]> {\n    if (clientSideFiltering || clientSideSorting) {\n      let translationKeys: string[] = []\n      const translatedColumns = columns.filter((c) => c.columnType === ColumnType.TRANSLATION_KEY)\n      translatedColumns.forEach((c) => {\n        translationKeys = [...translationKeys, ...items.map((i) => ObjectUtils.resolveFieldData(i, c.id)?.toString())]\n      })\n      if (translationKeys.length) {\n        return this.translateService.get(translationKeys).pipe(\n          map((translatedValues: Record<string, string>) => {\n            const translations: Record<string, Record<string, string>> = {}\n            translatedColumns.forEach((c) => {\n              translations[c.id] = Object.fromEntries(\n                items.map((i) => [\n                  ObjectUtils.resolveFieldData(i, c.id)?.toString() || '',\n                  translatedValues[ObjectUtils.resolveFieldData(i, c.id)?.toString()],\n                ])\n              )\n            })\n            return [items, filters, sortColumn, sortDirection, translations]\n          })\n        )\n      }\n    }\n    return of([items, filters, sortColumn, sortDirection, {}])\n  }\n\n  filterItems(\n    [items, filters, sortColumn, sortDirection, translations]: [\n      RowListGridData[],\n      Filter[],\n      string,\n      DataSortDirection,\n      Record<string, Record<string, string>>\n    ],\n    clientSideFiltering: boolean\n  ): [RowListGridData[], Filter[], string, DataSortDirection, Record<string, Record<string, string>>] {\n    if (!clientSideFiltering) {\n      return [items, filters, sortColumn, sortDirection, translations]\n    }\n    return [\n      items.filter((item) =>\n        filters\n          .map((filter) => filter.columnId)\n          .filter((value, index, self) => self.indexOf(value) === index && value != null)\n          .every((filterColumnId) =>\n            filters\n              .filter((filter) => filter.columnId === filterColumnId)\n              .some(\n                (filter) =>\n                  (\n                    translations[filter.columnId]?.[ObjectUtils.resolveFieldData(item, filter.columnId).toString()] ||\n                    ObjectUtils.resolveFieldData(item, filter.columnId)\n                  ).toString() === filter.value.toString()\n              )\n          )\n      ),\n      filters,\n      sortColumn,\n      sortDirection,\n      translations,\n    ]\n  }\n\n  sortItems(\n    [items, filters, sortColumn, sortDirection, translations]: [\n      RowListGridData[],\n      Filter[],\n      string,\n      DataSortDirection,\n      Record<string, Record<string, string>>\n    ],\n    columns: DataTableColumn[],\n    clientSideSorting: boolean\n  ): [RowListGridData[], Filter[], string, DataSortDirection, Record<string, Record<string, string>>] {\n    if (!clientSideSorting || sortColumn === '') {\n      return [items, filters, sortColumn, sortDirection, translations]\n    }\n    let translatedColValues: Record<string, string> = Object.fromEntries(\n      items.map((i) => [\n        ObjectUtils.resolveFieldData(i, sortColumn)?.toString(),\n        ObjectUtils.resolveFieldData(i, sortColumn)?.toString(),\n      ])\n    )\n    if (columns.find((h) => h.id === sortColumn)?.columnType === ColumnType.TRANSLATION_KEY) {\n      translatedColValues = translations[sortColumn]\n    }\n    return [\n      [...items].sort(this.createCompareFunction(translatedColValues, sortColumn, sortDirection)),\n      filters,\n      sortColumn,\n      sortDirection,\n      translations,\n    ]\n  }\n\n  flattenItems(items: RowListGridData[]) {\n    return items.map((i) => flattenObject(i))\n  }\n\n  createCompareFunction(\n    translatedColValues: Record<string, string>,\n    sortColumn: string,\n    sortDirection: DataSortDirection\n  ): (a: Record<string, any>, b: Record<string, any>) => number {\n    let direction = 0\n    if (sortDirection === DataSortDirection.ASCENDING) {\n      direction = 1\n    } else if (sortDirection === DataSortDirection.DESCENDING) {\n      direction = -1\n    }\n    return (data1, data2) => {\n      if (direction === 0) {\n        return 0\n      }\n      let result\n      const value1 = translatedColValues[ObjectUtils.resolveFieldData(data1, sortColumn)]\n      const value2 = translatedColValues[ObjectUtils.resolveFieldData(data2, sortColumn)]\n\n      if (value1 == null && value2 != null) result = -1\n      else if (value1 != null && value2 == null) result = 1\n      else if (value1 == null && value2 == null) result = 0\n      else if (typeof value1 === 'string' && typeof value2 === 'string')\n        result = value1.localeCompare(value2, [this.locale, 'en', 'de'], { numeric: true })\n      else {\n        if (value1 < value2) {\n          result = -1\n        } else if (value1 > value2) {\n          result = 1\n        } else {\n          result = 0\n        }\n      }\n      return direction * result\n    }\n  }\n}\n"]}