@rzl-zone/utils-js 2.1.0 → 3.0.0

package/dist/formatting/index.js

@@ -0,0 +1 @@
+export{censorEmail,chunkString,formatCurrency,formatDateFns,formatDateIntl,formatDateTime,formatNumber,formatPhoneNumber,getGMTOffset,truncateString}from"../chunk-ZL7J6GTP.js";import"../chunk-EUANTHVN.js";import"../chunk-OWV2P376.js";import"../chunk-MISCBZJC.js";import"../chunk-KOVO72OM.js";import"../chunk-T4CIAKEK.js";import"../chunk-WVSPXFTY.js";import"../chunk-BHIBDDQF.js";import"../chunk-QNKGP5DY.js";import"../chunk-EW3I4O7X.js";

package/dist/generator/index.cjs

@@ -0,0 +1 @@
+"use strict";var e=require("../chunk-FV7SEBKD.cjs"),r=require("../chunk-5C2SMIGX.cjs");require("../chunk-DVMHRLKP.cjs"),require("../chunk-ZHV5ZYVN.cjs"),require("../chunk-UDA26MCU.cjs"),require("../chunk-D3VSHABU.cjs"),Object.defineProperty(exports,"getRandomItem",{enumerable:!0,get:function(){return e.getRandomItem}}),Object.defineProperty(exports,"randomInt",{enumerable:!0,get:function(){return e.randomInt}}),Object.defineProperty(exports,"randomIntByLength",{enumerable:!0,get:function(){return e.randomIntByLength}}),Object.defineProperty(exports,"randomStr",{enumerable:!0,get:function(){return e.randomStr}}),Object.defineProperty(exports,"noop",{enumerable:!0,get:function(){return r.noop}});

package/dist/generator/index.d.ts

