@rzl-zone/utils-js 3.3.1 → 3.4.0

package/dist/never-D89PbPh5.d.ts

@@ -1,66 +0,0 @@
-import{I as If}from'./if-ChM35c_q.js';
-/** -------------------------------------------------------
- * * ***Utility Type: `IsNever`.***
- * -------------------------------------------------------
- * ****Conditional**: returns `true` if `T` is `never`, otherwise `false`.**
- * @template T - Type to check.
- * @example
- * ```ts
- * type A = IsNever<never>; // ➔ true
- * type B = IsNever<true>;  // ➔ false
- * ```
- */
-type IsNever<T>=[T] extends [never]?true:false;
-/** -------------------------------------------------------
- * * ***Utility Type: `IfNever`.***
- * -------------------------------------------------------
- * ****Conditional**: Selects one of two branches depending on whether `T` is `never`.**
- * - Defaults: `IfTrue = true`, `IfFalse = false`.
- * @template T - Type to check.
- * @template IfTrue - The branch type if `T` is `never`, (default: `true`).
- * @template IfFalse - The branch type if `T` is not `never`, (default: `false`).
- * @example
- * ```ts
- * type A = IfNever<never>;
- * // ➔ true
- * type B = IfNever<string>;
- * // ➔ false
- * type C = IfNever<never, 'valid', 'no'>;
- * // ➔ 'valid'
- * type D = IfNever<string, 'valid', 'no'>;
- * // ➔ 'no'
- * ```
- */
-type IfNever<T,IfTrue=true,IfFalse=false>=If<IsNever<T>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
- * * ***Utility Type: `NeverifyPropertiesOptions`.***
- * -------------------------------------------------------
- * **Configuration options for the ***{@link NeverifyProperties | `NeverifyProperties`}*** type utility.**
- * @example
- * ```ts
- * type Opt1 = NeverifyPropertiesOptions;
- * // ➔ { makeOptional: boolean }
- * ```
- */
-type NeverifyPropertiesOptions={
-/** * ***Whether to make all properties optional, defaultValue: `false`.***
- *
- * @default false
- */
-makeOptional:boolean;};
-/** -------------------------------------------------------
- * * ***Utility Type: `NeverifyProperties`.***
- * -------------------------------------------------------
- * **Turns all properties of an object to type `never`.**
- * - If `Options["makeOptional"]` is `true`, properties will be optional.
- * @template T - Object type to transform.
- * @template Options - Configuration options (default: `{ makeOptional: false }`).
- * @example
- * ```ts
- * type A = NeverifyProperties<{ a: string; b: string }>;
- * // ➔ { a: never; b: never }
- * type B = NeverifyProperties<{ a: string; b: string }, { makeOptional: true }>;
- * // ➔ { a?: never; b?: never }
- * ```
- */
-type NeverifyProperties<T extends object,Options extends NeverifyPropertiesOptions={makeOptional:false;}>={[K in keyof T]:never;}extends infer Result?If<Options["makeOptional"],Partial<Result>,Result>:never;export type{IsNever as I,NeverifyProperties as N,IfNever as a,NeverifyPropertiesOptions as b};

package/dist/nils-CO8zLHSB.d.ts

