@rzl-zone/utils-js 3.1.0-beta.2 → 3.1.2-beta.0

package/README.md

@@ -113,12 +113,12 @@ This package also provides utilities specially built for Next.js environments, n
   #### For now, explore the examples or dive into the source — all utilities are documented via **JSDoc** and typed properly.
   
   ```ts
-  import { | } from "@rzl-zone/utils-js";
+  import { | } from "@rzl-zone/utils-js/ | ";
   import { | } from "@rzl-zone/utils-js\types";
   import { | } from "@rzl-zone/utils-js\next";
   import { | } from "@rzl-zone/utils-js\next\server";
 
-  // Just place your cursor right inside { } like the pipe ("|") above then
+  // Just place your cursor right inside { } and from after `@rzl-zone/utils-js/` like the pipe ("|") above then
   // ctrl + space, there are many functions or types and then hover to each
   // function is complete with how to use it because I have added jsDoc.
   ```

package/dist/NumberRangeUnion-DC-C3_Kq.d.ts

@@ -1,26 +1,26 @@
 type Enumerate<N extends number,Acc extends number[]=[]>=Acc["length"] extends N?Acc[number]:Enumerate<N,[...Acc,Acc["length"]]>;
 /** --------------------------------------------------
-* * ***Generate a union type of numbers from `From` to `To` using enumeration.***
-* --------------------------------------------------
-*
-* @template From - Starting number of the range (inclusive).
-* @template To - Ending number of the range (inclusive).
-*
-* @description
-* Produces a **numeric union type** from `From` to `To` (inclusive),
-* using a simpler approach based on `Enumerate<N>` helper type.
-*
-* - ✅ Straightforward & easy to reason about.
-* - ⚠️ Still limited by TypeScript recursion depth (safe up to `999`).
-* - ⚙️ Best used for **smaller ranges** or when readability matters.
-*
-* @example
-* ```ts
-* type RangeX = NumberRangeUnion<3, 6>;
-* //    ^? 3 | 4 | 5 | 6
-*
-* type RangeY = NumberRangeUnion<0, 2>;
-* //    ^? 0 | 1 | 2
-* ```
-*/
+ * * ***Generate a union type of numbers from `From` to `To` using enumeration.***
+ * --------------------------------------------------
+ *
+ * @template From - Starting number of the range (inclusive).
+ * @template To - Ending number of the range (inclusive).
+ *
+ * @description
+ * Produces a **numeric union type** from `From` to `To` (inclusive),
+ * using a simpler approach based on `Enumerate<N>` helper type.
+ *
+ * - ✅ Straightforward & easy to reason about.
+ * - ⚠️ Still limited by TypeScript recursion depth (safe up to `999`).
+ * - ⚙️ Best used for **smaller ranges** or when readability matters.
+ *
+ * @example
+ * ```ts
+ * type RangeX = NumberRangeUnion<3, 6>;
+ * //    ^? 3 | 4 | 5 | 6
+ *
+ * type RangeY = NumberRangeUnion<0, 2>;
+ * //    ^? 0 | 1 | 2
+ * ```
+ */
 type NumberRangeUnion<From extends number,To extends number>=From extends To?From:Exclude<Enumerate<To>,Enumerate<From>>extends never?never:Exclude<Enumerate<To>,Enumerate<From>>|To;export type{NumberRangeUnion as N};

package/dist/any-BmdI8UbK.d.ts