@@ -0,0 +1,186 @@
+import{f as IfNonEmptyArray,E as Extends}from'../extends-Bk_SBGdT.js';import{F as FixNeverArrayRecursive}from'../arrays-normalize-recursive-CnjYJ9xg.js';import{g as NullToUndefined}from'../nils-DMz3kU7M.js';import'../if-CvT4R7Kh.js';import'../never-BfayMBF9.js';type OptionsRandomStr={
+/** Ensures no whitespace characters in the generated string, defaultValue: `true`.
+ *
+ * @default true
+ */
+avoidWhiteSpace?:boolean;
+/** Custom characters to replace the default number set if `type` is `"number"`, defaultValue: `undefined`.
+ *
+ * @default undefined
+ */
+replaceGenInt?:string;
+/** Custom characters to replace the default string set if `type` is `"string"`, defaultValue: `undefined`.
+ *
+ * @default undefined
+ */
+replaceGenStr?:string;
+/** Additional characters to include in the generated string, defaultValue: `undefined`.
+ *
+ * @default undefined
+ */
+addChar?:string;
+/** Minimum length of the generated string (1 to 5000), defaultValue: `40`.
+ *
+ * @default 40
+ */
+minLength?:number;
+/** Maximum length of the generated string (1 to 5000), defaultValue: `40`.
+ *
+ * @default 40
+ */
+maxLength?:number;
+/** Type of output: `"string"` or `"number"`, defaultValue: `"string"`.
+ *
+ * @default "string"
+ */
+type?:"string"|"number";};
+/** ---------------------------------
+ * * ***Returns a random element from a given array.***
+ * ---------------------------------
+ * @template T - The type of the input array.
+ * @param {*} array - The input array. Can be `null`, `undefined`, or an empty array.
+ * @returns
+ * - If `array` is a non-empty tuple, returns one of its elements.
+ * - If `array` is empty, `null`, or `undefined`, returns `undefined`.
+ * @example
+ * getRandomItem([]);
+ * // ➔ undefined
+ * getRandomItem(null);
+ * // ➔ undefined
+ * getRandomItem(undefined);
+ * // ➔ undefined
+ * getRandomItem([1, 2, 3, 4]);
+ * // ➔ number
+ * getRandomItem(["apple", "banana", "cherry"]);
+ * // ➔ string
+ * getRandomItem(["apple", 123, true]);
+ * // ➔ string | number | boolean
+ * getRandomItem(["apple", 123, true, null]);
+ * // ➔ string | number | boolean | undefined
+ * getRandomItem(["apple", 123, true, undefined]);
+ * // ➔ string | number | boolean | undefined
+ *
+ * // Tuple example:
+ * const tuple = [1, "two", true] as const;
+ * getRandomItem(tuple); // 1 | "two" | true
+ */
+declare function getRandomItem(array:undefined):undefined;declare function getRandomItem(array:null):undefined;declare function getRandomItem(array:[]):undefined;declare function getRandomItem<T extends readonly unknown[]>(array:T):T extends never[][]?[]:number extends T["length"]?NullToUndefined<FixNeverArrayRecursive<T[number]>>:IfNonEmptyArray<T,NullToUndefined<FixNeverArrayRecursive<T[number]>>,undefined>;declare function getRandomItem<T extends readonly unknown[]|undefined|null>(array:T):T extends readonly unknown[]?NullToUndefined<FixNeverArrayRecursive<T[number]>>|undefined:undefined;declare function getRandomItem<T>(array:T):unknown extends T?unknown:Extends<any[]|readonly any[],T>extends true?Extract<T,unknown[]|readonly unknown[]>[number]|undefined:Extends<any[],T>extends true?Extract<T,unknown[]|readonly unknown[]>[number]|undefined:Extends<readonly any[],T>extends true?Extract<T,unknown[]|readonly unknown[]>[number]|undefined:undefined;
+/** -----------------------------------------------------------------------
+ * * ***Generates a random integer within a specified range (inclusive).***
+ * ------------------------------------------------------------------------
+ * Generates a random integer between `min` and `max` (inclusive), with safety constraints:
+ * - `min` will be forced to be at least `1`.
+ * - `max` will be capped at `Number.MAX_SAFE_INTEGER`.
+ *
+ * Validates input parameters to ensure robust behavior.
+ * @param {number} min - The minimum value (inclusive), must be an integer.
+ * @param {number} max - The maximum value (inclusive), must be an integer.
+ * @returns {number} A random integer N where `min ≤ N ≤ max`.
+ * @throws {TypeError} If:
+ * - `min` or `max` is not an integer and value is `Number.MIN_VALUE`.
+ * - `min` is greater than `max`.
+ * @example
+ * randomInt(1, 10);   // ➔ returns 1 to 10
+ * randomInt(50, 100); // ➔ returns 50 to 100
+ * randomInt(5, 5);    // ➔ always returns 5
+ * randomInt(-5, 3);   // ➔ always returns ≥ 1, since min is adjusted
+ * randomInt(1, Number.MAX_SAFE_INTEGER + 10000);
+ * // ➔ still safely capped at MAX_SAFE_INTEGER
+ * randomInt(Number.MIN_VALUE, 3);
+ * // ➔ Error, min or max cant be as `Number.MIN_VALUE` value.
+ */
+declare const randomInt:(min:number,max:number)=>number;type OptionsRandomIntByLength={
+/** * Minimum length of the random number, the `allowed minimal value` `integer` is `1` `and not bigger than value of` `maxLength`, defaultValue: `1`.
+ *
+ * @default 1
+ */
+minLength?:number;
+/** * Maximum length of the random number, the `allowed maximal value` `integer` is `16`, defaultValue: `16`.
+ *
+ * @default 16
+ */
+maxLength?:number;
+/** * If true, prevents the result from being zero, defaultValue: `false`.
+ *
+ * @default false
+ */
+avoidZero?:boolean;};
+/** ----------------------------------------------------------------------------
+ * * ***Generates a random integer within a specified range of digit lengths.***
+ * -----------------------------------------------------------------------------
+ * **This function allows generating random integers that strictly conform to a specified minimum and
+ * maximum digit length, it is useful for scenarios such as generating realistic-looking IDs, codes,
+ * or random test data.**
+ * - **The function ensures:**
+ *    - `minLength` is at least 1 and not greater than `maxLength`.
+ *    - `maxLength` is no more than 16 (due to JavaScript's Number.MAX_SAFE_INTEGER).
+ *    - If `avoidZero` is `true`, ensures that `0` is never returned.
+ * @param {OptionsRandomIntByLength} [options] - Configuration options.
+ * @param {OptionsRandomIntByLength["minLength"]} [options.minLength=1] - Minimum number of digits (must be ≥1 and ≤ `maxLength`).
+ * @param {OptionsRandomIntByLength["maxLength"]} [options.maxLength=16] - Maximum number of digits (must be ≤16).
+ * @param {OptionsRandomIntByLength["avoidZero"]} [options.avoidZero=false] - If true, will ensure the result is never zero.
+ * @returns {number} A randomly generated integer within the specified constraints.
+ * @throws {TypeError} If parameters are invalid, such as:
+ * - `minLength` < `1`
+ * - `maxLength` > `16`
+ * - `minLength` > `maxLength`
+ * - non-integer values for `minLength` or `maxLength`
+ * @example
+ * randomIntByLength({ minLength: 3, maxLength: 5 });
+ * // ➔ (`4829` << random), (`192` << random) or (`71492` << random).
+ * randomIntByLength({ minLength: 4, maxLength: 4 });
+ * // ➔ `5930` (exact 4 digits)
+ * randomIntByLength({ avoidZero: true });
+ * // ➔ never 0
+ */
+declare const randomIntByLength:(options?:OptionsRandomIntByLength)=>number;
+/** ---------------------------------------------------------------------------------
+ * * ***Generates a random alphanumeric string or number with a specified length range.***
+ * ---------------------------------------------------------------------------------
+ * **This function allows you to generate random strings or numbers with fully
+ * customizable options, such as length range, character sets, inclusion of
+ * additional characters, and whether to avoid whitespace.**
+ * @param {OptionsRandomStr} [options] - Configuration options for generating the string.
+ * @param {OptionsRandomStr["minLength"]} [options.minLength=40] - Minimum length of the generated string (must be `≥` `1`).
+ * @param {OptionsRandomStr["maxLength"]} [options.maxLength=40] - Maximum length of the generated string (must be `≤` `5000`).
+ * @param {OptionsRandomStr["type"]} [options.type="string"] - Whether to generate a general alphanumeric string or purely numeric string.
+ * @param {OptionsRandomStr["avoidWhiteSpace"]} [options.avoidWhiteSpace=true] - If true, removes all whitespace, tabs, and newlines from the character set before generating.
+ * @param {OptionsRandomStr["replaceGenStr"]} [options.replaceGenStr] - A custom character set to use when `type` is `"string"`.
+ * @param {OptionsRandomStr["replaceGenInt"]} [options.replaceGenInt] - A custom character set to use when `type` is `"number"`.
+ * @param {OptionsRandomStr["addChar"]} [options.addChar] - Additional characters to always include in the character set.
+ * @returns {string} The randomly generated string or numeric string of the desired length.
+ * @throws {TypeError} If provided options are invalid (such as minLength > maxLength, invalid type, or empty character set).
+ * @example
+ * randomStr();
+ * // ➔ Generates a 40-character random alphanumeric string
+ * randomStr({ minLength: 10, maxLength: 20 });
+ * // ➔ Generates a string between 10 and 20 characters
+ * randomStr({ type: "number", minLength: 5, maxLength: 5 });
+ * // ➔ "48302"
+ * randomStr({ replaceGenStr: "ABC ", avoidWhiteSpace: false });
+ * // ➔ String using A, B, C and space
+ * randomStr({ addChar: "!@#", minLength: 15, maxLength: 15 });
+ * // ➔ Guaranteed to include !@# in the set
+ */
+declare const randomStr:(options?:OptionsRandomStr)=>string;
+/** --------------------------------------------------
+ * * ***A no-operation function that always returns `undefined`.***
+ * --------------------------------------------------
+ * **Useful as a default callback, placeholder, or stub function.**
+ * @returns {undefined} Always returns `undefined`.
+ * @example
+ * // Direct call returns undefined
+ * noop();
+ * // ➔ undefined
+ *
+ * // Can be used with type-checking helpers
+ * isUndefined(noop());  // ➔ true
+ * isFunction(noop);     // ➔ true
+ * isFunction(noop());   // ➔ false
+ *
+ * // Often used as a default function
+ * const callback = noop;
+ * callback();
+ * // ➔ undefined
+ */
+declare const noop:()=>void;export{getRandomItem,noop,randomInt,randomIntByLength,randomStr};