@@ -1,151 +0,0 @@
-/** --------------------------------------------------
- * * ***Utility Type: `Nullish`.***
- * --------------------------------------------------
- * **Useful as a shorthand when working with optional or missing values.**
- * - **Represents all values considered **`nullish`**:**
- *    - `null`
- *    - `undefined`
- */
-type Nullish=null|undefined;
-/** --------------------------------------------------
- * * ***Utility Type: `Nullable`.***
- * --------------------------------------------------
- * **Represents a type that can be either `T` or `null`.**
- * @template T - The base type.
- * @example
- * ```ts
- * type A = Nullable<string>; // ➔ string | null
- * ```
- */
-type Nullable<T>=T|null;
-/** --------------------------------------------------
- * * ***Utility Type: `Nilable`.***
- * --------------------------------------------------
- * **Represents a type that can be either `T`, `null`, or `undefined`.**
- * @template T - The base type.
- * @example
- * ```ts
- * type A = Nilable<number>; // ➔ number | null | undefined
- * ```
- */
-type Nilable<T>=T|null|undefined;
-/** --------------------------------------------------
- * * ***Utility Type: `Undefinedable`.***
- * --------------------------------------------------
- * **Represents a type that can be either `T` or `undefined`.**
- * @template T - The base type.
- * @example
- * ```ts
- * type A = Undefinedable<boolean>; // ➔ boolean | undefined
- * ```
- */
-type Undefinedable<T>=T|undefined;
-/** -------------------------------------------------------
- * * ***Utility Type: `NonNil`.***
- * -------------------------------------------------------
- * **Removes both `null` and `undefined` from the given type `T`.**
- * @template T - The type to filter.
- * @example
- * ```ts
- * type A = NonNil<string | null | undefined>;
- * // ➔ string
- * type B = NonNil<number | null>;
- * // ➔ number
- * type C = NonNil<undefined | null>;
- * // ➔ never
- * type D = NonNil<boolean | undefined>;
- * // ➔ boolean
- * ```
- */
-type NonNil<T>=T extends null|undefined?never:T;
-/** -------------------------------------------------------
- * * ***Utility Type: `NonNull`.***
- * -------------------------------------------------------
- * **Removes `null` from the given type `T`.**
- * @template T - The type to filter.
- * @example
- * ```ts
- * type A = NonNull<string | null>;
- * // ➔ string
- * type B = NonNull<number | null | undefined>;
- * // ➔ number | undefined
- * type C = NonNull<null>;
- * // ➔ never
- * ```
- */
-type NonNull<T>=T extends null?never:T;
-/** -------------------------------------------------------
- * * ***Utility Type: `NonUndefined`.***
- * -------------------------------------------------------
- * **Remove `undefined` from the given type `T`.**
- * @template T - The type to filter.
- * @example
- * ```ts
- * type A = NonUndefined<string | undefined>;
- * // ➔ string
- * type B = NonUndefined<number | null | undefined>;
- * // ➔ number | null
- * type C = NonUndefined<undefined>;
- * // ➔ never
- * ```
- */
-type NonUndefined<T>=T extends undefined?never:T;
-/** --------------------------------------------------
- * * ***Utility Type: `KeepNil`.***
- * --------------------------------------------------
- * **Keeps `null` and/or `undefined` in the output type **only if** they
- * exist in the input type `T`, otherwise, resolves to `never`.**
- * @template T - Input type to check for `null` and `undefined`.
- * @example
- * ```ts
- * type A = KeepNil<string | null>;
- * // ➔ null
- * type B = KeepNil<number | undefined>;
- * // ➔ undefined
- * type C = KeepNil<string | null | undefined>;
- * // ➔ null | undefined
- * type D = KeepNil<boolean>;
- * // ➔ never
- * ```
- */
-type KeepNil<T>=(null extends T?null:never)|(undefined extends T?undefined:never);
-/** --------------------------------------------------
- * * ***Utility Type: `KeepNull`.***
- * --------------------------------------------------
- * **Keeps `null` in the output type **only if** the input type `T` includes `null`, otherwise resolves to `never`.**
- * @template T - Input type to check for `null`.
- * @example
- * ```ts
- * type A = KeepNull<string | null>; // ➔ null
- * type B = KeepNull<string>;        // ➔ never
- * ```
- */
-type KeepNull<T>=null extends T?null:never;
-/** --------------------------------------------------
- * * ***Utility Type: `KeepUndef`.***
- * --------------------------------------------------
- * **Keeps `undefined` in the output type **only if** the input type `T` includes `undefined`, otherwise resolves to `never`.**
- * @template T - Input type to check for `undefined`.
- * @example
- * ```ts
- * type A = KeepUndef<number | undefined>; // ➔ undefined
- * type B = KeepUndef<number>;             // ➔ never
- * ```
- */
-type KeepUndef<T>=undefined extends T?undefined:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `NullToUndefined`.***
- * -------------------------------------------------------
- * **Transforms `null` or `undefined` types into `undefined`, otherwise, returns
- * the original type `T` unchanged.**
- * @template T - The input type to transform.
- * @example
- * ```ts
- * type A = NullToUndefined<null>;      // ➔ undefined
- * type B = NullToUndefined<undefined>; // ➔ undefined
- * type C = NullToUndefined<string>;    // ➔ string
- * type D = NullToUndefined<null[]>;    // ➔ null[]
- * type E = NullToUndefined<(string | null)[]>; // ➔ (string | null)[]
- * ```
- */
-type NullToUndefined<T>=T extends null?undefined:T extends undefined?undefined:T;export type{KeepNil as K,NonUndefined as N,Undefinedable as U,KeepNull as a,KeepUndef as b,Nilable as c,NonNil as d,NonNull as e,Nullable as f,NullToUndefined as g,Nullish as h};

