@messaia/cdk 18.1.0-rc19 → 18.1.0-rc20

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"]}