@messaia/cdk 18.1.0-rc19 → 18.1.0-rc21

package/esm2022/lib/common/common.module.mjs

@@ -1,5 +1,6 @@
 import { COMPILER_OPTIONS, Compiler, CompilerFactory, NgModule, ViewEncapsulation } from '@angular/core';
 import { JitCompilerFactory } from '@angular/platform-browser-dynamic';
+import { AutofocusDirective } from './directives/autofocus.directive';
 import { DisableControlDirective } from './directives/disable-control.directive';
 import { DataSourcePipe } from './pipes/data-source.pipe';
 import { EnumPipe } from './pipes/enum.pipe';
@@ -64,6 +65,7 @@ export { BaseService } from './services/base.service';
 export { ContextHelper } from './services/context-helper';
 export { EnumService } from './services/enum.service';
 export { ServiceLocator } from './services/service-locator';
+export { AutofocusDirective };
 const compilerOptions = {
     defaultEncapsulation: ViewEncapsulation.None
 };
@@ -101,7 +103,8 @@ const COMMON_DECLARATIONS = [
     JoinPipe,
     PropertyJoinPipe,
     BindPipe,
-    MapPipe
+    MapPipe,
+    AutofocusDirective
 ];
 export class VdCommonModule {
     /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: VdCommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
@@ -130,7 +133,8 @@ export class VdCommonModule {
             JoinPipe,
             PropertyJoinPipe,
             BindPipe,
-            MapPipe], exports: [DataSourcePipe,
+            MapPipe,
+            AutofocusDirective], exports: [DataSourcePipe,
             DisableControlDirective,
             EnumPipe,
             FileSizePipe,
@@ -155,7 +159,8 @@ export class VdCommonModule {
             JoinPipe,
             PropertyJoinPipe,
             BindPipe,
-            MapPipe] });
+            MapPipe,
+            AutofocusDirective] });
     /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: VdCommonModule, providers: [...RUNTIME_COMPILER_PROVIDERS] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: VdCommonModule, decorators: [{
@@ -167,4 +172,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImpor
                     providers: [...RUNTIME_COMPILER_PROVIDERS]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.module.js","sourceRoot":"","sources":["../../../../../projects/cdk/src/lib/common/common.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { COMPILER_OPTIONS, Compiler, CompilerFactory, CompilerOptions, NgModule, StaticProvider, ViewEncapsulation } from '@angular/core';\r\nimport { JitCompilerFactory } from '@angular/platform-browser-dynamic';\r\nimport { DisableControlDirective } from './directives/disable-control.directive';\r\nimport { DataSourcePipe } from './pipes/data-source.pipe';\r\nimport { EnumPipe } from './pipes/enum.pipe';\r\nimport { FileSizePipe } from './pipes/file-size.pipe';\r\nimport { FilterPipe } from './pipes/filter.pipe';\r\nimport { FirstLetterPipe } from './pipes/first-letter';\r\nimport { FormArrayPipe } from './pipes/form-array.pipe';\r\nimport { FormControlPipe } from './pipes/form-control.pipe';\r\nimport { FormGroupPipe } from './pipes/form-group.pipe';\r\nimport { FuncPipe } from './pipes/func.pipe';\r\nimport { JoinPipe } from './pipes/join.pipe';\r\nimport { KeysPipe } from './pipes/keys';\r\nimport { MapPipe } from './pipes/map.pipe';\r\nimport { MonthNamePipe } from './pipes/month-name.pipe';\r\nimport { PropertyPipe } from './pipes/nested-property';\r\nimport { OnlyNumberDirective } from './pipes/only-number';\r\nimport { OrderPipe } from './pipes/order.pipe';\r\nimport { PlaceholderPipe } from './pipes/placeholder.pipe';\r\nimport { PropertyJoinPipe } from './pipes/property-join.pipe';\r\nimport { SafeHtmlPipe } from './pipes/safe-html.pipe';\r\nimport { SplitPipe } from './pipes/split.pipe';\r\nimport { TimePipe } from './pipes/time.pipe';\r\nimport { TitleCase } from './pipes/titlecase.pipe';\r\nimport { TruncatePipe } from './pipes/truncate.pipe';\r\nimport { ValuesPipe } from './pipes/values';\r\nimport { BindPipe } from './public_api';\r\n\r\nexport { IControlValueAccessor, mixinControlValueAccessor } from './behaviors/control-value-accesor.mixin';\r\nexport { ICanDisable, mixinDisabled } from './behaviors/disabled.mixin';\r\nexport { endpointMetadataKey, headerMetadataKey } from './constants/constants';\r\nexport { FilterGlue } from './enums/filter-glue';\r\nexport { FilterOperator } from './enums/filter-operator';\r\nexport { Salutation } from './enums/salutation';\r\nexport { Api, Display } from './functions/decorators';\r\nexport { getEndpoint } from './functions/functions';\r\nexport { Utils } from './functions/utils';\r\nexport { AppStorage } from './helpers/app-storage';\r\nexport { DynamicBuilder } from './helpers/dynamic-builder';\r\nexport { DynamicComponentCompiler } from './helpers/dynamic-component-compiler';\r\nexport { ActionItem } from './models/action-item';\r\nexport { AppSetting } from './models/app-setting';\r\nexport { AuditEntity } from './models/audit-entity';\r\nexport { AuditUser } from './models/audit-user';\r\nexport { BaseEntity } from './models/base-entity';\r\nexport { IEntity } from './models/entity';\r\nexport { EnumItem } from './models/enum-item';\r\nexport { Filter } from './models/filter';\r\nexport { FilterField } from './models/filter-field';\r\nexport { Icon } from './models/icon';\r\nexport { KeyValue } from './models/key-value';\r\nexport { SaveAction } from './models/save-action';\r\nexport { SuffixButton } from './models/suffix-button';\r\nexport { DataSourcePipe } from './pipes/data-source.pipe';\r\nexport { EnumPipe } from './pipes/enum.pipe';\r\nexport { FirstLetterPipe } from './pipes/first-letter';\r\nexport { JoinPipe } from './pipes/join.pipe';\r\nexport { KeysPipe } from './pipes/keys';\r\nexport { MapPipe } from './pipes/map.pipe';\r\nexport { PropertyPipe } from './pipes/nested-property';\r\nexport { OrderPipe } from './pipes/order.pipe';\r\nexport { PropertyJoinPipe } from './pipes/property-join.pipe';\r\nexport { SplitPipe } from './pipes/split.pipe';\r\nexport { TitleCase } from './pipes/titlecase.pipe';\r\nexport { ValuesPipe } from './pipes/values';\r\nexport { BaseService } from './services/base.service';\r\nexport { ContextHelper } from './services/context-helper';\r\nexport { EnumService } from './services/enum.service';\r\nexport { ServiceLocator } from './services/service-locator';\r\n\r\nconst compilerOptions: CompilerOptions = {\r\n\tdefaultEncapsulation: ViewEncapsulation.None\r\n};\r\n\r\nexport function createCompiler(compilerFactory: CompilerFactory) {\r\n\treturn compilerFactory.createCompiler([compilerOptions]);\r\n}\r\n\r\nexport const RUNTIME_COMPILER_PROVIDERS: StaticProvider[] = [\r\n\t{ provide: COMPILER_OPTIONS, useValue: { compilerOptions }, multi: true },\r\n\t{ provide: CompilerFactory, useClass: JitCompilerFactory, deps: [COMPILER_OPTIONS] },\r\n\t{ provide: Compiler, useFactory: createCompiler, deps: [CompilerFactory] }\r\n];\r\n\r\nconst COMMON_DECLARATIONS = [\r\n\tDataSourcePipe,\r\n\tDisableControlDirective,\r\n\tEnumPipe,\r\n\tFileSizePipe,\r\n\tFilterPipe,\r\n\tFirstLetterPipe,\r\n\tFormControlPipe,\r\n\tFormGroupPipe,\r\n\tFormArrayPipe,\r\n\tFuncPipe,\r\n\tKeysPipe,\r\n\tMonthNamePipe,\r\n\tOnlyNumberDirective,\r\n\tOrderPipe,\r\n\tPlaceholderPipe,\r\n\tSafeHtmlPipe,\r\n\tTimePipe,\r\n\tTitleCase,\r\n\tTruncatePipe,\r\n\tValuesPipe,\r\n\tPropertyPipe,\r\n\tSplitPipe,\r\n\tJoinPipe,\r\n\tPropertyJoinPipe,\r\n\tBindPipe,\r\n\tMapPipe\r\n];\r\n\r\n@NgModule({\r\n\timports: [],\r\n\texports: [COMMON_DECLARATIONS],\r\n\tdeclarations: [COMMON_DECLARATIONS],\r\n\tproviders: [...RUNTIME_COMPILER_PROVIDERS]\r\n})\r\nexport class VdCommonModule { }"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.module.js","sourceRoot":"","sources":["../../../../../projects/cdk/src/lib/common/common.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { COMPILER_OPTIONS, Compiler, CompilerFactory, CompilerOptions, NgModule, StaticProvider, ViewEncapsulation } from '@angular/core';\r\nimport { JitCompilerFactory } from '@angular/platform-browser-dynamic';\r\nimport { AutofocusDirective } from './directives/autofocus.directive';\r\nimport { DisableControlDirective } from './directives/disable-control.directive';\r\nimport { DataSourcePipe } from './pipes/data-source.pipe';\r\nimport { EnumPipe } from './pipes/enum.pipe';\r\nimport { FileSizePipe } from './pipes/file-size.pipe';\r\nimport { FilterPipe } from './pipes/filter.pipe';\r\nimport { FirstLetterPipe } from './pipes/first-letter';\r\nimport { FormArrayPipe } from './pipes/form-array.pipe';\r\nimport { FormControlPipe } from './pipes/form-control.pipe';\r\nimport { FormGroupPipe } from './pipes/form-group.pipe';\r\nimport { FuncPipe } from './pipes/func.pipe';\r\nimport { JoinPipe } from './pipes/join.pipe';\r\nimport { KeysPipe } from './pipes/keys';\r\nimport { MapPipe } from './pipes/map.pipe';\r\nimport { MonthNamePipe } from './pipes/month-name.pipe';\r\nimport { PropertyPipe } from './pipes/nested-property';\r\nimport { OnlyNumberDirective } from './pipes/only-number';\r\nimport { OrderPipe } from './pipes/order.pipe';\r\nimport { PlaceholderPipe } from './pipes/placeholder.pipe';\r\nimport { PropertyJoinPipe } from './pipes/property-join.pipe';\r\nimport { SafeHtmlPipe } from './pipes/safe-html.pipe';\r\nimport { SplitPipe } from './pipes/split.pipe';\r\nimport { TimePipe } from './pipes/time.pipe';\r\nimport { TitleCase } from './pipes/titlecase.pipe';\r\nimport { TruncatePipe } from './pipes/truncate.pipe';\r\nimport { ValuesPipe } from './pipes/values';\r\nimport { BindPipe } from './public_api';\r\n\r\nexport { IControlValueAccessor, mixinControlValueAccessor } from './behaviors/control-value-accesor.mixin';\r\nexport { ICanDisable, mixinDisabled } from './behaviors/disabled.mixin';\r\nexport { endpointMetadataKey, headerMetadataKey } from './constants/constants';\r\nexport { FilterGlue } from './enums/filter-glue';\r\nexport { FilterOperator } from './enums/filter-operator';\r\nexport { Salutation } from './enums/salutation';\r\nexport { Api, Display } from './functions/decorators';\r\nexport { getEndpoint } from './functions/functions';\r\nexport { Utils } from './functions/utils';\r\nexport { AppStorage } from './helpers/app-storage';\r\nexport { DynamicBuilder } from './helpers/dynamic-builder';\r\nexport { DynamicComponentCompiler } from './helpers/dynamic-component-compiler';\r\nexport { ActionItem } from './models/action-item';\r\nexport { AppSetting } from './models/app-setting';\r\nexport { AuditEntity } from './models/audit-entity';\r\nexport { AuditUser } from './models/audit-user';\r\nexport { BaseEntity } from './models/base-entity';\r\nexport { IEntity } from './models/entity';\r\nexport { EnumItem } from './models/enum-item';\r\nexport { Filter } from './models/filter';\r\nexport { FilterField } from './models/filter-field';\r\nexport { Icon } from './models/icon';\r\nexport { KeyValue } from './models/key-value';\r\nexport { SaveAction } from './models/save-action';\r\nexport { SuffixButton } from './models/suffix-button';\r\nexport { DataSourcePipe } from './pipes/data-source.pipe';\r\nexport { EnumPipe } from './pipes/enum.pipe';\r\nexport { FirstLetterPipe } from './pipes/first-letter';\r\nexport { JoinPipe } from './pipes/join.pipe';\r\nexport { KeysPipe } from './pipes/keys';\r\nexport { MapPipe } from './pipes/map.pipe';\r\nexport { PropertyPipe } from './pipes/nested-property';\r\nexport { OrderPipe } from './pipes/order.pipe';\r\nexport { PropertyJoinPipe } from './pipes/property-join.pipe';\r\nexport { SplitPipe } from './pipes/split.pipe';\r\nexport { TitleCase } from './pipes/titlecase.pipe';\r\nexport { ValuesPipe } from './pipes/values';\r\nexport { BaseService } from './services/base.service';\r\nexport { ContextHelper } from './services/context-helper';\r\nexport { EnumService } from './services/enum.service';\r\nexport { ServiceLocator } from './services/service-locator';\r\nexport { AutofocusDirective };\r\n\r\nconst compilerOptions: CompilerOptions = {\r\n\tdefaultEncapsulation: ViewEncapsulation.None\r\n};\r\n\r\nexport function createCompiler(compilerFactory: CompilerFactory) {\r\n\treturn compilerFactory.createCompiler([compilerOptions]);\r\n}\r\n\r\nexport const RUNTIME_COMPILER_PROVIDERS: StaticProvider[] = [\r\n\t{ provide: COMPILER_OPTIONS, useValue: { compilerOptions }, multi: true },\r\n\t{ provide: CompilerFactory, useClass: JitCompilerFactory, deps: [COMPILER_OPTIONS] },\r\n\t{ provide: Compiler, useFactory: createCompiler, deps: [CompilerFactory] }\r\n];\r\n\r\nconst COMMON_DECLARATIONS = [\r\n\tDataSourcePipe,\r\n\tDisableControlDirective,\r\n\tEnumPipe,\r\n\tFileSizePipe,\r\n\tFilterPipe,\r\n\tFirstLetterPipe,\r\n\tFormControlPipe,\r\n\tFormGroupPipe,\r\n\tFormArrayPipe,\r\n\tFuncPipe,\r\n\tKeysPipe,\r\n\tMonthNamePipe,\r\n\tOnlyNumberDirective,\r\n\tOrderPipe,\r\n\tPlaceholderPipe,\r\n\tSafeHtmlPipe,\r\n\tTimePipe,\r\n\tTitleCase,\r\n\tTruncatePipe,\r\n\tValuesPipe,\r\n\tPropertyPipe,\r\n\tSplitPipe,\r\n\tJoinPipe,\r\n\tPropertyJoinPipe,\r\n\tBindPipe,\r\n\tMapPipe,\r\n\tAutofocusDirective\r\n];\r\n\r\n@NgModule({\r\n\timports: [],\r\n\texports: [COMMON_DECLARATIONS],\r\n\tdeclarations: [COMMON_DECLARATIONS],\r\n\tproviders: [...RUNTIME_COMPILER_PROVIDERS]\r\n})\r\nexport class VdCommonModule { }"]}

package/esm2022/lib/common/directives/autofocus.directive.mjs

@@ -0,0 +1,48 @@
+import { Directive, ElementRef, Input } from "@angular/core";
+import * as i0 from "@angular/core";
+export class AutofocusDirective {
+    elementRef;
+    /**
+     * Optional input to customize the delay
+     */
+    focusDelay = 300;
+    /**
+     * Determines whether the text should be selected on focus
+     */
+    selectText = false;
+    /**
+     * Constructor that injects the ElementRef, giving direct access
+     * to the host DOM element where the directive is applied.
+     * @param elementRef - The reference to the element on which the directive is set
+     */
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+    }
+    /**
+     * Set focus on the element after content initialization
+     */
+    ngAfterContentInit() {
+        setTimeout(() => {
+            if (this.elementRef.nativeElement) {
+                this.elementRef.nativeElement.focus();
+                /* Select the text if selectText is true */
+                if (this.selectText) {
+                    this.elementRef.nativeElement.select();
+                }
+            }
+        }, this.focusDelay);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: AutofocusDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.7", type: AutofocusDirective, selector: "[autoFocus]", inputs: { focusDelay: "focusDelay", selectText: "selectText" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: AutofocusDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[autoFocus]"
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { focusDelay: [{
+                type: Input
+            }], selectText: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/common/pipes/enum.pipe.mjs

@@ -2,12 +2,30 @@ import { Pipe } from "@angular/core";
 import * as i0 from "@angular/core";
 export class EnumPipe {
     /**
-     * Converts enum value to string
-     * @param value
-     * @param enumType
+     * Converts an enum value to its corresponding string representation.
+     *
+     * @param value - The numeric value of the enum to convert.
+     * @param enumType - The enum type (as an object) that defines the mapping of values to their string representations.
+     * @param prefixOrMetadata - Either a prefix string to prepend to the resulting string,
+     *                           or an object containing EnumMetadata for additional display information.
+     * @param suffix - An optional string to append to the resulting string (default is an empty string).
+     * @returns The formatted string representation of the enum value, including any specified prefixes or suffixes,
+     *          or undefined if the value is not recognized in the provided enum type.
      */
-    transform(value, enumType, prefix = '', suffix = '') {
-        return `${prefix}${enumType[value]}${suffix}`;
+    transform(value, enumType, prefixOrMetadata, suffix = '') {
+        /* Determine if prefixOrMetadata is an object containing EnumMetadata for the given value */
+        if (prefixOrMetadata && typeof prefixOrMetadata === 'object' && value in prefixOrMetadata) {
+            const metadata = prefixOrMetadata[value];
+            /* Return the display string from the metadata along with the suffix */
+            return `${metadata.display}${suffix}`;
+        }
+        /* Check if enumType is an object and contains the specified value */
+        if (enumType && typeof enumType === 'object' && value in enumType) {
+            /* Return the corresponding string value from the enum, prepending the prefix if provided */
+            return `${prefixOrMetadata ?? ''}${enumType[value]}${suffix}`;
+        }
+        /* If the value is not recognized in the enumType, return undefined as a fallback */
+        return undefined;
     }
     /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: EnumPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
     /** @nocollapse */ static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.7", ngImport: i0, type: EnumPipe, name: "enum", pure: false });
@@ -20,4 +38,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImpor
                     pure: false
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW51bS5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2RrL3NyYy9saWIvY29tbW9uL3BpcGVzL2VudW0ucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFPcEQsTUFBTSxPQUFPLFFBQVE7SUFFcEI7Ozs7T0FJRztJQUNILFNBQVMsQ0FBQyxLQUFhLEVBQUUsUUFBYSxFQUFFLFNBQWlCLEVBQUUsRUFBRSxTQUFpQixFQUFFO1FBQy9FLE9BQU8sR0FBRyxNQUFNLEdBQUcsUUFBUSxDQUFDLEtBQUssQ0FBQyxHQUFHLE1BQU0sRUFBRSxDQUFDO0lBQy9DLENBQUM7MEhBVFcsUUFBUTt3SEFBUixRQUFROzsyRkFBUixRQUFRO2tCQUxwQixJQUFJO21CQUFDO29CQUNMLElBQUksRUFBRSxNQUFNO29CQUNaLCtEQUErRDtvQkFDL0QsSUFBSSxFQUFFLEtBQUs7aUJBQ1giLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuXHJcbkBQaXBlKHtcclxuXHRuYW1lOiAnZW51bScsXHJcblx0LyogUmVxdWlyZWQgdG8gdXBkYXRlIHRoZSB2YWx1ZSB3aGVuIHRoZSBwcm9taXNlIGlzIHJlc29sdmVkICovXHJcblx0cHVyZTogZmFsc2VcclxufSlcclxuZXhwb3J0IGNsYXNzIEVudW1QaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XHJcblxyXG5cdC8qKlxyXG5cdCAqIENvbnZlcnRzIGVudW0gdmFsdWUgdG8gc3RyaW5nXHJcblx0ICogQHBhcmFtIHZhbHVlIFxyXG5cdCAqIEBwYXJhbSBlbnVtVHlwZSBcclxuXHQgKi9cclxuXHR0cmFuc2Zvcm0odmFsdWU6IG51bWJlciwgZW51bVR5cGU6IGFueSwgcHJlZml4OiBzdHJpbmcgPSAnJywgc3VmZml4OiBzdHJpbmcgPSAnJyk6IGFueSB7XHJcblx0XHRyZXR1cm4gYCR7cHJlZml4fSR7ZW51bVR5cGVbdmFsdWVdfSR7c3VmZml4fWA7XHJcblx0fVxyXG59Il19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/common/pipes/order.pipe.mjs

@@ -3,111 +3,176 @@ import * as i0 from "@angular/core";
 //@dynamic
 export class OrderPipe {
     /**
-     * Check if a value is a string
+     * Checks if a value is a string.
      *
-     * @param value
+     * @param value - The value to check.
+     * @returns True if the value is a string; otherwise, false.
      */
     static isString(value) {
         return typeof value === 'string' || value instanceof String;
     }
     /**
-     * Sorts values ignoring the case
+     * Sorts two values in a case-insensitive manner.
      *
-     * @param a
-     * @param b
+     * @param a - The first value to compare.
+     * @param b - The second value to compare.
+     * @returns A negative number if a < b, a positive number if a > b, and 0 if they are equal.
      */
     static caseInsensitiveSort(a, b) {
+        /* If both values are strings, compare them using localeCompare for case-insensitive sorting. */
         if (OrderPipe.isString(a) && OrderPipe.isString(b)) {
             return a.localeCompare(b);
         }
+        /* Otherwise, fall back to the default comparison. */
         return OrderPipe.defaultCompare(a, b);
     }
     /**
-     * Default compare method
+     * Default comparison method for sorting values.
      *
-     * @param a
-     * @param b
+     * @param a - The first value to compare.
+     * @param b - The second value to compare.
+     * @returns A negative number if a < b, a positive number if a > b, and 0 if they are equal.
      */
     static defaultCompare(a, b) {
+        /* If both values are equal, return 0. */
         if (a === b) {
             return 0;
         }
+        /* If 'a' is null, it is considered greater than 'b'. */
         if (a == null) {
             return 1;
         }
+        /* If 'b' is null, it is considered greater than 'a'. */
         if (b == null) {
             return -1;
         }
+        /* Compare the two values. */
         return a > b ? 1 : -1;
     }
     /**
-     * Parse expression, split into items
-     * @param expression
+     * Parses a dot-separated expression string into an array of strings.
+     *
+     * @param expression - The expression string to parse.
+     * @returns An array of strings representing the parsed expression.
      */
     static parseExpression(expression) {
+        /* Replace bracket notation with dot notation and remove leading dot. */
         expression = expression.replace(/\[(\w+)\]/g, '.$1');
         expression = expression.replace(/^\./, '');
         return expression.split('.');
     }
     /**
-     * Get value by expression
+     * Retrieves a value from an object based on a parsed expression.
      *
-     * @param object
-     * @param expression
+     * @param object - The object to retrieve the value from.
+     * @param expression - The parsed expression as an array of strings.
+     * @returns The retrieved value or undefined if not found.
      */
     static getValue(object, expression) {
         for (let i = 0, n = expression.length; i < n; ++i) {
             const k = expression[i];
+            /* If the key does not exist in the object, return undefined. */
             if (!(k in object)) {
                 return;
             }
+            /* Move to the next level in the object. */
             object = object[k];
         }
+        /* Return the final value. */
         return object;
     }
     /**
-     * Set value by expression
+     * Sets a value in an object based on a parsed expression.
      *
-     * @param object
-     * @param value
-     * @param expression
+     * @param object - The object to modify.
+     * @param value - The value to set.
+     * @param expression - The parsed expression as an array of strings.
      */
     static setValue(object, value, expression) {
         let i;
         for (i = 0; i < expression.length - 1; i++) {
+            /* Traverse the object to the second-to-last property. */
             object = object[expression[i]];
         }
+        /* Set the value at the last property. */
         object[expression[i]] = value;
     }
-    transform(value, expression, reverse, isCaseInsensitive = false, comparator) {
+    /**
+     * Transforms the input value by sorting it based on the provided expression and metadata.
+     *
+     * @param value - The value to transform, which can be an array or a single object.
+     * @param expression - The expression to sort by, can be a string or an array of strings.
+     * @param metadata - An optional metadata object for sorting.
+     * @param reverse - Indicates if the sorting should be in reverse order.
+     * @param isCaseInsensitive - Indicates if the sorting should be case insensitive.
+     * @param comparator - An optional custom comparator function.
+     * @returns The transformed (sorted) value.
+     */
+    transform(value, expression, metadata, reverse, isCaseInsensitive = false, comparator) {
+        /* If the value is null or undefined, return it as is. */
         if (!value) {
             return value;
         }
+        /* Check if we should sort by metadata. */
+        if (metadata) {
+            return this.sortByMetadata(value, expression, reverse ?? false, metadata);
+        }
+        /* If expression is an array, handle multiple expressions. */
         if (Array.isArray(expression)) {
             return this.multiExpressionTransform(value, expression, reverse ?? false, isCaseInsensitive, comparator);
         }
+        /* If value is an array, sort it using the provided expression. */
         if (Array.isArray(value)) {
             return this.sortArray(value.slice(), expression, reverse, isCaseInsensitive, comparator);
         }
+        /* If value is an object, transform it accordingly. */
         if (typeof value === 'object') {
             return this.transformObject(Object.assign({}, value), expression, reverse, isCaseInsensitive, comparator);
         }
+        /* If value is not an array or object, return it unchanged. */
         return value;
     }
     /**
-     * Sort array
+     * Sorts an array based on metadata for enum values.
+     *
+     * @param value - The array to sort.
+     * @param expression - The expression to sort by.
+     * @param reverse - Indicates if the sorting should be in reverse order.
+     * @param metadata - The metadata for enum sorting.
+     * @returns The sorted array.
+     */
+    sortByMetadata(value, expression, reverse, metadata) {
+        /* Comparison function for sorting by metadata order. */
+        const compareFn = (a, b) => {
+            const valueA = expression ? OrderPipe.getValue(a, OrderPipe.parseExpression(expression)) : a;
+            const valueB = expression ? OrderPipe.getValue(b, OrderPipe.parseExpression(expression)) : b;
+            /* Retrieve the order values from metadata, defaulting to Infinity if not found. */
+            const orderA = metadata[valueA]?.order ?? Infinity;
+            const orderB = metadata[valueB]?.order ?? Infinity;
+            return orderA - orderB;
+        };
+        /* Sort the array and handle reverse order. */
+        const sortedArray = value.slice().sort(compareFn);
+        return reverse ? sortedArray.reverse() : sortedArray;
+    }
+    /**
+     * Sorts an array based on the given expression.
      *
-     * @param value
-     * @param expression
-     * @param reverse
-     * @param isCaseInsensitive
-     * @param comparator
+     * @param value - The array to sort.
+     * @param expression - The expression to sort by.
+     * @param reverse - Indicates if the sorting should be in reverse order.
+     * @param isCaseInsensitive - Indicates if the sorting should be case insensitive.
+     * @param comparator - An optional custom comparator function.
+     * @returns The sorted array.
      */
     sortArray(value, expression, reverse, isCaseInsensitive, comparator) {
+        /* Determine if the expression is a deep link. */
         const isDeepLink = expression && expression.indexOf('.') !== -1;
+        /* Parse the expression if it's a deep link. */
         if (isDeepLink) {
             expression = OrderPipe.parseExpression(expression);
         }
+        /* Determine the comparison function. */
         let compareFn;
         if (comparator && typeof comparator === 'function') {
             compareFn = comparator;
@@ -115,60 +180,81 @@ export class OrderPipe {
         else {
             compareFn = isCaseInsensitive ? OrderPipe.caseInsensitiveSort : OrderPipe.defaultCompare;
         }
+        /* Sort the array using the determined comparison function. */
         let array = value.sort((a, b) => {
             if (!expression) {
                 return compareFn(a, b);
             }
             if (!isDeepLink) {
+                /* If not a deep link, compare the specified properties directly. */
                 if (a && b) {
                     return compareFn(a[expression], b[expression]);
                 }
+                /* Fall back to direct comparison. */
                 return compareFn(a, b);
             }
+            /* For deep links, get the values from the parsed expression. */
             return compareFn(OrderPipe.getValue(a, expression), OrderPipe.getValue(b, expression));
         });
+        /* Handle reverse sorting if specified. */
         if (reverse) {
             return array.reverse();
         }
         return array;
     }
     /**
-     * Transform Object
+     * Transforms an object based on a specified expression.
      *
-     * @param value
-     * @param expression
-     * @param reverse
-     * @param isCaseInsensitive
-     * @param comparator
+     * This method retrieves a value from the given object according to the parsed expression,
+     * applies the transformation to that value, and then sets the transformed value back into the object.
+     *
+     * @param value The object to transform.
+     * @param expression The expression used to identify the property to transform.
+     * @param reverse Optional. Indicates whether the transformation should be applied in reverse order.
+     * @param isCaseInsensitive Optional. Indicates whether the transformation should ignore case.
+     * @param comparator Optional. A custom comparator function to be used for sorting.
+     * @returns The transformed object with the updated value.
      */
     transformObject(value, expression, reverse, isCaseInsensitive, comparator) {
+        /* Parse the expression into an array of keys */
         let parsedExpression = OrderPipe.parseExpression(expression);
+        /* Retrieve the last predicate from the parsed expression for further processing */
         let lastPredicate = parsedExpression.pop();
+        /* Get the current value from the object using the parsed expression */
         let oldValue = OrderPipe.getValue(value, parsedExpression);
+        /* If there's a last predicate and the old value is not an array,
+           push the predicate back into the parsed expression for future use */
         if (lastPredicate && !Array.isArray(oldValue)) {
             parsedExpression.push(lastPredicate);
             lastPredicate = undefined;
             oldValue = OrderPipe.getValue(value, parsedExpression);
         }
+        /* If no old value is found, return the original object */
         if (!oldValue) {
             return value;
         }
-        OrderPipe.setValue(value, this.transform(oldValue, lastPredicate, reverse, isCaseInsensitive), parsedExpression);
-        return value;
+        /* Set the transformed value back into the original object */
+        OrderPipe.setValue(value, this.transform(oldValue, lastPredicate, undefined, reverse, isCaseInsensitive), parsedExpression);
+        return value; /* Return the updated object */
     }
     /**
-     * Apply multiple expressions
+     * Applies multiple expressions in sequence to transform a value.
+     *
+     * This method iterates over an array of expressions, applying each one in reverse order
+     * to the given value. The result of each transformation is passed as input to the next expression.
      *
-     * @param value
-     * @param expressions
-     * @param reverse
-     * @param isCaseInsensitive
-     * @param comparator
+     * @param value The initial value to transform.
+     * @param expressions An array of expressions to apply in reverse order.
+     * @param reverse Optional. Indicates whether the transformations should be applied in reverse order.
+     * @param isCaseInsensitive Optional. Indicates whether the transformations should ignore case.
+     * @param comparator Optional. A custom comparator function to be used for sorting.
+     * @returns The final transformed value after applying all expressions.
      */
     multiExpressionTransform(value, expressions, reverse, isCaseInsensitive = false, comparator) {
+        /* Apply each expression in reverse order, passing the result to the next transformation */
         return expressions.reverse().reduce((result, expression) => {
-            return this.transform(result, expression, reverse, isCaseInsensitive, comparator);
-        }, value);
+            return this.transform(result, expression, undefined, reverse, isCaseInsensitive, comparator);
+        }, value); /* Return the final transformed value */
     }
     /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: OrderPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
     /** @nocollapse */ static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.7", ngImport: i0, type: OrderPipe, name: "orderBy", pure: false });
@@ -180,4 +266,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImpor
                     pure: false
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"order.pipe.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/common/pipes/order.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import { Pipe, PipeTransform } from '@angular/core';\r\n\r\n//@dynamic\r\n@Pipe({\r\n\tname: 'orderBy',\r\n\tpure: false\r\n})\r\nexport class OrderPipe implements PipeTransform {\r\n\r\n\t/**\r\n\t * Check if a value is a string\r\n\t *\r\n\t * @param value\r\n\t */\r\n\tstatic isString(value: any) {\r\n\t\treturn typeof value === 'string' || value instanceof String;\r\n\t}\r\n\r\n\t/**\r\n\t * Sorts values ignoring the case\r\n\t *\r\n\t * @param a\r\n\t * @param b\r\n\t */\r\n\tstatic caseInsensitiveSort(a: any, b: any) {\r\n\t\tif (OrderPipe.isString(a) && OrderPipe.isString(b)) {\r\n\t\t\treturn a.localeCompare(b);\r\n\t\t}\r\n\t\treturn OrderPipe.defaultCompare(a, b);\r\n\t}\r\n\r\n\t/**\r\n\t * Default compare method\r\n\t * \r\n\t * @param a \r\n\t * @param b \r\n\t */\r\n\tstatic defaultCompare(a: any, b: any) {\r\n\t\tif (a === b) {\r\n\t\t\treturn 0;\r\n\t\t}\r\n\t\tif (a == null) {\r\n\t\t\treturn 1;\r\n\t\t}\r\n\t\tif (b == null) {\r\n\t\t\treturn -1;\r\n\t\t}\r\n\t\treturn a > b ? 1 : -1;\r\n\t}\r\n\r\n\t/**\r\n\t * Parse expression, split into items\r\n\t * @param expression\r\n\t */\r\n\tstatic parseExpression(expression: string): string[] {\r\n\t\texpression = expression.replace(/\\[(\\w+)\\]/g, '.$1');\r\n\t\texpression = expression.replace(/^\\./, '');\r\n\t\treturn expression.split('.');\r\n\t}\r\n\r\n\t/**\r\n\t * Get value by expression\r\n\t *\r\n\t * @param object\r\n\t * @param expression\r\n\t */\r\n\tstatic getValue(object: any, expression: string[]) {\r\n\t\tfor (let i = 0, n = expression.length; i < n; ++i) {\r\n\t\t\tconst k = expression[i];\r\n\t\t\tif (!(k in object)) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tobject = object[k];\r\n\t\t}\r\n\r\n\t\treturn object;\r\n\t}\r\n\r\n\t/**\r\n\t * Set value by expression\r\n\t *\r\n\t * @param object\r\n\t * @param value\r\n\t * @param expression\r\n\t */\r\n\tstatic setValue(object: any, value: any, expression: string[]) {\r\n\t\tlet i;\r\n\t\tfor (i = 0; i < expression.length - 1; i++) {\r\n\t\t\tobject = object[expression[i]];\r\n\t\t}\r\n\r\n\t\tobject[expression[i]] = value;\r\n\t}\r\n\r\n\ttransform(value: any | any[], expression?: any, reverse?: boolean, isCaseInsensitive: boolean = false, comparator?: Function): any {\r\n\t\tif (!value) {\r\n\t\t\treturn value;\r\n\t\t}\r\n\r\n\t\tif (Array.isArray(expression)) {\r\n\t\t\treturn this.multiExpressionTransform(value, expression, reverse ?? false, isCaseInsensitive, comparator);\r\n\t\t}\r\n\r\n\t\tif (Array.isArray(value)) {\r\n\t\t\treturn this.sortArray(value.slice(), expression, reverse, isCaseInsensitive, comparator);\r\n\t\t}\r\n\r\n\t\tif (typeof value === 'object') {\r\n\t\t\treturn this.transformObject(Object.assign({}, value), expression, reverse, isCaseInsensitive, comparator);\r\n\t\t}\r\n\r\n\t\treturn value;\r\n\t}\r\n\r\n\t/**\r\n\t * Sort array\r\n\t *\r\n\t * @param value\r\n\t * @param expression\r\n\t * @param reverse\r\n\t * @param isCaseInsensitive\r\n\t * @param comparator\r\n\t */\r\n\tprivate sortArray(value: any[], expression?: any, reverse?: boolean, isCaseInsensitive?: boolean, comparator?: Function): any[] {\r\n\t\tconst isDeepLink = expression && expression.indexOf('.') !== -1;\r\n\r\n\t\tif (isDeepLink) {\r\n\t\t\texpression = OrderPipe.parseExpression(expression);\r\n\t\t}\r\n\r\n\t\tlet compareFn: Function;\r\n\r\n\t\tif (comparator && typeof comparator === 'function') {\r\n\t\t\tcompareFn = comparator;\r\n\t\t} else {\r\n\t\t\tcompareFn = isCaseInsensitive ? OrderPipe.caseInsensitiveSort : OrderPipe.defaultCompare;\r\n\t\t}\r\n\r\n\t\tlet array: any[] = value.sort((a: any, b: any): number => {\r\n\t\t\tif (!expression) {\r\n\t\t\t\treturn compareFn(a, b);\r\n\t\t\t}\r\n\r\n\t\t\tif (!isDeepLink) {\r\n\t\t\t\tif (a && b) {\r\n\t\t\t\t\treturn compareFn(a[expression], b[expression]);\r\n\t\t\t\t}\r\n\t\t\t\treturn compareFn(a, b);\r\n\t\t\t}\r\n\r\n\t\t\treturn compareFn(OrderPipe.getValue(a, expression), OrderPipe.getValue(b, expression));\r\n\t\t});\r\n\r\n\t\tif (reverse) {\r\n\t\t\treturn array.reverse();\r\n\t\t}\r\n\r\n\t\treturn array;\r\n\t}\r\n\r\n\t/**\r\n\t * Transform Object\r\n\t *\r\n\t * @param value\r\n\t * @param expression\r\n\t * @param reverse\r\n\t * @param isCaseInsensitive\r\n\t * @param comparator\r\n\t */\r\n\tprivate transformObject(value: any | any[], expression?: any, reverse?: boolean, isCaseInsensitive?: boolean, comparator?: Function): any {\r\n\r\n\t\tlet parsedExpression = OrderPipe.parseExpression(expression);\r\n\t\tlet lastPredicate = parsedExpression.pop();\r\n\t\tlet oldValue = OrderPipe.getValue(value, parsedExpression);\r\n\r\n\t\tif (lastPredicate && !Array.isArray(oldValue)) {\r\n\t\t\tparsedExpression.push(lastPredicate);\r\n\t\t\tlastPredicate = undefined;\r\n\t\t\toldValue = OrderPipe.getValue(value, parsedExpression);\r\n\t\t}\r\n\r\n\t\tif (!oldValue) {\r\n\t\t\treturn value;\r\n\t\t}\r\n\r\n\t\tOrderPipe.setValue(value, this.transform(oldValue, lastPredicate, reverse, isCaseInsensitive), parsedExpression);\r\n\t\treturn value;\r\n\t}\r\n\r\n\t/**\r\n\t * Apply multiple expressions\r\n\t *\r\n\t * @param value\r\n\t * @param expressions\r\n\t * @param reverse\r\n\t * @param isCaseInsensitive\r\n\t * @param comparator\r\n\t */\r\n\tprivate multiExpressionTransform(value: any, expressions: any[], reverse: boolean, isCaseInsensitive: boolean = false, comparator?: Function): any {\r\n\t\treturn expressions.reverse().reduce((result: any, expression: any) => {\r\n\t\t\treturn this.transform(result, expression, reverse, isCaseInsensitive, comparator);\r\n\t\t}, value);\r\n\t}\r\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"order.pipe.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/common/pipes/order.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import { Pipe, PipeTransform } from '@angular/core';\r\nimport { EnumMetadata } from '../models/enum-metadata';\r\n\r\n//@dynamic\r\n@Pipe({\r\n\tname: 'orderBy',\r\n\tpure: false\r\n})\r\nexport class OrderPipe implements PipeTransform {\r\n\r\n\t/**\r\n\t * Checks if a value is a string.\r\n\t *\r\n\t * @param value - The value to check.\r\n\t * @returns True if the value is a string; otherwise, false.\r\n\t */\r\n\tstatic isString(value: any): boolean {\r\n\t\treturn typeof value === 'string' || value instanceof String;\r\n\t}\r\n\r\n\t/**\r\n\t * Sorts two values in a case-insensitive manner.\r\n\t *\r\n\t * @param a - The first value to compare.\r\n\t * @param b - The second value to compare.\r\n\t * @returns A negative number if a < b, a positive number if a > b, and 0 if they are equal.\r\n\t */\r\n\tstatic caseInsensitiveSort(a: any, b: any): number {\r\n\t\t/* If both values are strings, compare them using localeCompare for case-insensitive sorting. */\r\n\t\tif (OrderPipe.isString(a) && OrderPipe.isString(b)) {\r\n\t\t\treturn a.localeCompare(b);\r\n\t\t}\r\n\t\t/* Otherwise, fall back to the default comparison. */\r\n\t\treturn OrderPipe.defaultCompare(a, b);\r\n\t}\r\n\r\n\t/**\r\n\t * Default comparison method for sorting values.\r\n\t *\r\n\t * @param a - The first value to compare.\r\n\t * @param b - The second value to compare.\r\n\t * @returns A negative number if a < b, a positive number if a > b, and 0 if they are equal.\r\n\t */\r\n\tstatic defaultCompare(a: any, b: any): number {\r\n\t\t/* If both values are equal, return 0. */\r\n\t\tif (a === b) {\r\n\t\t\treturn 0;\r\n\t\t}\r\n\t\t/* If 'a' is null, it is considered greater than 'b'. */\r\n\t\tif (a == null) {\r\n\t\t\treturn 1;\r\n\t\t}\r\n\t\t/* If 'b' is null, it is considered greater than 'a'. */\r\n\t\tif (b == null) {\r\n\t\t\treturn -1;\r\n\t\t}\r\n\t\t/* Compare the two values. */\r\n\t\treturn a > b ? 1 : -1;\r\n\t}\r\n\r\n\t/**\r\n\t * Parses a dot-separated expression string into an array of strings.\r\n\t *\r\n\t * @param expression - The expression string to parse.\r\n\t * @returns An array of strings representing the parsed expression.\r\n\t */\r\n\tstatic parseExpression(expression: string): string[] {\r\n\t\t/* Replace bracket notation with dot notation and remove leading dot. */\r\n\t\texpression = expression.replace(/\\[(\\w+)\\]/g, '.$1');\r\n\t\texpression = expression.replace(/^\\./, '');\r\n\t\treturn expression.split('.');\r\n\t}\r\n\r\n\t/**\r\n\t * Retrieves a value from an object based on a parsed expression.\r\n\t *\r\n\t * @param object - The object to retrieve the value from.\r\n\t * @param expression - The parsed expression as an array of strings.\r\n\t * @returns The retrieved value or undefined if not found.\r\n\t */\r\n\tstatic getValue(object: any, expression: string[]): any {\r\n\t\tfor (let i = 0, n = expression.length; i < n; ++i) {\r\n\t\t\tconst k = expression[i];\r\n\t\t\t/* If the key does not exist in the object, return undefined. */\r\n\t\t\tif (!(k in object)) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\t/* Move to the next level in the object. */\r\n\t\t\tobject = object[k];\r\n\t\t}\r\n\t\t/* Return the final value. */\r\n\t\treturn object;\r\n\t}\r\n\r\n\t/**\r\n\t * Sets a value in an object based on a parsed expression.\r\n\t *\r\n\t * @param object - The object to modify.\r\n\t * @param value - The value to set.\r\n\t * @param expression - The parsed expression as an array of strings.\r\n\t */\r\n\tstatic setValue(object: any, value: any, expression: string[]): void {\r\n\t\tlet i;\r\n\t\tfor (i = 0; i < expression.length - 1; i++) {\r\n\t\t\t/* Traverse the object to the second-to-last property. */\r\n\t\t\tobject = object[expression[i]];\r\n\t\t}\r\n\t\t/* Set the value at the last property. */\r\n\t\tobject[expression[i]] = value;\r\n\t}\r\n\r\n\t/**\r\n\t * Transforms the input value by sorting it based on the provided expression and metadata.\r\n\t *\r\n\t * @param value - The value to transform, which can be an array or a single object.\r\n\t * @param expression - The expression to sort by, can be a string or an array of strings.\r\n\t * @param metadata - An optional metadata object for sorting.\r\n\t * @param reverse - Indicates if the sorting should be in reverse order.\r\n\t * @param isCaseInsensitive - Indicates if the sorting should be case insensitive.\r\n\t * @param comparator - An optional custom comparator function.\r\n\t * @returns The transformed (sorted) value.\r\n\t */\r\n\ttransform(value: any | any[], expression?: any, metadata?: { [key: number]: EnumMetadata }, reverse?: boolean, isCaseInsensitive: boolean = false, comparator?: Function): any {\r\n\t\t/* If the value is null or undefined, return it as is. */\r\n\t\tif (!value) {\r\n\t\t\treturn value;\r\n\t\t}\r\n\r\n\t\t/* Check if we should sort by metadata. */\r\n\t\tif (metadata) {\r\n\t\t\treturn this.sortByMetadata(value, expression, reverse ?? false, metadata);\r\n\t\t}\r\n\r\n\t\t/* If expression is an array, handle multiple expressions. */\r\n\t\tif (Array.isArray(expression)) {\r\n\t\t\treturn this.multiExpressionTransform(value, expression, reverse ?? false, isCaseInsensitive, comparator);\r\n\t\t}\r\n\r\n\t\t/* If value is an array, sort it using the provided expression. */\r\n\t\tif (Array.isArray(value)) {\r\n\t\t\treturn this.sortArray(value.slice(), expression, reverse, isCaseInsensitive, comparator);\r\n\t\t}\r\n\r\n\t\t/* If value is an object, transform it accordingly. */\r\n\t\tif (typeof value === 'object') {\r\n\t\t\treturn this.transformObject(Object.assign({}, value), expression, reverse, isCaseInsensitive, comparator);\r\n\t\t}\r\n\r\n\t\t/* If value is not an array or object, return it unchanged. */\r\n\t\treturn value;\r\n\t}\r\n\r\n\t/**\r\n\t * Sorts an array based on metadata for enum values.\r\n\t *\r\n\t * @param value - The array to sort.\r\n\t * @param expression - The expression to sort by.\r\n\t * @param reverse - Indicates if the sorting should be in reverse order.\r\n\t * @param metadata - The metadata for enum sorting.\r\n\t * @returns The sorted array.\r\n\t */\r\n\tprivate sortByMetadata(value: any[], expression: string | undefined, reverse: boolean, metadata: { [key: number]: EnumMetadata }): any[] {\r\n\t\t/* Comparison function for sorting by metadata order. */\r\n\t\tconst compareFn = (a: any, b: any): number => {\r\n\t\t\tconst valueA = expression ? OrderPipe.getValue(a, OrderPipe.parseExpression(expression)) : a;\r\n\t\t\tconst valueB = expression ? OrderPipe.getValue(b, OrderPipe.parseExpression(expression)) : b;\r\n\r\n\t\t\t/* Retrieve the order values from metadata, defaulting to Infinity if not found. */\r\n\t\t\tconst orderA = metadata[valueA]?.order ?? Infinity;\r\n\t\t\tconst orderB = metadata[valueB]?.order ?? Infinity;\r\n\r\n\t\t\treturn orderA - orderB;\r\n\t\t};\r\n\r\n\t\t/* Sort the array and handle reverse order. */\r\n\t\tconst sortedArray = value.slice().sort(compareFn);\r\n\t\treturn reverse ? sortedArray.reverse() : sortedArray;\r\n\t}\r\n\r\n\t/**\r\n\t * Sorts an array based on the given expression.\r\n\t *\r\n\t * @param value - The array to sort.\r\n\t * @param expression - The expression to sort by.\r\n\t * @param reverse - Indicates if the sorting should be in reverse order.\r\n\t * @param isCaseInsensitive - Indicates if the sorting should be case insensitive.\r\n\t * @param comparator - An optional custom comparator function.\r\n\t * @returns The sorted array.\r\n\t */\r\n\tprivate sortArray(value: any[], expression?: any, reverse?: boolean, isCaseInsensitive?: boolean, comparator?: Function): any[] {\r\n\t\t/* Determine if the expression is a deep link. */\r\n\t\tconst isDeepLink = expression && expression.indexOf('.') !== -1;\r\n\r\n\t\t/* Parse the expression if it's a deep link. */\r\n\t\tif (isDeepLink) {\r\n\t\t\texpression = OrderPipe.parseExpression(expression);\r\n\t\t}\r\n\r\n\t\t/* Determine the comparison function. */\r\n\t\tlet compareFn: Function;\r\n\r\n\t\tif (comparator && typeof comparator === 'function') {\r\n\t\t\tcompareFn = comparator;\r\n\t\t} else {\r\n\t\t\tcompareFn = isCaseInsensitive ? OrderPipe.caseInsensitiveSort : OrderPipe.defaultCompare;\r\n\t\t}\r\n\r\n\t\t/* Sort the array using the determined comparison function. */\r\n\t\tlet array: any[] = value.sort((a: any, b: any): number => {\r\n\t\t\tif (!expression) {\r\n\t\t\t\treturn compareFn(a, b);\r\n\t\t\t}\r\n\r\n\t\t\tif (!isDeepLink) {\r\n\t\t\t\t/* If not a deep link, compare the specified properties directly. */\r\n\t\t\t\tif (a && b) {\r\n\t\t\t\t\treturn compareFn(a[expression], b[expression]);\r\n\t\t\t\t}\r\n\t\t\t\t/* Fall back to direct comparison. */\r\n\t\t\t\treturn compareFn(a, b);\r\n\t\t\t}\r\n\r\n\t\t\t/* For deep links, get the values from the parsed expression. */\r\n\t\t\treturn compareFn(OrderPipe.getValue(a, expression), OrderPipe.getValue(b, expression));\r\n\t\t});\r\n\r\n\t\t/* Handle reverse sorting if specified. */\r\n\t\tif (reverse) {\r\n\t\t\treturn array.reverse();\r\n\t\t}\r\n\r\n\t\treturn array;\r\n\t}\r\n\r\n\t/**\r\n\t * Transforms an object based on a specified expression.\r\n\t *\r\n\t * This method retrieves a value from the given object according to the parsed expression,\r\n\t * applies the transformation to that value, and then sets the transformed value back into the object.\r\n\t *\r\n\t * @param value The object to transform.\r\n\t * @param expression The expression used to identify the property to transform.\r\n\t * @param reverse Optional. Indicates whether the transformation should be applied in reverse order.\r\n\t * @param isCaseInsensitive Optional. Indicates whether the transformation should ignore case.\r\n\t * @param comparator Optional. A custom comparator function to be used for sorting.\r\n\t * @returns The transformed object with the updated value.\r\n\t */\r\n\tprivate transformObject(value: any | any[], expression?: any, reverse?: boolean, isCaseInsensitive?: boolean, comparator?: Function): any {\r\n\t\t/* Parse the expression into an array of keys */\r\n\t\tlet parsedExpression = OrderPipe.parseExpression(expression);\r\n\r\n\t\t/* Retrieve the last predicate from the parsed expression for further processing */\r\n\t\tlet lastPredicate = parsedExpression.pop();\r\n\r\n\t\t/* Get the current value from the object using the parsed expression */\r\n\t\tlet oldValue = OrderPipe.getValue(value, parsedExpression);\r\n\r\n\t\t/* If there's a last predicate and the old value is not an array, \r\n\t\t   push the predicate back into the parsed expression for future use */\r\n\t\tif (lastPredicate && !Array.isArray(oldValue)) {\r\n\t\t\tparsedExpression.push(lastPredicate);\r\n\t\t\tlastPredicate = undefined;\r\n\t\t\toldValue = OrderPipe.getValue(value, parsedExpression);\r\n\t\t}\r\n\r\n\t\t/* If no old value is found, return the original object */\r\n\t\tif (!oldValue) {\r\n\t\t\treturn value;\r\n\t\t}\r\n\r\n\t\t/* Set the transformed value back into the original object */\r\n\t\tOrderPipe.setValue(value, this.transform(oldValue, lastPredicate, undefined, reverse, isCaseInsensitive), parsedExpression);\r\n\t\treturn value; /* Return the updated object */\r\n\t}\r\n\r\n\t/**\r\n\t * Applies multiple expressions in sequence to transform a value.\r\n\t *\r\n\t * This method iterates over an array of expressions, applying each one in reverse order\r\n\t * to the given value. The result of each transformation is passed as input to the next expression.\r\n\t *\r\n\t * @param value The initial value to transform.\r\n\t * @param expressions An array of expressions to apply in reverse order.\r\n\t * @param reverse Optional. Indicates whether the transformations should be applied in reverse order.\r\n\t * @param isCaseInsensitive Optional. Indicates whether the transformations should ignore case.\r\n\t * @param comparator Optional. A custom comparator function to be used for sorting.\r\n\t * @returns The final transformed value after applying all expressions.\r\n\t */\r\n\tprivate multiExpressionTransform(value: any, expressions: any[], reverse: boolean, isCaseInsensitive: boolean = false, comparator?: Function): any {\r\n\t\t/* Apply each expression in reverse order, passing the result to the next transformation */\r\n\t\treturn expressions.reverse().reduce((result: any, expression: any) => {\r\n\t\t\treturn this.transform(result, expression, undefined, reverse, isCaseInsensitive, comparator);\r\n\t\t}, value); /* Return the final transformed value */\r\n\t}\r\n}\r\n"]}