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

package/dist/formatting/index.js

@@ -1 +0,0 @@
-export{h as censorEmail,i as chunkString,a as formatCurrency,f as formatDateFns,e as formatDateIntl,d as formatDateTime,b as formatNumber,c as formatPhoneNumber,g as getGMTOffset,j as truncateString}from'../chunk-G4EWCRKS.js';import'../chunk-7VX33E3V.js';import'../chunk-ESJYBIYH.js';import'../chunk-NR44SNYE.js';import'../chunk-7CHFAMS2.js';import'../chunk-NJSAV73S.js';import'../chunk-ELDDNERR.js';import'../chunk-J4NCYYGS.js';import'../chunk-5SZUSNGZ.js';import'../chunk-EWYPSKKM.js';

package/dist/generator/index.cjs

@@ -1 +0,0 @@
-'use strict';var chunkSZPWZZYG_cjs=require('../chunk-SZPWZZYG.cjs'),chunkRV2VULM7_cjs=require('../chunk-RV2VULM7.cjs');require('../chunk-PUQXRLZH.cjs'),require('../chunk-26W3VZIK.cjs'),require('../chunk-7YWAQOA4.cjs'),require('../chunk-CII6WWLO.cjs');Object.defineProperty(exports,"getRandomItem",{enumerable:true,get:function(){return chunkSZPWZZYG_cjs.a}});Object.defineProperty(exports,"randomInt",{enumerable:true,get:function(){return chunkSZPWZZYG_cjs.b}});Object.defineProperty(exports,"randomIntByLength",{enumerable:true,get:function(){return chunkSZPWZZYG_cjs.c}});Object.defineProperty(exports,"randomStr",{enumerable:true,get:function(){return chunkSZPWZZYG_cjs.d}});Object.defineProperty(exports,"noop",{enumerable:true,get:function(){return chunkRV2VULM7_cjs.a}});

package/dist/generator/index.js

@@ -1 +0,0 @@
-export{a as getRandomItem,b as randomInt,c as randomIntByLength,d as randomStr}from'../chunk-5Q37AP7P.js';export{a as noop}from'../chunk-SYJC7UAW.js';import'../chunk-ELDDNERR.js';import'../chunk-J4NCYYGS.js';import'../chunk-5SZUSNGZ.js';import'../chunk-EWYPSKKM.js';

package/dist/omit-VvmIsZmX.d.ts