package/dist/generator/index.js

@@ -0,0 +1 @@
+export{getRandomItem,randomInt,randomIntByLength,randomStr}from"../chunk-3YCFMGRB.js";export{noop}from"../chunk-FIAAX3UE.js";import"../chunk-WVSPXFTY.js";import"../chunk-BHIBDDQF.js";import"../chunk-QNKGP5DY.js";import"../chunk-EW3I4O7X.js";

package/dist/if-CvT4R7Kh.d.ts

@@ -0,0 +1,18 @@
+/** -------------------------------------------------------
+ * * ***If.***
+ * -------------------------------------------------------
+ * Conditional: returns the second argument if the first argument is `true`, otherwise returns the third argument.
+ * - Defaults: `IfTrue = true`, `IfFalse = false`.
+ *
+ * @template Condition - The boolean condition to check.
+ * @template IfTrue - The branch type if condition is `true`. (default: `true`)
+ * @template IfFalse - The branch type if condition is `false`. (default: `false`)
+ * @example
+ * ```ts
+ * type A = If<true, "valid">;
+ * // ➔ "valid"
+ * type B = If<false, "valid", "invalid">;
+ * // ➔ "invalid"
+ * ```
+ */
+type If<Condition,IfTrue=true,IfFalse=false>=Condition extends true?IfTrue:IfFalse;export type{If as I};