@@ -1,67 +1,67 @@
 import{I as If}from'./if-CvT4R7Kh.js';
 /** -------------------------------------------------------
-* * ***IsAny.***
-* -------------------------------------------------------
-* A type-level utility that checks whether a type is ***`any`***.
-* - Returns `true` if `T` is `any`.
-* - Returns `false` otherwise.
-*
-* @template T - The type to evaluate.
-* @example
-* ```ts
-* type A = IsAny<any>;     // ➔ true
-* type B = IsAny<string>;  // ➔ false
-* type C = IsAny<unknown>; // ➔ false
-* type D = IsAny<never>;   // ➔ false
-* ```
-*/
+ * * ***IsAny.***
+ * -------------------------------------------------------
+ * A type-level utility that checks whether a type is ***`any`***.
+ * - Returns `true` if `T` is `any`.
+ * - Returns `false` otherwise.
+ *
+ * @template T - The type to evaluate.
+ * @example
+ * ```ts
+ * type A = IsAny<any>;     // ➔ true
+ * type B = IsAny<string>;  // ➔ false
+ * type C = IsAny<unknown>; // ➔ false
+ * type D = IsAny<never>;   // ➔ false
+ * ```
+ */
 type IsAny<T>=0 extends 1 & T?true:false;
 /** -------------------------------------------------------
-* * ***IfAny.***
-* -------------------------------------------------------
-*
-* A type-level conditional utility that returns one type if ***`T` is `any`***,
-* and another type otherwise.
-* - Defaults to `true` when `T` is `any`.
-* - Defaults to `false` otherwise.
-*
-* @template T - The type to check.
-* @template IfTrue - The type to return if `T` is `any`. *(default: `true`)*
-* @template IfFalse - The type to return if `T` is not `any`. *(default: `false`)*
-*
-* @example
-* ```ts
-* type A = IfAny<any, string, number>;
-* // ➔ string
-* type B = IfAny<string, string, number>;
-* // ➔ number
-* ```
-*/
+ * * ***IfAny.***
+ * -------------------------------------------------------
+ *
+ * A type-level conditional utility that returns one type if ***`T` is `any`***,
+ * and another type otherwise.
+ * - Defaults to `true` when `T` is `any`.
+ * - Defaults to `false` otherwise.
+ *
+ * @template T - The type to check.
+ * @template IfTrue - The type to return if `T` is `any`. *(default: `true`)*
+ * @template IfFalse - The type to return if `T` is not `any`. *(default: `false`)*
+ *
+ * @example
+ * ```ts
+ * type A = IfAny<any, string, number>;
+ * // ➔ string
+ * type B = IfAny<string, string, number>;
+ * // ➔ number
+ * ```
+ */
 type IfAny<T,IfTrue=true,IfFalse=false>=If<IsAny<T>,IfTrue,IfFalse>;
 /** Configuration options for a type-level utility `AnifyProperties`. */
 type AnifyPropertiesOptions={
 /** If `makeOptional: true`, all properties become optional, otherwise, all properties are required and typed as `any`, defaultValue: `false`.
-*
-* @default false
-*/
+ *
+ * @default false
+ */
 makeOptional:boolean;};
 /** -------------------------------------------------------
-* * ***AnifyProperties.***
-* -------------------------------------------------------
-*
-* A type-level utility that transforms all properties of an object into ***`any`***.
-* - If `makeOptional: true`, all properties become optional.
-* - Otherwise, all properties are required and typed as `any`.
-*
-* @template T - The object type to transform.
-* @template Options - Configuration options. Defaults to `{ makeOptional: false }`.
-* @example
-* ```ts
-* type A = AnifyProperties<{a: string; b: number}>;
-* // ➔ { a: any; b: any }
-*
-* type B = AnifyProperties<{a: string; b: number}, { makeOptional: true }>;
-* // ➔ { a?: any; b?: any }
-* ```
-*/
+ * * ***AnifyProperties.***
+ * -------------------------------------------------------
+ *
+ * A type-level utility that transforms all properties of an object into ***`any`***.
+ * - If `makeOptional: true`, all properties become optional.
+ * - Otherwise, all properties are required and typed as `any`.
+ *
+ * @template T - The object type to transform.
+ * @template Options - Configuration options. Defaults to `{ makeOptional: false }`.
+ * @example
+ * ```ts
+ * type A = AnifyProperties<{a: string; b: number}>;
+ * // ➔ { a: any; b: any }
+ *
+ * type B = AnifyProperties<{a: string; b: number}, { makeOptional: true }>;
+ * // ➔ { a?: any; b?: any }
+ * ```
+ */
 type AnifyProperties<T extends object,Options extends AnifyPropertiesOptions={makeOptional:false;}>={[K in keyof T]:any;}extends infer Result?If<Options["makeOptional"],Partial<Result>,Result>:never;export type{AnifyProperties as A,IsAny as I,AnifyPropertiesOptions as a,IfAny as b};

package/dist/arrays-normalize-recursive-CnjYJ9xg.d.ts

