ngx-transforms 0.1.0 → 0.2.0

package/fesm2022/ngx-transforms.mjs

@@ -315,22 +315,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImpor
  * @param {boolean} [isReplace=true] - Whether to perform replacement (true) or only highlight matches (false).
  *
  * @returns {string | SafeHtml} - Returns the transformed string or SafeHtml with highlights.
- *
- * @example
- * {{ 'Hello World' | replace:'World':'Universe' }}
- * // Output: Hello Universe
- *
- * {{ 'test123' | replace:/\d+/g:'X':'highlight' }}
- * // Output: test<span class="highlight">X</span>
- *
- * {{ 'Angular is great' | replace:'great':'awesome':'highlight':true }}
- * // Output: Angular is <span class="highlight">awesome</span>
- *
- * {{ 'Angular is great' | replace:'great':'awesome':'highlight':false }}
- * // Output: Angular is <span class="highlight">great</span>
- *
- * <div [innerHTML]="'Angular is great' | replace:'great':'awesome':'highlight':false"></div>
- * // Renders: Angular is <span class="highlight">great</span>
  */
 class ReplacePipe {
     sanitizer = inject(DomSanitizer);
@@ -1204,6 +1188,179 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImpor
                 }]
         }] });
 
+/**
+ * DiffPipe: Returns elements present in the first array but not in the second.
+ *
+ * Supports primitives and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The source array.
+ * @param {unknown[]} compared - The array to compare against.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
+ *
+ * @returns {unknown[]} - Elements in value that are not in compared.
+ *
+ * @example
+ * {{ [1, 2, 3, 4, 5] | diff:[3, 4, 5, 6] }}              // [1, 2]
+ * {{ allUsers | diff:activeUsers:'id' }}                    // inactive users
+ * {{ orders | diff:shipped:'meta.trackingId' }}             // unshipped orders
+ */
+class DiffPipe {
+    transform(value, compared, key) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        if (!Array.isArray(compared) || compared.length === 0) {
+            return [...value];
+        }
+        if (!key) {
+            const comparedSet = new Set(compared);
+            return value.filter(item => !comparedSet.has(item));
+        }
+        const comparedSet = new Set(compared.map(item => this.getNestedValue(item, key)));
+        return value.filter(item => {
+            const val = this.getNestedValue(item, key);
+            return !comparedSet.has(val);
+        });
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: DiffPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: DiffPipe, isStandalone: true, name: "diff" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: DiffPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'diff',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * EveryPipe: Checks if all elements in an array satisfy a condition.
+ *
+ * Supports primitives (equality check) and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to check.
+ * @param {unknown} match - The value to match against.
+ * @param {string} [key] - Optional property path to check (supports dot notation).
+ *
+ * @returns {boolean} - True if all elements match, false otherwise.
+ *
+ * @example
+ * {{ [true, true, true] | every:true }}                     // true
+ * {{ users | every:'active':'status' }}                     // are all users active?
+ * {{ orders | every:'shipped':'meta.state' }}               // are all orders shipped?
+ */
+class EveryPipe {
+    transform(value, match, key) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return false;
+        }
+        if (!key) {
+            return value.every(item => item === match);
+        }
+        return value.every(item => this.getNestedValue(item, key) === match);
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: EveryPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: EveryPipe, isStandalone: true, name: "every" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: EveryPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'every',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * IntersectionPipe: Returns elements common to both arrays.
+ *
+ * Supports primitives and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The first array.
+ * @param {unknown[]} compared - The second array.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
+ *
+ * @returns {unknown[]} - Elements present in both arrays.
+ *
+ * @example
+ * {{ [1, 2, 3, 4] | intersection:[3, 4, 5, 6] }}              // [3, 4]
+ * {{ teamA | intersection:teamB:'id' }}                         // shared members
+ * {{ required | intersection:granted:'meta.scope' }}            // matched permissions
+ */
+class IntersectionPipe {
+    transform(value, compared, key) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        if (!Array.isArray(compared) || compared.length === 0) {
+            return [];
+        }
+        if (!key) {
+            const comparedSet = new Set(compared);
+            return value.filter(item => comparedSet.has(item));
+        }
+        const comparedSet = new Set(compared.map(item => this.getNestedValue(item, key)));
+        return value.filter(item => {
+            const val = this.getNestedValue(item, key);
+            return comparedSet.has(val);
+        });
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IntersectionPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: IntersectionPipe, isStandalone: true, name: "intersection" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: IntersectionPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'intersection',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * ChunkPipe: Splits an array into smaller arrays of a specified size.
+ *
+ * @param {unknown[]} value - The array to split.
+ * @param {number} [size=1] - The size of each chunk.
+ *
+ * @returns {unknown[][]} - An array of chunks.
+ *
+ * @example
+ * {{ [1, 2, 3, 4, 5] | chunk:2 }}     // [[1, 2], [3, 4], [5]]
+ * {{ [1, 2, 3, 4, 5, 6] | chunk:3 }}  // [[1, 2, 3], [4, 5, 6]]
+ */
+class ChunkPipe {
+    transform(value, size = 1) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return [];
+        }
+        if (size <= 0) {
+            return [];
+        }
+        const result = [];
+        for (let i = 0; i < value.length; i += size) {
+            result.push(value.slice(i, i + size));
+        }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: ChunkPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: ChunkPipe, isStandalone: true, name: "chunk" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: ChunkPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'chunk',
+                    standalone: true
+                }]
+        }] });
+
 /**
  * FlattenPipe: Flattens nested arrays to a specified depth.
  *
@@ -1235,6 +1392,46 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImpor
                 }]
         }] });
 
+/**
+ * GroupByPipe: Groups array elements by a property value.
+ *
+ * @param {unknown[]} value - The array to group.
+ * @param {string} key - Property path to group by (supports dot notation).
+ *
+ * @returns {Record<string, unknown[]>} - An object where keys are group names and values are arrays.
+ *
+ * @example
+ * {{ users | groupBy:'role' }}              // { admin: [...], editor: [...] }
+ * {{ orders | groupBy:'customer.city' }}    // { 'New York': [...], 'London': [...] }
+ */
+class GroupByPipe {
+    transform(value, key) {
+        if (!Array.isArray(value) || !key) {
+            return {};
+        }
+        return value.reduce((groups, item) => {
+            const groupKey = String(this.getNestedValue(item, key) ?? 'undefined');
+            if (!groups[groupKey]) {
+                groups[groupKey] = [];
+            }
+            groups[groupKey].push(item);
+            return groups;
+        }, {});
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: GroupByPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: GroupByPipe, isStandalone: true, name: "groupBy" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: GroupByPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'groupBy',
+                    standalone: true,
+                }]
+        }] });
+
 /**
  * InitialPipe: Returns all elements except the last n.
  *
@@ -1272,6 +1469,130 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImpor
                 }]
         }] });
 
+/**
+ * OrderByPipe: Sorts an array by a property value.
+ *
+ * @param {unknown[]} value - The array to sort.
+ * @param {string} key - Property path to sort by (supports dot notation).
+ * @param {string} [direction='asc'] - Sort direction: 'asc' or 'desc'.
+ *
+ * @returns {unknown[]} - A new sorted array.
+ *
+ * @example
+ * {{ users | orderBy:'name' }}            // sorted A-Z
+ * {{ users | orderBy:'name':'desc' }}     // sorted Z-A
+ * {{ users | orderBy:'age':'asc' }}       // sorted by age
+ */
+class OrderByPipe {
+    transform(value, key, direction = 'asc') {
+        if (!Array.isArray(value) || value.length <= 1 || !key) {
+            return Array.isArray(value) ? [...value] : [];
+        }
+        const dir = direction === 'desc' ? -1 : 1;
+        return [...value].sort((a, b) => {
+            const valA = this.getNestedValue(a, key);
+            const valB = this.getNestedValue(b, key);
+            if (valA === valB)
+                return 0;
+            if (valA === null || valA === undefined)
+                return 1;
+            if (valB === null || valB === undefined)
+                return -1;
+            if (typeof valA === 'string' && typeof valB === 'string') {
+                return valA.localeCompare(valB) * dir;
+            }
+            if (typeof valA === 'number' && typeof valB === 'number') {
+                return (valA - valB) * dir;
+            }
+            return String(valA).localeCompare(String(valB)) * dir;
+        });
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: OrderByPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: OrderByPipe, isStandalone: true, name: "orderBy" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: OrderByPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'orderBy',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * PluckPipe: Extracts a property value from every object in an array.
+ *
+ * @param {unknown[]} value - The array of objects.
+ * @param {string} key - Property path to extract (supports dot notation).
+ *
+ * @returns {unknown[]} - An array of the extracted values.
+ *
+ * @example
+ * {{ users | pluck:'name' }}                // ['Alice', 'Bob', 'Carol']
+ * {{ orders | pluck:'customer.email' }}     // ['a@test.com', 'b@test.com']
+ */
+class PluckPipe {
+    transform(value, key) {
+        if (!Array.isArray(value) || !key) {
+            return [];
+        }
+        return value.map(item => this.getNestedValue(item, key));
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: PluckPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: PluckPipe, isStandalone: true, name: "pluck" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: PluckPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'pluck',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * RangePipe: Generates a numeric sequence array.
+ *
+ * @param {number} value - The number of items to generate (or the end value when start is provided).
+ * @param {number} [start=0] - The starting number.
+ * @param {number} [step=1] - The increment between each number.
+ *
+ * @returns {number[]} - An array of sequential numbers.
+ *
+ * @example
+ * {{ 5 | range }}            // [0, 1, 2, 3, 4]
+ * {{ 5 | range:1 }}          // [1, 2, 3, 4, 5]
+ * {{ 10 | range:0:2 }}       // [0, 2, 4, 6, 8]
+ */
+class RangePipe {
+    transform(value, start = 0, step = 1) {
+        if (typeof value !== 'number' || isNaN(value) || value <= 0) {
+            return [];
+        }
+        if (step === 0) {
+            return [];
+        }
+        const result = [];
+        for (let i = 0; i < value; i++) {
+            result.push(start + i * step);
+        }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: RangePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: RangePipe, isStandalone: true, name: "range" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: RangePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'range',
+                    standalone: true,
+                }]
+        }] });
+
 /**
  * ReversePipe: Reverses the characters in a string.
  *
@@ -1512,6 +1833,216 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImpor
                 }]
         }] });
 
+/**
+ * WithoutPipe: Excludes specified elements from an array.
+ *
+ * Supports primitives and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to filter.
+ * @param {unknown[]} excludes - Values to exclude.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
+ *
+ * @returns {unknown[]} - A new array without the excluded elements.
+ *
+ * @example
+ * {{ [1, 2, 3, 4, 5] | without:[2, 4] }}                   // [1, 3, 5]
+ * {{ users | without:['banned']:'status' }}                  // active users
+ * {{ orders | without:['cancelled']:'meta.status' }}         // non-cancelled orders
+ */
+class WithoutPipe {
+    transform(value, excludes, key) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        if (!Array.isArray(excludes) || excludes.length === 0) {
+            return [...value];
+        }
+        const excludeSet = new Set(excludes);
+        if (!key) {
+            return value.filter(item => !excludeSet.has(item));
+        }
+        return value.filter(item => {
+            const val = this.getNestedValue(item, key);
+            return !excludeSet.has(val);
+        });
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: WithoutPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: WithoutPipe, isStandalone: true, name: "without" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: WithoutPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'without',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * SomePipe: Checks if at least one element in an array satisfies a condition.
+ *
+ * Supports primitives (equality check) and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to check.
+ * @param {unknown} match - The value to match against.
+ * @param {string} [key] - Optional property path to check (supports dot notation).
+ *
+ * @returns {boolean} - True if at least one element matches, false otherwise.
+ *
+ * @example
+ * {{ [false, false, true] | some:true }}                    // true
+ * {{ users | some:'admin':'role' }}                          // any admins?
+ * {{ orders | some:'failed':'meta.status' }}                 // any failures?
+ */
+class SomePipe {
+    transform(value, match, key) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return false;
+        }
+        if (!key) {
+            return value.some(item => item === match);
+        }
+        return value.some(item => this.getNestedValue(item, key) === match);
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: SomePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: SomePipe, isStandalone: true, name: "some" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: SomePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'some',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * UnionPipe: Combines two arrays, keeping only unique elements.
+ *
+ * Supports primitives and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The first array.
+ * @param {unknown[]} other - The second array.
+ * @param {string} [key] - Optional property path for uniqueness check (supports dot notation).
+ *
+ * @returns {unknown[]} - A merged array with duplicates removed.
+ *
+ * @example
+ * {{ [1, 2, 3] | union:[3, 4, 5] }}                        // [1, 2, 3, 4, 5]
+ * {{ admins | union:editors:'id' }}                          // all unique users
+ * {{ local | union:remote:'meta.uuid' }}                     // merged records
+ */
+class UnionPipe {
+    transform(value, other, key) {
+        if (!Array.isArray(value) && !Array.isArray(other)) {
+            return [];
+        }
+        const first = Array.isArray(value) ? value : [];
+        const second = Array.isArray(other) ? other : [];
+        if (!key) {
+            const seen = new Set();
+            const result = [];
+            for (const item of [...first, ...second]) {
+                if (!seen.has(item)) {
+                    seen.add(item);
+                    result.push(item);
+                }
+            }
+            return result;
+        }
+        const seen = new Set();
+        const result = [];
+        for (const item of [...first, ...second]) {
+            const val = this.getNestedValue(item, key);
+            if (!seen.has(val)) {
+                seen.add(val);
+                result.push(item);
+            }
+        }
+        return result;
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: UnionPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: UnionPipe, isStandalone: true, name: "union" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: UnionPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'union',
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * FilterByPipe: Filters an array by matching a search term against object
+ properties.
+ *
+ * @param {unknown[]} value - The array to filter.
+ * @param {string} search - The search term.
+ * @param {string} [key] - Property to search in. If omitted, searches all string
+ properties.
+ *
+ * @returns {unknown[]} - Filtered array with matching items.
+ *
+ * @example
+ * {{ users | filterBy:'alice':'name' }}     // users with 'alice' in name
+ * {{ users | filterBy:'admin':'role' }}     // users with role 'admin'
+ * {{ users | filterBy:'bob' }}              // search all properties for 'bob'
+ */
+class FilterByPipe {
+    transform(value, search, key) {
+        if (!Array.isArray(value) || !search) {
+            return Array.isArray(value) ? [...value] : [];
+        }
+        const term = String(search).toLowerCase();
+        if (key) {
+            return value.filter(item => {
+                const val = this.getNestedValue(item, key);
+                return val !== undefined && val !== null
+                    && String(val).toLowerCase().includes(term);
+            });
+        }
+        return value.filter(item => {
+            if (typeof item === 'object' && item !== null) {
+                return this.searchObject(item, term);
+            }
+            return String(item).toLowerCase().includes(term);
+        });
+    }
+    searchObject(obj, term) {
+        return Object.values(obj).some(val => {
+            if (typeof val === 'string') {
+                return val.toLowerCase().includes(term);
+            }
+            if (typeof val === 'number' || typeof val === 'boolean') {
+                return String(val).toLowerCase().includes(term);
+            }
+            if (typeof val === 'object' && val !== null) {
+                return this.searchObject(val, term);
+            }
+            return false;
+        });
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, segment) => current?.[segment], obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: FilterByPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.3", ngImport: i0, type: FilterByPipe, isStandalone: true, name: "filterBy" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: FilterByPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'filterBy',
+                    standalone: true,
+                }]
+        }] });
+
 // Text
 const ALL_PIPES = [
     // Text
@@ -1543,14 +2074,26 @@ const ALL_PIPES = [
     TextToSpeechPipe,
     TimeAgoPipePipe,
     // Array
+    ChunkPipe,
+    DiffPipe,
+    EveryPipe,
+    IntersectionPipe,
     Flatten,
+    GroupByPipe,
     InitialPipe,
+    OrderByPipe,
+    PluckPipe,
+    RangePipe,
     ReversePipe,
     SamplePipe,
     ShufflePipe,
     TailPipe,
     TruthifyPipe,
     UniquePipe,
+    WithoutPipe,
+    SomePipe,
+    UnionPipe,
+    FilterByPipe
 ];
 
 // Text
@@ -1559,5 +2102,5 @@ const ALL_PIPES = [
  * Generated bundle index. Do not edit.
  */
 
-export { ALL_PIPES, AsciiArtPipe, BarcodePipe, CamelCasePipe, ColorConvertPipe, CountPipe, CreditCardMaskPipe, DeviceTypePipe, EmailMaskPipe, Flatten, GravatarPipe, HighlightPipe, HtmlEscapePipe, HtmlSanitizePipe, InitialPipe, InitialsPipe, IpAddressMaskPipe, JsonPrettyPipe, KebabCasePipe, MorseCodePipe, QrCodePipe, ReplacePipe, ReversePipe, SamplePipe, ShufflePipe, SnakeCasePipe, TailPipe, TextToSpeechPipe, TimeAgoPipePipe, TitleCasePipe, TruncatePipe, TruthifyPipe, UniquePipe };
+export { ALL_PIPES, AsciiArtPipe, BarcodePipe, CamelCasePipe, ChunkPipe, ColorConvertPipe, CountPipe, CreditCardMaskPipe, DeviceTypePipe, DiffPipe, EmailMaskPipe, EveryPipe, FilterByPipe, Flatten, GravatarPipe, GroupByPipe, HighlightPipe, HtmlEscapePipe, HtmlSanitizePipe, InitialPipe, InitialsPipe, IntersectionPipe, IpAddressMaskPipe, JsonPrettyPipe, KebabCasePipe, MorseCodePipe, OrderByPipe, PluckPipe, QrCodePipe, RangePipe, ReplacePipe, ReversePipe, SamplePipe, ShufflePipe, SnakeCasePipe, SomePipe, TailPipe, TextToSpeechPipe, TimeAgoPipePipe, TitleCasePipe, TruncatePipe, TruthifyPipe, UnionPipe, UniquePipe, WithoutPipe };
 //# sourceMappingURL=ngx-transforms.mjs.map