ngx-transforms 0.1.0 → 0.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ngx-transforms",
-  "version": "0.1.0",
-  "description": "A collection of 31+ standalone Angular pipes for text, security, media, data, and array transformations.",
+  "version": "0.3.0",
+  "description": "A collection of 36 standalone Angular pipes for text, security, media, data, and array transformations.",
   "keywords": [
     "angular",
     "pipes",
@@ -20,7 +20,18 @@
     "shuffle",
     "unique",
     "flatten",
-    "time-ago"
+    "time-ago",
+    "diff",
+    "intersection",
+    "union",
+    "every",
+    "some",
+    "filter-by",
+    "group-by",
+    "order-by",
+    "chunk",
+    "pluck",
+    "range"
   ],
   "license": "MIT",
   "author": "Mofiro Jean <mofirojean@gmail.com>",

package/types/ngx-transforms.d.ts

@@ -193,22 +193,6 @@ declare class MorseCodePipe implements PipeTransform {
  * @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>
  */
 declare class ReplacePipe implements PipeTransform {
     private sanitizer;
@@ -639,6 +623,93 @@ declare class TimeAgoPipePipe implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<TimeAgoPipePipe, "timeAgo", true>;
 }
 
+/**
+ * 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
+ */
+declare class DiffPipe implements PipeTransform {
+    transform(value: unknown[], compared: unknown[], key?: string): unknown[];
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DiffPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DiffPipe, "diff", 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?
+ */
+declare class EveryPipe implements PipeTransform {
+    transform(value: unknown[], match: unknown, key?: string): boolean;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EveryPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EveryPipe, "every", 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
+ */
+declare class IntersectionPipe implements PipeTransform {
+    transform(value: unknown[], compared: unknown[], key?: string): unknown[];
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntersectionPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IntersectionPipe, "intersection", 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]]
+ */
+declare class ChunkPipe implements PipeTransform {
+    transform(value: unknown[], size?: number): unknown[][];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChunkPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ChunkPipe, "chunk", true>;
+}
+
 /**
  * FlattenPipe: Flattens nested arrays to a specified depth.
  *
@@ -658,6 +729,25 @@ declare class Flatten implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<Flatten, "flatten", true>;
 }
 
+/**
+ * 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': [...] }
+ */
+declare class GroupByPipe implements PipeTransform {
+    transform(value: unknown[], key: string): Record<string, unknown[]>;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupByPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<GroupByPipe, "groupBy", true>;
+}
+
 /**
  * InitialPipe: Returns all elements except the last n.
  *
@@ -677,6 +767,66 @@ declare class InitialPipe implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<InitialPipe, "initial", true>;
 }
 
+/**
+ * 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
+ */
+declare class OrderByPipe implements PipeTransform {
+    transform(value: unknown[], key: string, direction?: 'asc' | 'desc'): unknown[];
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrderByPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<OrderByPipe, "orderBy", 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']
+ */
+declare class PluckPipe implements PipeTransform {
+    transform(value: unknown[], key: string): unknown[];
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluckPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PluckPipe, "pluck", 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]
+ */
+declare class RangePipe implements PipeTransform {
+    transform(value: number, start?: number, step?: number): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RangePipe, "range", true>;
+}
+
 /**
  * ReversePipe: Reverses the characters in a string.
  *
@@ -805,7 +955,382 @@ declare class UniquePipe implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<UniquePipe, "unique", true>;
 }
 
+/**
+ * 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
+ */
+declare class WithoutPipe implements PipeTransform {
+    transform(value: unknown[], excludes: unknown[], key?: string): unknown[];
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WithoutPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<WithoutPipe, "without", 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?
+ */
+declare class SomePipe implements PipeTransform {
+    transform(value: unknown[], match: unknown, key?: string): boolean;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SomePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SomePipe, "some", 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
+ */
+declare class UnionPipe implements PipeTransform {
+    transform(value: unknown[], other: unknown[], key?: string): unknown[];
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnionPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UnionPipe, "union", 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'
+ */
+declare class FilterByPipe implements PipeTransform {
+    transform(value: unknown[], search: string, key?: string): unknown[];
+    private searchObject;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterByPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FilterByPipe, "filterBy", true>;
+}
+
+/**
+ * MinPipe: Returns the minimum value from an array of numbers or objects.
+ *
+ * Supports primitive number arrays and object arrays by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to evaluate.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
+ *
+ * @returns {number | undefined} - The minimum value, or undefined if the array is empty/invalid.
+ *
+ * @example
+ * {{ [5, 3, 8, 1, 9] | min }}                              // 1
+ * {{ products | min:'price' }}                               // cheapest price
+ * {{ orders | min:'meta.total' }}                            // lowest order total
+ */
+declare class MinPipe implements PipeTransform {
+    transform(value: unknown[], key?: string): number | undefined;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MinPipe, "min", true>;
+}
+
+/**
+ * MaxPipe: Returns the maximum value from an array of numbers or objects.
+ *
+ * Supports primitive number arrays and object arrays by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to evaluate.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
+ *
+ * @returns {number | undefined} - The maximum value, or undefined if the array is empty/invalid.
+ *
+ * @example
+ * {{ [5, 3, 8, 1, 9] | max }}                              // 9
+ * {{ products | max:'price' }}                               // highest price
+ * {{ orders | max:'meta.total' }}                            // largest order total
+ */
+declare class MaxPipe implements PipeTransform {
+    transform(value: unknown[], key?: string): number | undefined;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaxPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MaxPipe, "max", true>;
+}
+
+/**
+ * SumPipe: Returns the sum of all numeric values in an array.
+ *
+ * Supports primitive number arrays and object arrays by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to evaluate.
+ * @param {string} [key] - Optional property path for object summation (supports dot notation).
+ *
+ * @returns {number | undefined} - The total, or undefined if the array is empty/invalid.
+ *
+ * @example
+ * {{ [10, 20, 30] | sum }}                                  // 60
+ * {{ items | sum:'price' }}                                  // total price
+ * {{ orders | sum:'meta.total' }}                            // grand total
+ */
+declare class SumPipe implements PipeTransform {
+    transform(value: unknown[], key?: string): number | undefined;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SumPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SumPipe, "sum", true>;
+}
+
+/**
+ * AveragePipe: Returns the arithmetic mean of all numeric values in an array.
+ *
+ * Supports primitive number arrays and object arrays by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to evaluate.
+ * @param {string} [key] - Optional property path for object averaging (supports dot notation).
+ *
+ * @returns {number | undefined} - The average, or undefined if the array is empty/invalid.
+ *
+ * @example
+ * {{ [10, 20, 30] | average }}                              // 20
+ * {{ students | average:'grade' }}                           // average grade
+ * {{ reviews | average:'meta.rating' }}                      // average rating
+ */
+declare class AveragePipe implements PipeTransform {
+    transform(value: unknown[], key?: string): number | undefined;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AveragePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AveragePipe, "average", true>;
+}
+
+/**
+ * PercentagePipe: Calculates what percentage a value represents of a total.
+ *
+ * Returns `(value / total) * 100`, optionally rounded to a given number of decimal places.
+ *
+ * @param {number} value - The partial value.
+ * @param {number} total - The total/whole value.
+ * @param {number} [decimals] - Optional number of decimal places to round to.
+ *
+ * @returns {number | undefined} - The percentage, or undefined if inputs are invalid.
+ *
+ * @example
+ * {{ 25 | percentage:200 }}                                 // 12.5
+ * {{ 1 | percentage:3:2 }}                                  // 33.33
+ * {{ 750 | percentage:1000 }}                               // 75
+ */
+declare class PercentagePipe implements PipeTransform {
+    transform(value: number, total: number, decimals?: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PercentagePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PercentagePipe, "percentage", true>;
+}
+
+/**
+ * CeilPipe: Rounds a number up to the specified number of decimal places.
+ *
+ * Uses `Math.ceil` — always rounds toward positive infinity.
+ *
+ * @param {number} value - The number to round up.
+ * @param {number} [precision=0] - Number of decimal places to preserve (defaults to 0 = integer).
+ *
+ * @returns {number | undefined} - The rounded-up value, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 4.1 | ceil }}                                           // 5
+ * {{ 4.123 | ceil:2 }}                                       // 4.13
+ * {{ 0.001 | ceil:2 }}                                       // 0.01
+ * {{ -4.9 | ceil }}                                          // -4
+ */
+declare class CeilPipe implements PipeTransform {
+    transform(value: number, precision?: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CeilPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CeilPipe, "ceil", true>;
+}
+
+/**
+ * FloorPipe: Rounds a number down to the specified number of decimal places.
+ *
+ * Uses `Math.floor` — always rounds toward negative infinity.
+ *
+ * @param {number} value - The number to round down.
+ * @param {number} [precision=0] - Number of decimal places to preserve (defaults to 0 = integer).
+ *
+ * @returns {number | undefined} - The rounded-down value, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 4.9 | floor }}                                          // 4
+ * {{ 4.567 | floor:2 }}                                      // 4.56
+ * {{ 0.999 | floor:1 }}                                      // 0.9
+ * {{ -4.1 | floor }}                                         // -5
+ */
+declare class FloorPipe implements PipeTransform {
+    transform(value: number, precision?: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FloorPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FloorPipe, "floor", true>;
+}
+
+/**
+ * RoundPipe: Rounds a number to the nearest value at the specified number of decimal places.
+ *
+ * Uses `Math.round` — rounds half-up (e.g. 2.5 → 3, -2.5 → -2).
+ *
+ * @param {number} value - The number to round.
+ * @param {number} [precision=0] - Number of decimal places to preserve (defaults to 0 = integer).
+ *
+ * @returns {number | undefined} - The rounded value, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 4.4 | round }}                                          // 4
+ * {{ 4.5 | round }}                                          // 5
+ * {{ 4.567 | round:2 }}                                      // 4.57
+ * {{ 0.125 | round:2 }}                                      // 0.13
+ */
+declare class RoundPipe implements PipeTransform {
+    transform(value: number, precision?: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RoundPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RoundPipe, "round", true>;
+}
+
+/**
+ * SqrtPipe: Returns the square root of a number.
+ *
+ * Uses `Math.sqrt`. Returns undefined for negative numbers.
+ *
+ * @param {number} value - The number to compute the square root of.
+ *
+ * @returns {number | undefined} - The square root, or undefined if the input is invalid or negative.
+ *
+ * @example
+ * {{ 9 | sqrt }}                                             // 3
+ * {{ 2 | sqrt }}                                             // 1.4142135623730951
+ * {{ 144 | sqrt }}                                           // 12
+ */
+declare class SqrtPipe implements PipeTransform {
+    transform(value: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SqrtPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SqrtPipe, "sqrt", true>;
+}
+
+/**
+ * PowPipe: Raises a number to the specified power.
+ *
+ * Uses `Math.pow`. The exponent defaults to 2 (squaring).
+ *
+ * @param {number} value - The base number.
+ * @param {number} [exponent=2] - The power to raise the base to (defaults to 2).
+ *
+ * @returns {number | undefined} - The result, or undefined if the inputs are invalid.
+ *
+ * @example
+ * {{ 3 | pow }}                                              // 9  (3^2)
+ * {{ 2 | pow:3 }}                                            // 8  (2^3)
+ * {{ 5 | pow:0 }}                                            // 1  (anything^0)
+ */
+declare class PowPipe implements PipeTransform {
+    transform(value: number, exponent?: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PowPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PowPipe, "pow", true>;
+}
+
+/**
+ * DegreesPipe: Converts a value in radians to degrees.
+ *
+ * Formula: `degrees = radians * (180 / Math.PI)`
+ *
+ * @param {number} value - The angle in radians.
+ *
+ * @returns {number | undefined} - The angle in degrees, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 3.14159 | degrees }}                                    // ~180
+ * {{ 1.5708 | degrees }}                                     // ~90
+ * {{ 0 | degrees }}                                          // 0
+ */
+declare class DegreesPipe implements PipeTransform {
+    transform(value: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DegreesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DegreesPipe, "degrees", true>;
+}
+
+/**
+ * BytesPipe: Formats a number of bytes into a human-readable string with appropriate units.
+ *
+ * Supports both binary (1024-based: KiB, MiB, GiB) and decimal (1000-based: KB, MB, GB) units.
+ * Defaults to decimal (1000-based) units.
+ *
+ * @param {number} value - The number of bytes.
+ * @param {number} [decimals=1] - Number of decimal places in the output.
+ * @param {string} [base='decimal'] - Unit base: 'decimal' (1000, KB/MB/GB) or 'binary' (1024, KiB/MiB/GiB).
+ *
+ * @returns {string | undefined} - The formatted string, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 1536 | bytes }}                                         // "1.5 KB"
+ * {{ 1048576 | bytes:2 }}                                    // "1.05 MB"
+ * {{ 1073741824 | bytes:1:'binary' }}                        // "1.0 GiB"
+ */
+declare class BytesPipe implements PipeTransform {
+    private readonly decimalUnits;
+    private readonly binaryUnits;
+    transform(value: number, decimals?: number, base?: 'decimal' | 'binary'): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BytesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BytesPipe, "bytes", true>;
+}
+
+/**
+ * RadiansPipe: Converts a value in degrees to radians.
+ *
+ * Formula: `radians = degrees * (Math.PI / 180)`
+ *
+ * @param {number} value - The angle in degrees.
+ *
+ * @returns {number | undefined} - The angle in radians, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 180 | radians }}                                        // ~3.14159
+ * {{ 90 | radians }}                                         // ~1.5708
+ * {{ 0 | radians }}                                          // 0
+ */
+declare class RadiansPipe implements PipeTransform {
+    transform(value: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadiansPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RadiansPipe, "radians", true>;
+}
+
 declare const ALL_PIPES: Provider[];
 
-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, AveragePipe, BarcodePipe, BytesPipe, CamelCasePipe, CeilPipe, ChunkPipe, ColorConvertPipe, CountPipe, CreditCardMaskPipe, DegreesPipe, DeviceTypePipe, DiffPipe, EmailMaskPipe, EveryPipe, FilterByPipe, Flatten, FloorPipe, GravatarPipe, GroupByPipe, HighlightPipe, HtmlEscapePipe, HtmlSanitizePipe, InitialPipe, InitialsPipe, IntersectionPipe, IpAddressMaskPipe, JsonPrettyPipe, KebabCasePipe, MaxPipe, MinPipe, MorseCodePipe, OrderByPipe, PercentagePipe, PluckPipe, PowPipe, QrCodePipe, RadiansPipe, RangePipe, ReplacePipe, ReversePipe, RoundPipe, SamplePipe, ShufflePipe, SnakeCasePipe, SomePipe, SqrtPipe, SumPipe, TailPipe, TextToSpeechPipe, TimeAgoPipePipe, TitleCasePipe, TruncatePipe, TruthifyPipe, UnionPipe, UniquePipe, WithoutPipe };
 export type { AsciiArtOptions, BarcodeElementType, BarcodeFormat, BarcodeOptions, ColorTargetType, DeviceType, QrCodeOptions };