@@ -1,72 +1,72 @@
 /** -------------------------------------------------------
-* * ***FixNeverArrayRecursive.***
-* -------------------------------------------------------
-* A type-level utility that **recursively transforms arrays of type `never[]` into empty arrays**.
-* - Preserves `readonly` modifiers.
-* - Applies recursively for nested arrays.
-* - Leaves other types unchanged.
-*
-* @template T - The input type to recursively fix.
-* @example
-* ```ts
-* type A = FixNeverArrayRecursive<never[]>;
-* // ➔ []
-* type B = FixNeverArrayRecursive<readonly never[]>;
-* // ➔ readonly []
-* type C = FixNeverArrayRecursive<string[]>;
-* // ➔ string[]
-* type D = FixNeverArrayRecursive<(never | string)[]>;
-* // ➔ (never | string)[]
-* type E = FixNeverArrayRecursive<(never[])[]>;
-* // ➔ [][]
-* ```
-*/
+ * * ***FixNeverArrayRecursive.***
+ * -------------------------------------------------------
+ * A type-level utility that **recursively transforms arrays of type `never[]` into empty arrays**.
+ * - Preserves `readonly` modifiers.
+ * - Applies recursively for nested arrays.
+ * - Leaves other types unchanged.
+ *
+ * @template T - The input type to recursively fix.
+ * @example
+ * ```ts
+ * type A = FixNeverArrayRecursive<never[]>;
+ * // ➔ []
+ * type B = FixNeverArrayRecursive<readonly never[]>;
+ * // ➔ readonly []
+ * type C = FixNeverArrayRecursive<string[]>;
+ * // ➔ string[]
+ * type D = FixNeverArrayRecursive<(never | string)[]>;
+ * // ➔ (never | string)[]
+ * type E = FixNeverArrayRecursive<(never[])[]>;
+ * // ➔ [][]
+ * ```
+ */
 type FixNeverArrayRecursive<T>=T extends readonly never[]?T extends never[]?[]:readonly []:T extends(infer U)[]?FixNeverArrayRecursive<U>[]:T extends readonly(infer U)[]?readonly FixNeverArrayRecursive<U>[]:T;
 /** -------------------------------------------------------
-* * ***NormalizeEmptyArraysRecursive.***
-* -------------------------------------------------------
-* A type-level utility that **recursively normalizes empty array types** by converting arrays whose element type is `never`, `null`, or `undefined` into empty tuple types (`[]`).
-* - Preserves `readonly` modifiers.
-* - Recurses into nested arrays.
-* - Leaves other array types unchanged.
-*
-* @template T - The input type to normalize.
-* @example
-* ```ts
-* type A = NormalizeEmptyArraysRecursive<never[]>;
-* // ➔ []
-* type B = NormalizeEmptyArraysRecursive<readonly never[]>;
-* // ➔ readonly []
-* type C = NormalizeEmptyArraysRecursive<null[]>;
-* // ➔ []
-* type D = NormalizeEmptyArraysRecursive<(null[] | string[])[]>;
-* // ➔ ([] | string[])[]
-* type E = NormalizeEmptyArraysRecursive<string[]>;
-* // ➔ string[]
-* ```
-*/
+ * * ***NormalizeEmptyArraysRecursive.***
+ * -------------------------------------------------------
+ * A type-level utility that **recursively normalizes empty array types** by converting arrays whose element type is `never`, `null`, or `undefined` into empty tuple types (`[]`).
+ * - Preserves `readonly` modifiers.
+ * - Recurses into nested arrays.
+ * - Leaves other array types unchanged.
+ *
+ * @template T - The input type to normalize.
+ * @example
+ * ```ts
+ * type A = NormalizeEmptyArraysRecursive<never[]>;
+ * // ➔ []
+ * type B = NormalizeEmptyArraysRecursive<readonly never[]>;
+ * // ➔ readonly []
+ * type C = NormalizeEmptyArraysRecursive<null[]>;
+ * // ➔ []
+ * type D = NormalizeEmptyArraysRecursive<(null[] | string[])[]>;
+ * // ➔ ([] | string[])[]
+ * type E = NormalizeEmptyArraysRecursive<string[]>;
+ * // ➔ string[]
+ * ```
+ */
 type NormalizeEmptyArraysRecursive<T>=T extends readonly(infer U)[]?U extends never|null|undefined?T extends readonly unknown[]?T extends(infer E)[]?[]:readonly []:never:T extends(infer E)[]?NormalizeEmptyArraysRecursive<U>[]:readonly NormalizeEmptyArraysRecursive<U>[]:T;
 /** -------------------------------------------------------
-* * ***RemoveEmptyArrayElements.***
-* -------------------------------------------------------
-* A type-level utility that **recursively removes empty array elements (`[]`) from a tuple type**.
-* - If `T` is a tuple, checks the first element:
-*    - If `Head` is an empty array type (`[]`), it is removed.
-*    - Otherwise, `Head` is preserved.
-* - Repeats recursively on the rest of the tuple.
-* - Leaves non-tuple types unchanged.
-*
-* @template T - The tuple type to process.
-* @example
-* ```ts
-* type A = RemoveEmptyArrayElements<[[], 1, [], 2]>;
-* // ➔ [1, 2]
-* type B = RemoveEmptyArrayElements<[]>;
-* // ➔ []
-* type C = RemoveEmptyArrayElements<[[], [], []]>;
-* // ➔ []
-* type D = RemoveEmptyArrayElements<[1, 2, 3]>;
-* // ➔ [1, 2, 3]
-* ```
-*/
+ * * ***RemoveEmptyArrayElements.***
+ * -------------------------------------------------------
+ * A type-level utility that **recursively removes empty array elements (`[]`) from a tuple type**.
+ * - If `T` is a tuple, checks the first element:
+ *    - If `Head` is an empty array type (`[]`), it is removed.
+ *    - Otherwise, `Head` is preserved.
+ * - Repeats recursively on the rest of the tuple.
+ * - Leaves non-tuple types unchanged.
+ *
+ * @template T - The tuple type to process.
+ * @example
+ * ```ts
+ * type A = RemoveEmptyArrayElements<[[], 1, [], 2]>;
+ * // ➔ [1, 2]
+ * type B = RemoveEmptyArrayElements<[]>;
+ * // ➔ []
+ * type C = RemoveEmptyArrayElements<[[], [], []]>;
+ * // ➔ []
+ * type D = RemoveEmptyArrayElements<[1, 2, 3]>;
+ * // ➔ [1, 2, 3]
+ * ```
+ */
 type RemoveEmptyArrayElements<T>=T extends [infer Head,...infer Tail]?Head extends []?RemoveEmptyArrayElements<Tail>:[Head,...RemoveEmptyArrayElements<Tail>]:T extends []?[]:T;export type{FixNeverArrayRecursive as F,NormalizeEmptyArraysRecursive as N,RemoveEmptyArrayElements as R};

