@sumaris-net/ngx-components 18.22.4 → 18.22.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sumaris-net/ngx-components",
   "description": "SUMARiS Angular components",
-  "version": "18.22.4",
+  "version": "18.22.5",
   "author": "contact@e-is.pro",
   "license": "AGPL-3.0",
   "readmeFilename": "README.md",

package/src/app/shared/functions.d.ts

@@ -68,9 +68,83 @@ export declare function suggestFromStringArray(values: string[], searchText: any
 }): string[];
 export declare function joinPropertiesPath<T = any>(obj: T, properties: string[], separator?: string): string | undefined;
 export declare function joinProperties<T = any, K extends keyof T = any>(obj: T, keys: K[], separator?: string): string | undefined;
-export declare function propertyPathComparator<T = any>(path: string | string[]): (a: T, b: T) => number;
-export declare function propertyComparator<T = any, K extends keyof T = any>(key: K, defaultValue?: any): (a: T, b: T) => number;
-export declare function propertiesPathComparator<T = any>(keys: string[], defaultValues?: any[]): (a: T, b: T) => number;
+/**
+ * Generic comparison between two values.
+ *
+ * Compares two values using the JavaScript greater-than operator.
+ * Works for numbers, strings, dates, and any types that provide
+ * a meaningful `>` comparison. Use for ascending order.
+ *
+ * @typeParam T - Type of the compared values.
+ * @param a - Left value to compare.
+ * @param b - Right value to compare.
+ * @returns 0 if equal, -1 if a < b, 1 if a > b.
+ */
+export declare function compareValues<T>(a: T, b: T): number;
+/**
+ * Reverse comparison between two values (descending order).
+ *
+ * Same semantics as {@link compareValues} but inverted, to sort
+ * in descending order.
+ *
+ * @typeParam T - Type of the compared values.
+ * @param a - Left value to compare.
+ * @param b - Right value to compare.
+ * @returns 0 if equal, 1 if a < b, -1 if a > b.
+ */
+export declare function compareValuesDesc<T>(a: T, b: T): number;
+/**
+ * Build a comparator function based on a nested property path.
+ *
+ * Uses {@link getPropertyByPath} to extract values and compares them
+ * in ascending or descending order.
+ *
+ * @typeParam T - Type of compared objects.
+ * @param path - Property path or array path (e.g. "a.b[0].c").
+ * @param direction - Sort direction, 'asc' by default.
+ * @returns A comparator compatible with `Array.prototype.sort`.
+ */
+export declare function propertyPathComparator<T = any>(path: string | string[], direction?: 'asc' | 'desc'): (a: T, b: T) => number;
+/**
+ * Build a comparator based on a direct property of the compared objects.
+ *
+ * Falls back to `defaultValue` when the property is `undefined` on an item.
+ *
+ * @typeParam T - Type of compared objects.
+ * @typeParam K - Key of the property in `T`.
+ * @param property - Property name to compare.
+ * @param direction - Sort direction, 'asc' by default.
+ * @param defaultValue - Value used when the property is undefined.
+ * @returns A comparator compatible with `Array.prototype.sort`.
+ */
+export declare function propertyComparator<T = any, K extends keyof T = any>(property: K, direction?: 'asc' | 'desc', defaultValue?: any): (a: T, b: T) => number;
+/**
+ * Build a comparator using multiple property paths as tie-breakers.
+ *
+ * Each key in `keys` is resolved via {@link getPropertyByPath}. The first
+ * non-zero comparison result is returned. If provided, `defaultValues[i]`
+ * is used when a value at `keys[i]` is undefined.
+ *
+ * @typeParam T - Type of compared objects.
+ * @param keys - Ordered list of property paths to compare.
+ * @param direction - Sort direction applied to each key, 'asc' by default.
+ * @param defaultValues - Optional default values, aligned with `keys`.
+ * @throws Error when `keys` is empty or when `defaultValues` length is invalid.
+ * @returns A comparator compatible with `Array.prototype.sort`.
+ */
+export declare function propertiesPathComparator<T = any>(keys: string[], direction?: 'asc' | 'desc', defaultValues?: any[]): (a: T, b: T) => number;
+/**
+ * Compose a comparator from multiple comparators (multi-level sort).
+ *
+ * Each comparator is applied sequentially. The first non-zero result is
+ * returned, allowing you to define primary, secondary, tertiary criteria, etc.
+ * If all comparators return 0, the items are considered equivalent.
+ *
+ * @typeParam T - Type of the compared items.
+ * @param comparators - List of comparator functions to apply in order.
+ * @returns A comparator compatible with `Array.prototype.sort`.
+ */
+export declare function composeComparators<T>(...comparators: Array<(a: T, b: T) => number>): (a: T, b: T) => number;
 export declare function sort<T>(array: T[], attribute?: string, opts?: Intl.CollatorOptions): T[];
 export declare function isInt(value: string): boolean;
 export declare function isNumber(value: string): boolean;

package/src/assets/manifest.json

@@ -2,7 +2,7 @@
   "name": "ngx-sumaris-components",
   "short_name": "ngx-sumaris-components",
   "manifest_version": 1,
-  "version": "18.22.4",
+  "version": "18.22.5",
   "default_locale": "fr",
   "description": "Angular components for building beautiful and responsive Apps",
   "icons": [{