@@ -1,28 +0,0 @@
-import{P as Prettify}from'./prettify-C4xLcYOP.js';
-/** --------------------------------------------------
- * * ***OmitStrict.***
- * --------------------------------------------------
- * Strictly omits keys `K` from type `T`, with optional flattening for readability using `Prettify`.
- *
- * ✅ 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;}>:WithPrettify extends false?Omit<T,K>:never;export type{OmitStrict as O};

package/dist/prettify-C4xLcYOP.d.ts

@@ -1,353 +0,0 @@
-import{I as If}from'./if-CvT4R7Kh.js';import{A as AnyFunction,N as NonPlainObject}from'./type-data-DDs-u2kq.js';import{I as IsNever}from'./never-BfayMBF9.js';
-/** -------------------------------------------------------
- * * ***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
- * // truthy
- * type A = IsArrayOrTuple<string[]>;
- * // ➔ true
- * type B = IsArrayOrTuple<readonly [string, number]>;
- * // ➔ true
- *
- * // falsy
- * type C = IsArrayOrTuple<string>; // ➔ false
- */
-type IsArrayOrTuple<T>=T extends readonly any[]?true:false;
-/** -------------------------------------------------------
- * * ***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;
-/** -------------------------------------------------------
- * * ***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;
-/** -------------------------------------------------------
- * * ***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;
-/** -------------------------------------------------------
- * * ***IsPrimitive.***
- * -------------------------------------------------------
- *
- * Checks if a given type `T` is a **strict primitive type** in JavaScript/TypeScript,
- * including literal variants.
- * This excludes `void` and `never`.
- *
- * 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;
-/** -------------------------------------------------------
- * * ***IsRealPrimitive.***
- * -------------------------------------------------------
- *
- * Checks if a given type `T` is a **real primitive type** in JavaScript/TypeScript,
- * based on runtime behavior, **excluding `null`** but including `undefined`.
- *
- * 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];};
-/** -------------------------------------------------------
- * * ***PrettifyOptions***
- * -------------------------------------------------------
- *
- * Options for customizing the behavior of the {@link Prettify} type.
- */
-type PrettifyOptions={
-/** -------------------------------------------------------
- * * ***recursive***
- * -------------------------------------------------------
- *
- * Enables **deep prettification** of types when set to `true`.
- *
- * By default (`false`), {@link 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} 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;
-/** -------------------------------------------------------
- * * ***Prettify.***
- * -------------------------------------------------------
- * Flattens and simplifies complex TypeScript types into a more
- * human-readable form, by forcing the compiler to expand intersections.
- *
- * 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{DefaultPrettifyOptions as D,IsArrayOrTuple as I,Prettify as P,PrettifyOptions as a,IsConstructor as b,IsFunction as c,IsPrimitive as d,IsRealPrimitive as e,Primitive as f};

package/dist/promise/index.cjs

@@ -1 +0,0 @@
-'use strict';var chunkD5TYPCWU_cjs=require('../chunk-D5TYPCWU.cjs');require('../chunk-PUQXRLZH.cjs'),require('../chunk-26W3VZIK.cjs'),require('../chunk-7YWAQOA4.cjs'),require('../chunk-CII6WWLO.cjs');Object.defineProperty(exports,"delay",{enumerable:true,get:function(){return chunkD5TYPCWU_cjs.a}});

package/dist/promise/index.d.ts

@@ -1,31 +0,0 @@
-/** ------------------------------------------------------------
- * * ***Utility: `delay`.***
- * ------------------------------------------------------------
- * **Creates a Promise-based delay that resolves after a given number
- * of milliseconds, optionally supports cancellation with `AbortSignal`.**
- * - **Behavior:**
- *    - Validates `milliSeconds` is a non-zero, non-negative integer.
- *    - Validates `signal` is an `AbortSignal` instance when provided.
- *    - Cleans up event listeners and timers properly.
- * @param {number} [milliSeconds=1000]
- *  The duration of the delay in milliseconds, default is `1000`.
- * @param {AbortSignal} [signal]
- *  An optional `AbortSignal` that can cancel the delay.
- * @returns {Promise<void>}
- *  A promise that resolves after the specified delay or
- *  rejects with an `AbortError` if aborted.
- * @throws {TypeError} Validates `milliSeconds` and `signal`:
- *  - If `milliSeconds` **is not a valid** an `integer-number`, `NaN`, `negative-number`, or `≤ 0`.
- *  - If `signal` **is not a valid** an`AbortSignal`.
- * @throws {DOMException}
- * If the delay is aborted using the signal, rejects with `"AbortError"`.
- * @example
- * // Waits for 2 seconds
- * await delay(2000);
- *
- * // Delay with AbortSignal
- * const controller = new AbortController();
- * delay(5000, controller.signal).catch(err => console.log(err.name)); // "AbortError"
- * controller.abort();
- */
-declare const delay:(milliSeconds?:number,signal?:AbortSignal)=>Promise<void>;export{delay};

package/dist/promise/index.js

@@ -1 +0,0 @@
-export{a as delay}from'../chunk-NXMTWY77.js';import'../chunk-ELDDNERR.js';import'../chunk-J4NCYYGS.js';import'../chunk-5SZUSNGZ.js';import'../chunk-EWYPSKKM.js';

package/dist/stylings/index.cjs

@@ -1 +0,0 @@
-'use strict';var chunkYFTR64N5_cjs=require('../chunk-YFTR64N5.cjs');require('../chunk-UQDJF5RR.cjs'),require('../chunk-CII6WWLO.cjs');Object.defineProperty(exports,"shouldForwardProp",{enumerable:true,get:function(){return chunkYFTR64N5_cjs.a}});

package/dist/stylings/index.d.ts

@@ -1,41 +0,0 @@
-/** Converts a union type into an intersection type.
- *
- * @template U - The union type to be converted.
- */
-type UnionToIntersectionStrict<U>=(U extends never?never:(arg:U)=>never)extends(arg:infer I)=>void?I:never;
-/** Converts a union type into a tuple type.
- *
- * @template T - The union type to be converted.
- */
-type UnionToTupleStrict<T>=UnionToIntersectionStrict<T extends never?never:(t:T)=>T>extends(_:never)=>infer W?[...UnionToTupleStrict<Exclude<T,W>>,W]:[];
-/** ----------------------------------------------------------
- * * ***Utility: `shouldForwardProp`.***
- * ----------------------------------------------------------
- * **Creates a helper for styled-components `shouldForwardProp`.**
- * @description
- * This utility returns a predicate function that determines whether a given prop
- * should be forwarded to the DOM, useful for filtering out internal props (e.g.,
- * `$size`, `$active`) so they don't end up as invalid HTML attributes.
- * - **Behavior:**
- *    - Accepts a tuple (strict) of prop keys to exclude from forwarding.
- *    - Automatically coerces prop names to string for consistent checking.
- *    - Supports string, number, or symbol keys (via PropertyKey).
- *    - Will throw an error if the provided `props` argument is not an array.
- * @template CustomProps - The type of the component's props.
- * @param {UnionToTupleStrict<keyof CustomProps>} props
- *   The list of prop names (keys of `CustomProps`) to exclude from forwarding.
- * @returns {(propName: PropertyKey) => boolean}
- *   A function that takes a prop name and returns `true` if it should be forwarded, `false` if it should be blocked.
- * @throws {TypeError} If `props` is not an array.
- * @example
- * type Props = { $size: string; color: string; visible: boolean };
- * const filter = shouldForwardProp<Props>(["$size"]);
- * filter("$size"); // ➔ false (blocked)
- * filter("color"); // ➔ true (forwarded)
- * @example
- * // Using with styled-components:
- * styled.div.withConfig({
- *   shouldForwardProp: shouldForwardProp<CustomProps>(["$internal"])
- * })
- */
-declare const shouldForwardProp:<CustomProps>(props:Partial<UnionToTupleStrict<keyof CustomProps>>)=>((propName:keyof CustomProps)=>boolean);export{shouldForwardProp};

package/dist/stylings/index.js

@@ -1 +0,0 @@
-export{a as shouldForwardProp}from'../chunk-JYNSO7ZY.js';import'../chunk-SL3RQOWA.js';import'../chunk-EWYPSKKM.js';