package/dist/assertions/index.cjs

@@ -1 +1 @@
-'use strict';var chunkDFSTVQFI_cjs=require('../chunk-DFSTVQFI.cjs'),chunkISJ33O2J_cjs=require('../chunk-ISJ33O2J.cjs'),chunkDYRDBYPF_cjs=require('../chunk-DYRDBYPF.cjs');require('../chunk-7YWAQOA4.cjs');var chunkLVUSFXQS_cjs=require('../chunk-LVUSFXQS.cjs');Object.defineProperty(exports,"assertIsBigInt",{enumerable:true,get:function(){return chunkDFSTVQFI_cjs.a}});Object.defineProperty(exports,"assertIsNumber",{enumerable:true,get:function(){return chunkDFSTVQFI_cjs.b}});Object.defineProperty(exports,"assertIsArray",{enumerable:true,get:function(){return chunkISJ33O2J_cjs.a}});Object.defineProperty(exports,"assertIsString",{enumerable:true,get:function(){return chunkDYRDBYPF_cjs.a}});Object.defineProperty(exports,"assertIsBoolean",{enumerable:true,get:function(){return chunkLVUSFXQS_cjs.G}});Object.defineProperty(exports,"assertIsPlainObject",{enumerable:true,get:function(){return chunkLVUSFXQS_cjs.j}});
+'use strict';var chunkIY5OZAB3_cjs=require('../chunk-IY5OZAB3.cjs'),chunkUQDJF5RR_cjs=require('../chunk-UQDJF5RR.cjs'),chunkBEZPD44N_cjs=require('../chunk-BEZPD44N.cjs');require('../chunk-7YWAQOA4.cjs');var chunkCII6WWLO_cjs=require('../chunk-CII6WWLO.cjs');Object.defineProperty(exports,"assertIsBigInt",{enumerable:true,get:function(){return chunkIY5OZAB3_cjs.a}});Object.defineProperty(exports,"assertIsNumber",{enumerable:true,get:function(){return chunkIY5OZAB3_cjs.b}});Object.defineProperty(exports,"assertIsArray",{enumerable:true,get:function(){return chunkUQDJF5RR_cjs.a}});Object.defineProperty(exports,"assertIsString",{enumerable:true,get:function(){return chunkBEZPD44N_cjs.a}});Object.defineProperty(exports,"assertIsBoolean",{enumerable:true,get:function(){return chunkCII6WWLO_cjs.G}});Object.defineProperty(exports,"assertIsPlainObject",{enumerable:true,get:function(){return chunkCII6WWLO_cjs.j}});