package/dist/or-C6qzKt2I.d.ts

@@ -1,82 +0,0 @@
-import{E as Extends,I as IfExtends}from'./extends-DtdRjDyU.js';
-/** -------------------------------------------------------
- * * ***Utility Type: `And`.***
- * -------------------------------------------------------
- * **Performs a **logical AND** operation between two boolean types.**
- * - **Behavior:**
- *    - Returns `true` if **both** conditions extend `true`.
- *    - Returns `false` for otherwise.
- * @template Condition1 - The first condition.
- * @template Condition2 - The second condition.
- * @example
- * ```ts
- * type Case1 = And<true, true>;
- * // ➔ true
- * type Case2 = And<false, true>;
- * // ➔ false
- * type Case3 = And<true, false>;
- * // ➔ false
- * type Case4 = And<false, false>;
- * // ➔ false
- * ```
- */
-type And<Condition1,Condition2>=IfExtends<Condition1,true,Extends<Condition2,true>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `AndArr`.***
- * -------------------------------------------------------
- * **Performs a **logical AND** operation across all elements in an array of
- * boolean types.**
- * - **Behavior:**
- *    - Returns `true` if **all elements** extend `true`.
- *    - Returns `false` if **any element** is not `true`.
- * @template Conditions - A readonly array of boolean conditions.
- * @example
- * ```ts
- * type Case1 = AndArr<[true, true, true]>;
- * // ➔ true
- * type Case2 = AndArr<[true, true, false]>;
- * // ➔ false
- * type Case3 = AndArr<[false, false, false]>;
- * // ➔ false
- * type Case4 = AndArr<[]>;
- * // ➔ false
- * ```
- */
-type AndArr<Conditions extends readonly unknown[]>=Extends<[],Conditions>extends true?false:Extends<Conditions[number],true>;
-/** -------------------------------------------------------
- * * ***Utility Type: `Or`.***
- * -------------------------------------------------------
- * **Computes the logical OR of two type-level boolean conditions.**
- * @template Condition1 - First boolean condition.
- * @template Condition2 - Second boolean condition.
- * @example
- * ```ts
- * type Case1 = Or<true, true>;   // ➔ true
- * type Case2 = Or<false, true>;  // ➔ true
- * type Case3 = Or<false, false>; // ➔ false
- * type Case4 = Or<true, false>;  // ➔ true
- * ```
- * @remarks
- * - Uses {@link IfExtends | **`IfExtends`**} to determine if either condition is `true`.
- * - Returns `true` if at least one of the two conditions is `true`.
- * - Returns `false` only if both are `false`.
- */
-type Or<Condition1,Condition2>=IfExtends<Condition1,true,true,IfExtends<Condition2,true>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `OrArr`.***
- * -------------------------------------------------------
- * **Computes the logical OR of all elements inside a tuple or array of boolean types.**
- * @template Conditions - An array of boolean type elements.
- * @example
- * ```ts
- * type Case1 = OrArr<[true, true, true]>;    // ➔ true
- * type Case2 = OrArr<[true, true, false]>;   // ➔ true
- * type Case3 = OrArr<[false, false, false]>; // ➔ false
- * type Case4 = OrArr<[]>;                    // ➔ false
- * ```
- * @remarks
- * - Uses TypeScript's indexed access types and conditional type inference.
- * - Returns `true` if at least one element in the array is `true`.
- * - Returns `false` if all elements are `false` or array is empty.
- */
-type OrArr<Conditions extends readonly unknown[]>=true extends Conditions[number]?true:false;export type{And as A,OrArr as O,AndArr as a,Or as b};

