@rzl-zone/utils-js 3.3.0 → 3.4.0

package/dist/prettify-3o8_Kw6b.d.ts

@@ -1,564 +0,0 @@
-import{I as If}from'./if-ChM35c_q.js';import{I as IsNever}from'./never-D89PbPh5.js';
-/** --------------------------------------------------
- * * ***Utility Type: `AnyFunction`.***
- * --------------------------------------------------
- * **A generic type representing **any function** with
- * any arguments and any return type.**
- * @example
- * const fn: AnyFunction = (a, b) => a + b;
- * console.log(fn(1, 2)); // ➔ 3
- *
- * const fn2: AnyFunction = (x, y, z) => x + y - z;
- * console.log(fn2(10, 20, 5)); // ➔ 25
- */
-type AnyFunction=(...args:any[])=>any;
-/** --------------------------------------------------
- * * ***Utility Type: `NodeBuiltins`.***
- * --------------------------------------------------
- * **Represents Node.js built-in core objects.**
- * @description
- * Includes commonly used Node.js core classes/objects that are not plain objects.
- * - **Examples:**
- *    - `Buffer`.
- *    - `EventEmitter`.
- *    - `Stream`.
- *    - `URL`.
- *    - `process`.
- * - ❌ Excludes plain objects (`{}`) and primitives.
- * - ⚠️ Note:
- *    - This is **not exhaustive** because Node.js has
- *      many built-in modules, but it covers the main
- *      runtime objects often encountered.
- */
-type NodeBuiltins=Buffer|NodeJS.EventEmitter|NodeJS.ReadableStream|NodeJS.WritableStream|NodeJS.Process|URL;
-/** --------------------------------------------------
- * * ***Utility Type: `DataTypes`.***
- * --------------------------------------------------
- * **Represents a broad union of commonly used JavaScript data types.**
- * - ✅ ***Includes:***
- *    - `Primitive-Types`.
- *    - `object`.
- *    - `null`.
- *    - `undefined`.
- *    - `symbol`.
- *    - `Any-Function` signature.
- * @example
- * ```ts
- * function isValidType(value: DataTypes): boolean {
- *   return value !== undefined && value !== null;
- * }
- * ```
- */
-type DataTypes=bigint|boolean|AnyFunction|null|number|object|string|symbol|undefined;
-/** --------------------------------------------------
- * * ***Utility Type: `DeepReplaceType`.***
- * --------------------------------------------------
- * **Recursively traverses an array, tuple, or object (including nested structures)
- * and replaces all values of type `Target` with `NewType`.**
- * - ✅ Useful for remapping deeply nested arrays, tuples, or records.
- * @template Arr - The input array, tuple, or object.
- * @template Target - The type to match and replace.
- * @template NewType - The new type to assign to matched values.
- * @example
- * ```ts
- * // Simple tuple
- * type A = [number, string, [number]];
- * type B = DeepReplaceType<A, number, boolean>;
- * // ➔ [boolean, string, [boolean]]
- *
- * // Nested object
- * type Obj = { a: number; b: { c: number; d: string } };
- * type ObjReplaced = DeepReplaceType<Obj, number, boolean>;
- * // ➔ { a: boolean; b: { c: boolean; d: string } }
- *
- * // Mixed array and object
- * type Mixed = [{ x: number }, { y: string, z: number[] }];
- * type MixedReplaced = DeepReplaceType<Mixed, number, boolean>;
- * // ➔ [{ x: boolean }, { y: string, z: boolean[] }]
- * ```
- */
-type DeepReplaceType<Arr,Target,NewType>=Arr extends Target?NewType:Arr extends object?{[K in keyof Arr]:DeepReplaceType<Arr[K],Target,NewType>;}:Arr;
-/** --------------------------------------------------
- * * ***Utility Type: `TypedArray`.***
- * --------------------------------------------------
- * **Represents all JavaScript **TypedArray** types used for binary data manipulation.**
- * - ✅ ***Includes:***
- *    - `Int8Array`.
- *    - `Uint8Array`.
- *    - `Uint8ClampedArray`.
- *    - `Int16Array`.
- *    - `Uint16Array`.
- *    - `Int32Array`.
- *    - `Uint32Array`.
- *    - `Float32Array`.
- *    - `Float64Array`.
- *    - `BigInt64Array`.
- *    - `BigUint64Array`.
- */
-type TypedArray=Int8Array|Uint8Array|Uint8ClampedArray|Int16Array|Uint16Array|Int32Array|Uint32Array|Float32Array|Float64Array|BigInt64Array|BigUint64Array;
-/** --------------------------------------------------
- * * ***Utility Type: `WebApiObjects`.***
- * --------------------------------------------------
- * **Represents common **Web API objects** available in the browser.**
- * - ✅ ***Includes:***
- *    - URL: `URL`, `URLSearchParams`.
- *    - Networking: `Request`, `Response`, `Headers`, `WebSocket`.
- *    - Streams: `ReadableStream`, `WritableStream`, `TransformStream`.
- *    - Events: `Event`, `CustomEvent`, `MessageChannel`, `MessagePort`, `MessageEvent`.
- *    - DOM: `HTMLElement`, `Node`, `Document`, `Window`, `CanvasRenderingContext2D`.
- *    - Encoding: `TextEncoder`, `TextDecoder`.
- *    - File: `File`, `FileList`, `ImageBitmap`, `FormData`.
- *    - Abort: `AbortController`, `AbortSignal`.
- *    - Crypto: `CryptoKey`.
- */
-type WebApiObjects=URL|URLSearchParams|FormData|Headers|Response|Request|ReadableStream<any>|WritableStream<any>|TransformStream<any,any>|MessageChannel|MessagePort|MessageEvent|Event|CustomEvent|HTMLElement|Node|Document|Window|AbortController|AbortSignal|TextEncoder|TextDecoder|CryptoKey|File|FileList|ImageBitmap|CanvasRenderingContext2D|WebSocket;
-/** --------------------------------------------------
- * * ***Utility Type: `IntlObjects`.***
- * --------------------------------------------------
- * **Represents all **ECMAScript Internationalization API** objects from `Intl`.**
- * - ✅ ***Includes:***
- *    - `Intl.Collator`.
- *    - `Intl.DateTimeFormat`.
- *    - `Intl.NumberFormat`.
- *    - `Intl.RelativeTimeFormat`.
- *    - `Intl.PluralRules`.
- *    - `Intl.ListFormat`.
- *    - `Intl.Locale`.
- */
-type IntlObjects=Intl.Collator|Intl.DateTimeFormat|Intl.NumberFormat|Intl.RelativeTimeFormat|Intl.PluralRules|Intl.ListFormat|Intl.Locale;
-/** --------------------------------------------------
- * * ***Utility Type: `BoxedPrimitivesTypes`.***
- * --------------------------------------------------
- * **Represents JavaScript **boxed primitive objects** (object wrappers for primitive values).**
- * @description
- * Boxed primitives are created using the `new` keyword on primitive wrapper constructors.
- * - ✅ ***Includes (object wrappers):***
- *    - `new Number(123)` ➔ `Number`.
- *    - `new String("hello")` ➔ `String`.
- *    - `new Boolean(true)` ➔ `Boolean`.
- * - ❌ ***Excludes (primitive values):***
- *    - `123` ➔ `number`.
- *    - `"hello"` ➔ `string`.
- *    - `true` ➔ `boolean`.
- * - ℹ️ ***Note:***
- *    - These are **rarely used directly** in modern **JavaScript/TypeScript**.
- *    - However, they exist for completeness and are sometimes relevant
- *      when distinguishing between **primitive values** and **object wrappers**.
- * @example
- * ```ts
- * const a: BoxedPrimitivesTypes = new Number(123);
- * // ➔ ✅ valid
- * const b: BoxedPrimitivesTypes = new String("abc");
- * // ➔ ✅ valid
- * const c: BoxedPrimitivesTypes = new Boolean(false);
- * // ➔ ✅ valid
- *
- * // ❌ Not allowed (primitive values):
- * const x: BoxedPrimitivesTypes = 123;
- * const y: BoxedPrimitivesTypes = "abc";
- * const z: BoxedPrimitivesTypes = true;
- * ```
- */
-type BoxedPrimitivesTypes=Number|String|Boolean;
-/** --------------------------------------------------
- * * ***Utility Type: `NonPlainObject`.***
- * --------------------------------------------------
- * **Represents all known **non-plain object types**,
- * i.e., values that are **not** considered a `"plain object"` (`{ [key: string]: any }`).**
- * - ✅ ***Includes:***
- *    - **Functions**.
- *    - **Arrays**.
- *    - **Native objects:** `Date`, `RegExp`, `Map`, `Set`, `WeakMap`, `WeakSet`.
- *    - **Built-in classes & APIs:** `Promise`, `Error`, `ArrayBuffer`, `DataView`.
- *    - **Typed arrays:** `TypedArray`.
- *    - **Browser & Node APIs:** `WebApiObjects`, `IntlObjects`, `NodeBuiltins`.
- *    - **Symbols**.
- *    - **Proxies** (wrapping any object).
- *    - The global **`Reflect`** object.
- * - ❌ ***Excludes:***
- *    - Plain objects (`{ foo: string }`, `Record<string, any>`), `null` and `undefined`.
- * - ℹ️ ***Note:***
- *    - Use this type when you need to differentiate **plain objects** from **all other object-like values**.
- * @example
- * ```ts
- * type A = NonPlainObject;
- *
- * const x: A = new Date();
- * // ➔ ✅ Allowed
- * const y: A = [1, 2, 3];
- * // ➔ ✅ Allowed
- * const z: A = Promise.resolve(123);
- * // ➔ ✅ Allowed
- *
- * // ❌ Not allowed (plain object):
- * // const bad: A = { foo: "bar" };
- * ```
- */
-type NonPlainObject=BoxedPrimitivesTypes|AnyFunction|Promise<any>|Array<any>|AnObjectNonArray;
-/** --------------------------------------------------
- * * ***Utility Type: `AnObjectNonArray`.***
- * --------------------------------------------------
- * **Represents all **non-null, non-array, object-like values** in JavaScript/Node.js.**
- * - ✅ ***Includes:***
- *    - **Built-in objects:** `Date`, `RegExp`, `Error`, `ArrayBuffer`, `DataView`.
- *    - **Collections:** `Map`, `Set`, `WeakMap`, `WeakSet`.
- *    - **Typed arrays:**
- *      `Int8Array`, `Uint8Array`, `Uint8ClampedArray`,
- *      `Int16Array`, `Uint16Array`,
- *      `Int32Array`, `Uint32Array`,
- *      `Float32Array`, `Float64Array`,
- *      `BigInt64Array`, `BigUint64Array`.
- *    - **Browser Web APIs:**
- *      `URL`, `URLSearchParams`, `FormData`, `Headers`, `Response`, `Request`,
- *      `ReadableStream`, `WritableStream`, `TransformStream`,
- *      `MessageChannel`, `MessagePort`, `MessageEvent`,
- *      `Event`, `CustomEvent`, `HTMLElement`, `Node`, `Document`, `Window`,
- *      `CanvasRenderingContext2D`,
- *      `AbortController`, `AbortSignal`,
- *      `TextEncoder`, `TextDecoder`,
- *      `CryptoKey`, `File`, `FileList`, `ImageBitmap`, `WebSocket`.
- *    - **ECMAScript Internationalization API objects:**
- *      `Intl.Collator`, `Intl.DateTimeFormat`, `Intl.NumberFormat`,
- *      `Intl.RelativeTimeFormat`, `Intl.PluralRules`,
- *      `Intl.ListFormat`, `Intl.Locale`.
- *    - **Node.js built-ins:** `Buffer`.
- *    - **Symbols**.
- *    - **Proxies** (wrapping any object).
- *    - The global **`Reflect`** object.
- * - ❌ ***Excludes:***
- *    - `null`.
- *    - Arrays (`[]`, `new Array()`).
- * - ℹ️ ***Note:***
- *    - Use this type when you need to represent **any object-like value except arrays and `null`**.
- * @example
- * ```ts
- * const a: AnObjectNonArray = new Date();
- * const b: AnObjectNonArray = new Map();
- * const c: AnObjectNonArray = Symbol("id");
- *
- * // ❌ These are NOT allowed:
- * // const x: AnObjectNonArray = null;
- * // const y: AnObjectNonArray = [];
- * ```
- */
-type AnObjectNonArray=Date|RegExp|Map<any,any>|Set<any>|WeakMap<any,any>|WeakSet<any>|Error|ArrayBuffer|DataView|TypedArray|WebApiObjects|IntlObjects|NodeBuiltins|symbol|{[Symbol.toStringTag]:"Proxy";}|typeof Reflect;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsArrayOrTuple`.***
- * -------------------------------------------------------
- * **Checks if a given type `T` is an array or tuple type.**
- * - This includes both mutable (`T[]`) and readonly (`readonly T[]`) arrays.
- * @template T - The type to check.
- * @example
- * type A = IsArrayOrTuple<string[]>;
- * // ➔ true
- * type B = IsArrayOrTuple<readonly [string, number]>;
- * // ➔ true
- * type C = IsArrayOrTuple<string>; // ➔ false
- */
-type IsArrayOrTuple<T>=T extends readonly any[]?true:false;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsConstructor`.***
- * -------------------------------------------------------
- * **Checks if a given type `T` is a constructor type (`new () => any`).**
- * @template T - The type to check.
- * @returns `true` if `T` is a constructor, otherwise `false`.
- * @example
- * class MyClass {}
- * type A = IsConstructor<typeof MyClass>;
- * // ➔ true
- * type B = IsConstructor<() => void>;
- * // ➔ false
- */
-type IsConstructor<T>=T extends abstract new(...args:any[])=>any?true:false;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsFunction`.***
- * -------------------------------------------------------
- * **Checks if a given type `T` is a callable function type.**
- * @template T - The type to check.
- * @example
- * type A = IsFunction<() => void>; // ➔ true
- * type B = IsFunction<string>;     // ➔ false
- */
-type IsFunction<T>=T extends AnyFunction?true:false;
-/** -------------------------------------------------------
- * * ***Utility Type: `Primitive`.***
- * -------------------------------------------------------
- * **Represents **all primitive types in JavaScript/TypeScript**,
- * including their literal variants.**
- * - **This type matches:**
- *    - Core primitive types:
- *      - `string`, `number`, `boolean`, `bigint`, `symbol`, `null`, `undefined`.
- *    - Literal counterparts:
- *      - `"foo"`, `42`, `true`, etc.
- * - ⚠️ ***Note:***
- *    - Unlike some definitions, this does **not** include `void` or `never`,
- *      since they are TypeScript-specific keywords, not runtime primitives.
- * @example
- * ```ts
- * type A = Primitive;
- * // ➔ any strict primitive type
- * type B = "hello" extends Primitive ? true : false;
- * // ➔ true
- * type C = void extends Primitive ? true : false;
- * // ➔ false
- * ```
- */
-type Primitive=string|number|bigint|boolean|symbol|null|undefined;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsPrimitive`.***
- * -------------------------------------------------------
- * **Checks if a given type `T` is a **strict primitive type** in JavaScript/TypeScript,
- * including literal variants.**
- * - **Behavior:**
- *    - ***Includes:***
- *        - `string`, `number`, `bigint`, `boolean`, `symbol`, `null`, `undefined`.
- *        - Literal types like: `"foo"`, `42`, `true`.
- *    - ***Excludes:***
- *        - `void` (absence of value).
- *        - `never` (impossible type).
- *        - `object`, `unknown`, `Date`, `arrays`, `functions`, etc.
- * @template T - The type to check
- * @example
- * ```ts
- * type A = IsPrimitive<"foo">;      // ➔ true
- * type B = IsPrimitive<null>;       // ➔ true
- * type C = IsPrimitive<number>;     // ➔ true
- * type D = IsPrimitive<undefined>;  // ➔ true
- * type E = IsPrimitive<{}>;         // ➔ false
- * type F = IsPrimitive<void>;       // ➔ false
- * type G = IsPrimitive<never>;      // ➔ false
- * type H = IsPrimitive<unknown>;    // ➔ false
- * type I = IsPrimitive<object>;     // ➔ false
- * type J = IsPrimitive<Date>;       // ➔ false
- * type K = IsPrimitive<[]>;         // ➔ false
- * type L = IsPrimitive<() => void>; // ➔ false
- * ```
- */
-type IsPrimitive<T>=IsNever<T>extends true?false:T extends Primitive?true:false;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsRealPrimitive`.***
- * -------------------------------------------------------
- * **Checks if a given type `T` is a **real primitive type** in JavaScript/TypeScript,
- * based on runtime behavior, **excluding `null`** but including `undefined`.**
- * - **Behavior:**
- *    - ***Includes:***
- *       - `string`, `number`, `bigint`, `boolean`, `symbol`, `undefined`.
- *       - Literal types like: `"foo"`, `42`, `true`.
- *    - ***Excludes:***
- *       - `null`.
- *       - `never` (impossible type).
- *       - Objects, arrays, functions, `Date`, `unknown`, etc.
- * - ⚠️ ***Note:***
- *    - This aligns with runtime `typeof` checks in JS:
- *      - `typeof null === "object"`,
- *        so `null` is excluded from **“real primitives”**.
- * @template T - The type to check.
- * @example
- * ```ts
- * type A = IsRealPrimitive<42>;         // ➔ true
- * type B = IsRealPrimitive<string>;     // ➔ true
- * type C = IsRealPrimitive<boolean>;    // ➔ true
- * type D = IsRealPrimitive<undefined>;  // ➔ true
- * type E = IsRealPrimitive<{}>;         // ➔ false
- * type F = IsRealPrimitive<[]>;         // ➔ false
- * type G = IsRealPrimitive<null>;       // ➔ false
- * type H = IsRealPrimitive<Date>;       // ➔ false
- * type I = IsRealPrimitive<() => void>; // ➔ false
- * ```
- */
-type IsRealPrimitive<T>=T extends Exclude<Primitive,null>?true:false;
-/** * Applies readonly behavior according to mode. */
-type ApplyReadonlyMode<T,Mode extends PrettifyOptions["readonlyMode"]>=Mode extends"remove"?{-readonly [K in keyof T]:T[K];}:Mode extends"preserve"?{readonly [K in keyof T]:T[K];}:{[K in keyof T]:T[K];};
-/** ---------------------------------------------------------------------------
- * * ***Options for {@link Prettify|`Prettify`}.***
- * ---------------------------------------------------------------------------
- * **Options for customizing the behavior of the {@link Prettify | **`Prettify`**} type utility.**
- */
-type PrettifyOptions={
-/** -------------------------------------------------------
- * * ***recursive***
- * -------------------------------------------------------
- * **Enables **deep prettification** of types when set to `true`.**
- * @description
- * By default (`false`), {@link Prettify | **`Prettify`**} only flattens the **top-level shape**
- * of objects and intersections. Nested objects, arrays, and tuples remain as-is
- * unless this option is enabled.
- * - ***Behavior when `true`:***
- *    - **Plain objects**: Nested intersections are expanded recursively.
- *    - **Arrays & tuples**: Each element type is recursively prettified.
- *    - **Readonly handling**: Nested properties respect the `readonlyMode` option.
- *    - **Functions, constructors, and built-in objects** (Set, Map, Date, Promise, etc.)
- *      are **not** affected or expanded.
- *    - **Nested intersections**: Combined properties are flattened recursively.
- * - ⚠️ ***Notes:***
- *    - Recursive mode only applies to **plain objects**, **arrays**, and **tuples**.
- *    - Readonly modifiers on nested properties follow the `readonlyMode` rules:
- *      - `"auto"` ➔ keep as-is
- *      - `"remove"` ➔ strip readonly
- *      - `"preserve"` ➔ make readonly
- *    - Arrays and tuples maintain `readonly` if the original type is `readonly` and `readonlyMode` is `"auto"` or `"preserve"`.
- * @default false
- * @example
- * ```ts
- * type Nested = {
- *   a: {
- *     readonly b: { c: number } & { d: string }
- *   } & { e: boolean };
- *   list: readonly ({ id: number } & { name: string })[];
- *   set: Set<{ x: number } & { y: string }>;
- * };
- *
- * // Top-level only (default)
- * type Shallow = Prettify<Nested>;
- * // ➔ {
- * //      a: { readonly b: { c: number } & { d: string } } & { e: boolean };
- * //      list: readonly ({ id: number } & { name: string })[];
- * //      set: Set<{ x: number } & { y: string }>;
- * //    }
- *
- * // Fully recursive flatten
- * type Deep = Prettify<Nested, { recursive: true }>;
- * // ➔ {
- * //      a: { readonly b: { c: number; d: string }; e: boolean };
- * //      list: readonly { id: number; name: string }[];
- * //      set: Set<{ x: number } & { y: string }>; // built-in ignored
- * //    }
- * ```
- */
-recursive?:boolean;
-/** -------------------------------------------------------
- * * ***readonlyMode***
- * -------------------------------------------------------
- * **Determines how `readonly` modifiers are applied to properties
- * when using {@link Prettify}.**
- * - **Modes:**
- *    - `"auto"` ➔ Keep `readonly` exactly as in the original type (default).
- *    - `"remove"` ➔ Remove all `readonly` modifiers.
- *    - `"preserve"` ➔ Make all properties `readonly`.
- * - **Behavior:**
- *    - Applies to both **top-level** and **nested properties** (if `recursive` is `true`).
- *    - Arrays and tuples preserve or adjust `readonly` according to the selected mode:
- *      - `"auto"` ➔ preserve array/tuple readonly as-is.
- *      - `"remove"` ➔ array/tuple becomes mutable.
- *      - `"preserve"` ➔ array/tuple becomes readonly.
- *    - Functions, constructors, and built-in objects (Set, Map, Date, Promise, etc.) are **not affected**.
- *    - Nested intersections respect `readonlyMode` recursively if `recursive` is enabled.
- * - ⚠️ ***Notes:***
- *    - For nested objects, `readonly` behavior only changes if `recursive: true`.
- *    - `readonlyMode` does **not** override `readonly` on function parameters, methods, or constructors.
- * @default "auto"
- * @example
- * ```ts
- * type T = { readonly a: number; b: string };
- *
- * // Default: auto
- * type Auto = Prettify<T, { readonlyMode: "auto" }>;
- * // ➔ { readonly a: number; b: string }
- *
- * // Remove readonly
- * type Remove = Prettify<T, { readonlyMode: "remove" }>;
- * // ➔ { a: number; b: string }
- *
- * // Force all readonly
- * type Preserve = Prettify<T, { readonlyMode: "preserve" }>;
- * // ➔ { readonly a: number; readonly b: string }
- *
- * // Recursive + preserve
- * type Nested = {
- *   config: { readonly port: number } & { host: string }
- * };
- * type RecursivePreserve = Prettify<Nested, { recursive: true; readonlyMode: "preserve" }>;
- * // ➔ { readonly config: { readonly port: number; readonly host: string } }
- * ```
- */
-readonlyMode?:Extract<"auto"|"remove"|"preserve",string>;};
-/** -------------------------------------------------------
- * * ***DefaultPrettifyOptions***
- * -------------------------------------------------------
- * **Default options {@link Prettify | **`Prettify`**} used when no custom options are provided.**
- */
-type DefaultPrettifyOptions={recursive:false;readonlyMode:"auto";};type MergeReadonlyIntersection<T>=T extends readonly any[]?T:T extends object?{[K in keyof T]:T[K];}:T;
-/** -------------------------------------------------------
- * * ***Utility Type: `Prettify`.***
- * -------------------------------------------------------
- * **Flattens and simplifies complex TypeScript types into a more
- * human-readable form, by forcing the compiler to expand intersections.**
- * @description
- * By default, only the **top-level shape** of an object is flattened.
- * To also prettify **nested objects**, set the `recursive` option.
- * - ⚠️ ***Note:***
- *    - `recursive: true` only affects **plain objects** and **arrays/tuples**.
- *    - Built-in objects like `Set`, `Map`, `Date`, `Promise`, etc.
- *      will **not** be recursively prettified.
- *    - `readonly` handling is controlled via the `readonlyMode` option.
- * - **ℹ️ Options:**
- *    - `recursive?: boolean` (default: `false`):
- *      - Whether to recursively expand nested objects and intersections.
- *    - `readonlyMode?: "auto" | "remove" | "preserve"` (default: `"auto"`):
- *      - How `readonly` modifiers are treated:
- *        - `"auto"`     ➔ preserve `readonly` as-is (**default**).
- *        - `"remove"`   ➔ strip all `readonly`.
- *        - `"preserve"` ➔ enforce `readonly` everywhere.
- * @template T - The type to prettify.
- * @template Options - Configuration options.
- * @example
- * ```ts
- * // --- Top-level only (default) ---
- * type T0 = Prettify<{ a: number } & { b: string }>;
- * // ➔ { a: number; b: string }
- *
- * // --- Recursive expansion of nested objects ---
- * type T1 = Prettify<
- *   { a: { x: number } & { y: string } } & { b: boolean },
- *   { recursive: true }
- * >;
- * // ➔ { a: { x: number; y: string }; b: boolean }
- *
- * // --- Readonly handling modes ---
- * type T2 = { readonly id: number; name: string };
- *
- * type R1 = Prettify<T2>;
- * // (default: readonlyMode = "auto")
- * // ➔ { readonly id: number; name: string }
- *
- * type R2 = Prettify<T2, { readonlyMode: "remove" }>;
- * // ➔ { id: number; name: string }
- *
- * type R3 = Prettify<T2, { readonlyMode: "preserve" }>;
- * // ➔ { readonly id: number; readonly name: string }
- *
- * // --- Readonly + mutable intersection ---
- * type T3 = Prettify<{ readonly a: number } & { a: number; b: boolean }>;
- * // ➔ { a: number; b: boolean }
- * // (in "auto" mode, readonly lose over mutable)
- *
- * // --- Nested readonly with recursive ---
- * type T4 = Prettify<
- *   { config: { readonly port: number } & { host: string } },
- *   { recursive: true }
- * >;
- * // ➔ { config: { readonly port: number; host: string } }
- *
- * // --- Arrays with readonly ---
- * type T5 = Prettify<
- *   { list: readonly ({ id: number } & { name: string })[] },
- *   { recursive: true }
- * >;
- * // (readonly on array is preserved in "auto" mode)
- * // ➔ { list: readonly { id: number; name: string }[] }
- *
- * type T6 = Prettify<
- *   { list: readonly ({ id: number } & { name: string })[] },
- *   { recursive: true; readonlyMode: "remove" }
- * >;
- * // ➔ { list: { id: number; name: string }[] }
- *
- * // --- Built-in objects are ignored (not expanded) ---
- * type T7 = Prettify<
- *   { s: Set<{ a: number } & { b: string }> },
- *   { recursive: true }
- * >;
- * // ➔ { s: Set<{ a: number } & { b: string }> }
- * ```
- */
-type Prettify<T,Options extends PrettifyOptions=DefaultPrettifyOptions>=IsPrimitive<T>extends true?T:IsFunction<T>extends true?T:IsConstructor<T>extends true?T:IsArrayOrTuple<T>extends true?ApplyReadonlyMode<{[K in keyof T]:If<Options["recursive"],Prettify<T[K],Options>,T[K]>;},Options["readonlyMode"]>:T extends NonPlainObject?T:T extends object?ApplyReadonlyMode<MergeReadonlyIntersection<{[K in keyof T]:If<Options["recursive"],Prettify<T[K],Options>,T[K]>;}>,Options["readonlyMode"]>:T;export type{AnyFunction as A,BoxedPrimitivesTypes as B,DefaultPrettifyOptions as D,IsArrayOrTuple as I,NonPlainObject as N,Prettify as P,TypedArray as T,WebApiObjects as W,PrettifyOptions as a,IsConstructor as b,IsFunction as c,IsPrimitive as d,IsRealPrimitive as e,Primitive as f,AnObjectNonArray as g,DataTypes as h,DeepReplaceType as i,IntlObjects as j};

package/dist/promises-LU7K00H0.d.ts

@@ -1,72 +0,0 @@
-/** --------------------------------------------------
- * * ***Utility Type: `Awaitable`.***
- * --------------------------------------------------
- * **Represents a type that can be awaited:**
- *   - Either a plain value `T` or a `PromiseLike<T>`.
- * @template T - The inner value type.
- * @example
- * ```ts
- * async function wrap<T>(v: Awaitable<T>): Promise<T> {
- *   return await v;
- * }
- *
- * const a = wrap(42);           // Promise<number>
- * const b = wrap(Promise.resolve("hi")); // Promise<string>
- * ```
- */
-type Awaitable<T>=T|PromiseLike<T>;interface CustomPromiseLike<OnSuccess,OnError>{
-/**
- * Attaches callbacks for the resolution and/or rejection of the Promise.
- * @param onfulfilled The callback to execute when the Promise is resolved.
- * @param onrejected The callback to execute when the Promise is rejected.
- * @returns A Promise for the completion of which ever callback is executed.
- */
-then<TResult1=OnSuccess,TResult2=never>(onfulfilled?:((value:OnSuccess)=>TResult1|PromiseLike<TResult1>)|null|undefined,onrejected?:((reason:OnError)=>TResult2|PromiseLike<TResult2>)|null|undefined):CustomPromiseType<TResult1|TResult2,OnError>;
-/**
- * Attaches a callback for only the rejection of the Promise.
- * @param onrejected The callback to execute when the Promise is rejected.
- * @returns A Promise for the completion of the callback.
- */
-catch<TResult=never>(onrejected?:((reason:OnError)=>TResult|PromiseLike<TResult>)|null|undefined):CustomPromiseType<OnSuccess|TResult,OnError>;
-/**
- * Registers a callback to be invoked **exactly once** when the
- * promise settles, with access to both the resolved value and
- * the rejection reason.
- *
- * If the promise is already settled when `finish` is called,
- * the callback executes immediately on the same tick.
- *
- * @param cb Callback receiving the final `(value, error)`.
- * @returns `this` for fluent chaining.
- */
-finish(cb:(value:OnSuccess|undefined,error:OnError|undefined)=>void):CustomPromiseType<OnSuccess,OnError>;}
-/** --------------------------------------------------
- * * ***Utility Type: `CustomPromiseType`.***
- * --------------------------------------------------
- * **Extends the native `Promise` type to provide explicit typing
- * for both the resolved (`onSuccess`) and rejected (`onError`) values,
- * plus an optional `finish` hook.**
- * - **Behavior:**
- *    - ✅ **Strongly types** `success`, `error`, and `finish` handlers.
- *    - ⚙️ `finish` runs exactly once after the promise settles (similar to `finish`).
- * @template OnSuccess - The type of the fulfilled value.
- * @template OnError   - The type of the rejection reason, defaults to `unknown`.
- * @example
- * ```ts
- * import type { CustomPromiseType } from "@rzl-zone/types";
- * import { CustomsPromise } from "@rzl-zone/promises";
- *
- * const fetchUser = (): CustomPromiseType<User, ApiError> =>
- *   CustomsPromise<User, ApiError>((resolve, reject) => {
- *     apiCall().then(resolve).catch(reject);
- *   });
- *
- * fetchUser()
- *   .then(user => console.log(user))
- *   .catch(err => console.error(err))
- *   .finish((result, error) => {
- *     console.log("always runs", { result, error });
- *   });
- * ```
- */
-type CustomPromiseType<OnSuccess,OnError=unknown>=CustomPromiseLike<OnSuccess,OnError>;export type{Awaitable as A,CustomPromiseType as C};