package/dist/override-CL2olHE5.d.ts

@@ -1,59 +0,0 @@
-import{P as Prettify}from'./prettify-3o8_Kw6b.js';
-/** --------------------------------------------------
- * * ***Utility Type: `ExtractStrict`.***
- * --------------------------------------------------
- * **Performs a stricter version of the built-in `Extract<T, U>`
- * with improved type narrowing.**
- * - ✅ Especially useful in generic utilities where the
- *    standard `Extract` can widen or collapse unions.
- * @template T - The full union or set of types.
- * @template U - The type(s) to be kept from `T`.
- * @example
- * ```ts
- * type A = 'a' | 'b' | 'c';
- * type B = ExtractStrict<A, 'b' | 'c'>;
- * // ➔ 'b' | 'c'
- * ```
- */
-type ExtractStrict<T,U extends T>=T extends unknown?0 extends(U extends T?([T] extends [U]?0:never):never)?T:never:never;
-/** --------------------------------------------------
- * * ***Utility Type: `OmitStrict`.***
- * --------------------------------------------------
- * **Strictly omits keys `K` from type `T`, with optional flattening for readability using `Prettify`.**
- * - **Behavior:**
- *    - ✅ Enhances autocomplete and type inspection clarity in editors.
- *    - ✅ Optionally flattens nested intersections or mapped types into a cleaner shape.
- * @template T - The original object type.
- * @template K - The keys to omit from `T`.
- * @template WithPrettify - Whether to prettify the result (default is `true`).
- * @template WithPrettifyRecursive - Whether to prettify nested object properties recursively (default is `true`).
- * @example
- * ```ts
- * type A = { a: number; b: string; c: boolean };
- * type B = OmitStrict<A, 'b'>;
- * // ➔ { a: number; c: boolean }
- *
- * type C = OmitStrict<A, 'b', false>;
- * // ➔ Omit without prettifying, keeps intersection structure
- *
- * type D = OmitStrict<A, 'b', true, false>;
- * // ➔ Prettifies only top level, does not recurse into nested objects
- * ```
- */
-type OmitStrict<T,K extends keyof T,WithPrettify extends boolean=true,WithPrettifyRecursive extends boolean=true>=WithPrettify extends true?Prettify<Omit<T,K>,{recursive:WithPrettifyRecursive extends boolean?WithPrettifyRecursive:false;}>:WithPrettify extends false?Omit<T,K>:never;
-/** --------------------------------------------------
- * * ***Utility Type: `OverrideTypes`.***
- * --------------------------------------------------
- * **Overrides properties in type `T` with properties from type `U`, based on matching keys.**
- * - ✅ Ensures the result retains all properties from `T`, but values from `U` override corresponding keys.
- * @template T - The base object type to override.
- * @template U - The object type containing overriding properties.
- * @example
- * ```ts
- * type A = { a: number; b: string };
- * type B = { b: boolean };
- * type C = OverrideTypes<A, B>;
- * // ➔ { a: number; b: boolean }
- * ```
- */
-type OverrideTypes<T,U extends Partial<Record<keyof T,unknown>>>=OmitStrict<T,Extract<keyof U,keyof T>>& U extends infer U?{[K in keyof U]:U[K];}:never;export type{ExtractStrict as E,OmitStrict as O,OverrideTypes as a};

package/dist/pick-BSMX6Xe2.d.ts

@@ -1,15 +0,0 @@
-/** --------------------------------------------------
- * * ***Utility Type: `PickStrict`.***
- * --------------------------------------------------
- * **Utility type that behaves exactly like the native `Pick<T, K>`,
- * but can help with type inference and IDE autocomplete in stricter scenarios.**
- * @template T - The base object type.
- * @template K - The keys from `T` to be picked.
- * @example
- * ```ts
- * type A = { a: number; b: string; c: boolean };
- * type B = PickStrict<A, 'a' | 'c'>;
- * // ➔ { a: number; c: boolean }
- * ```
- */
-type PickStrict<T,K extends keyof T>=Pick<T,K>;export type{PickStrict as P};