@kikiutils/shared 9.0.0

package/dist/hash.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+const sha3 = require('@noble/hashes/sha3');
+const utils = require('@noble/hashes/utils');
+
+/**
+ * This file provides a set of functions for creating SHA-3 hash digests using different bit lengths (224, 256, 384, 512).
+ * These functions use the [@noble/hashes](https://github.com/paulmillr/noble-hashes) library to generate the hashes.
+ * Can be used in the browser, mainly for Nuxt/Vue and other frameworks compiled and executed in the browser.
+ *
+ * @example
+ * ```typescript
+ * import { sha3256 } from '@kikiutils/shared/hash';
+ *
+ * console.log(sha3256('test')); // 36f028580bb02cc8272a9a020f4200e346e276ae664e45ee80745574e2f5ab80
+ * ```
+ */
+const sha3224 = (data) => utils.bytesToHex(sha3.sha3_224(data));
+const sha3256 = (data) => utils.bytesToHex(sha3.sha3_256(data));
+const sha3384 = (data) => utils.bytesToHex(sha3.sha3_384(data));
+const sha3512 = (data) => utils.bytesToHex(sha3.sha3_512(data));
+
+exports.sha3224 = sha3224;
+exports.sha3256 = sha3256;
+exports.sha3384 = sha3384;
+exports.sha3512 = sha3512;
+//# sourceMappingURL=hash.cjs.map

package/dist/hash.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.cjs","sources":["../src/hash.ts"],"sourcesContent":["/**\n * This file provides a set of functions for creating SHA-3 hash digests using different bit lengths (224, 256, 384, 512).\n * These functions use the [@noble/hashes](https://github.com/paulmillr/noble-hashes) library to generate the hashes.\n * Can be used in the browser, mainly for Nuxt/Vue and other frameworks compiled and executed in the browser.\n *\n * @example\n * ```typescript\n * import { sha3256 } from '@kikiutils/shared/hash';\n *\n * console.log(sha3256('test')); // 36f028580bb02cc8272a9a020f4200e346e276ae664e45ee80745574e2f5ab80\n * ```\n */\n\nimport {\n    sha3_224,\n    sha3_256,\n    sha3_384,\n    sha3_512,\n} from '@noble/hashes/sha3';\nimport { bytesToHex } from '@noble/hashes/utils';\n\nexport const sha3224 = (data: string | Uint8Array) => bytesToHex(sha3_224(data));\nexport const sha3256 = (data: string | Uint8Array) => bytesToHex(sha3_256(data));\nexport const sha3384 = (data: string | Uint8Array) => bytesToHex(sha3_384(data));\nexport const sha3512 = (data: string | Uint8Array) => bytesToHex(sha3_512(data));\n"],"names":["bytesToHex","sha3_224","sha3_256","sha3_384","sha3_512"],"mappings":";;;;;AAAA;;;;;;;;;;;AAWG;AAUU,MAAA,OAAO,GAAG,CAAC,IAAyB,KAAKA,gBAAU,CAACC,aAAQ,CAAC,IAAI,CAAC;AAClE,MAAA,OAAO,GAAG,CAAC,IAAyB,KAAKD,gBAAU,CAACE,aAAQ,CAAC,IAAI,CAAC;AAClE,MAAA,OAAO,GAAG,CAAC,IAAyB,KAAKF,gBAAU,CAACG,aAAQ,CAAC,IAAI,CAAC;AAClE,MAAA,OAAO,GAAG,CAAC,IAAyB,KAAKH,gBAAU,CAACI,aAAQ,CAAC,IAAI,CAAC;;;;;;;"}

package/dist/hash.d.ts

@@ -0,0 +1,17 @@
+/**
+ * This file provides a set of functions for creating SHA-3 hash digests using different bit lengths (224, 256, 384, 512).
+ * These functions use the [@noble/hashes](https://github.com/paulmillr/noble-hashes) library to generate the hashes.
+ * Can be used in the browser, mainly for Nuxt/Vue and other frameworks compiled and executed in the browser.
+ *
+ * @example
+ * ```typescript
+ * import { sha3256 } from '@kikiutils/shared/hash';
+ *
+ * console.log(sha3256('test')); // 36f028580bb02cc8272a9a020f4200e346e276ae664e45ee80745574e2f5ab80
+ * ```
+ */
+export declare const sha3224: (data: string | Uint8Array) => string;
+export declare const sha3256: (data: string | Uint8Array) => string;
+export declare const sha3384: (data: string | Uint8Array) => string;
+export declare const sha3512: (data: string | Uint8Array) => string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAUH,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,GAAG,UAAU,WAA+B,CAAC;AACjF,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,GAAG,UAAU,WAA+B,CAAC;AACjF,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,GAAG,UAAU,WAA+B,CAAC;AACjF,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,GAAG,UAAU,WAA+B,CAAC"}

package/dist/hash.mjs

@@ -0,0 +1,22 @@
+import { sha3_224, sha3_256, sha3_384, sha3_512 } from '@noble/hashes/sha3';
+import { bytesToHex } from '@noble/hashes/utils';
+
+/**
+ * This file provides a set of functions for creating SHA-3 hash digests using different bit lengths (224, 256, 384, 512).
+ * These functions use the [@noble/hashes](https://github.com/paulmillr/noble-hashes) library to generate the hashes.
+ * Can be used in the browser, mainly for Nuxt/Vue and other frameworks compiled and executed in the browser.
+ *
+ * @example
+ * ```typescript
+ * import { sha3256 } from '@kikiutils/shared/hash';
+ *
+ * console.log(sha3256('test')); // 36f028580bb02cc8272a9a020f4200e346e276ae664e45ee80745574e2f5ab80
+ * ```
+ */
+const sha3224 = (data) => bytesToHex(sha3_224(data));
+const sha3256 = (data) => bytesToHex(sha3_256(data));
+const sha3384 = (data) => bytesToHex(sha3_384(data));
+const sha3512 = (data) => bytesToHex(sha3_512(data));
+
+export { sha3224, sha3256, sha3384, sha3512 };
+//# sourceMappingURL=hash.mjs.map

package/dist/hash.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.mjs","sources":["../src/hash.ts"],"sourcesContent":["/**\n * This file provides a set of functions for creating SHA-3 hash digests using different bit lengths (224, 256, 384, 512).\n * These functions use the [@noble/hashes](https://github.com/paulmillr/noble-hashes) library to generate the hashes.\n * Can be used in the browser, mainly for Nuxt/Vue and other frameworks compiled and executed in the browser.\n *\n * @example\n * ```typescript\n * import { sha3256 } from '@kikiutils/shared/hash';\n *\n * console.log(sha3256('test')); // 36f028580bb02cc8272a9a020f4200e346e276ae664e45ee80745574e2f5ab80\n * ```\n */\n\nimport {\n    sha3_224,\n    sha3_256,\n    sha3_384,\n    sha3_512,\n} from '@noble/hashes/sha3';\nimport { bytesToHex } from '@noble/hashes/utils';\n\nexport const sha3224 = (data: string | Uint8Array) => bytesToHex(sha3_224(data));\nexport const sha3256 = (data: string | Uint8Array) => bytesToHex(sha3_256(data));\nexport const sha3384 = (data: string | Uint8Array) => bytesToHex(sha3_384(data));\nexport const sha3512 = (data: string | Uint8Array) => bytesToHex(sha3_512(data));\n"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;AAWG;AAUU,MAAA,OAAO,GAAG,CAAC,IAAyB,KAAK,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC;AAClE,MAAA,OAAO,GAAG,CAAC,IAAyB,KAAK,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC;AAClE,MAAA,OAAO,GAAG,CAAC,IAAyB,KAAK,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC;AAClE,MAAA,OAAO,GAAG,CAAC,IAAyB,KAAK,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC;;;;"}

package/dist/math.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+const decimal_js = require('decimal.js');
+
+/**
+ * Converts a fraction (numerator / denominator) into a percentage string.
+ *
+ * - Uses `decimal.js` for precise decimal calculations.
+ * - Supports custom decimal places and optional percentage symbol.
+ * - Returns `'0.00%'` if result is `NaN` or division is invalid.
+ *
+ * @param {CalculableValue} molecular - The numerator of the fraction.
+ * @param {CalculableValue} denominator - The denominator of the fraction.
+ * @param {ToPercentageStringOptions} [options] - Optional output settings.
+ * @returns {string} Formatted percentage string.
+ *
+ * @example
+ * ```typescript
+ * import { toPercentageString } from '@kikiutils/shared/math';
+ *
+ * console.log(toPercentageString(50, 200)); // 25.00%
+ * console.log(toPercentageString(50, 200, { withSymbol: false })); // 25.00
+ * console.log(toPercentageString(50, 200, { decimalPlaces: 1 })); // 25.0%
+ * ```
+ */
+function toPercentageString(molecular, denominator, options) {
+    const molecularDecimal = new decimal_js.Decimal(molecular.toString());
+    const denominatorDecimal = new decimal_js.Decimal(denominator.toString());
+    const calculationResult = molecularDecimal.div(denominatorDecimal);
+    const result = calculationResult.isNaN()
+        ? '0.00'
+        : calculationResult.times(100).toFixed(options?.decimalPlaces ?? 2);
+    return options?.withSymbol ?? true ? `${result}%` : result;
+}
+
+exports.toPercentageString = toPercentageString;
+//# sourceMappingURL=math.cjs.map

package/dist/math.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.cjs","sources":["../src/math.ts"],"sourcesContent":["import { Decimal } from 'decimal.js';\n\ntype CalculableValue = Decimal.Value | { toString: () => string };\n\n/**\n * Options for configuring the output of `toPercentageString`.\n */\nexport interface ToPercentageStringOptions {\n    /**\n     * Number of decimal places to include in the result.\n     * @default 2\n     */\n    decimalPlaces?: number;\n\n    /**\n     * Whether to include the '%' symbol in the result.\n     * @default true\n     */\n    withSymbol?: boolean;\n}\n\n/**\n * Converts a fraction (numerator / denominator) into a percentage string.\n *\n * - Uses `decimal.js` for precise decimal calculations.\n * - Supports custom decimal places and optional percentage symbol.\n * - Returns `'0.00%'` if result is `NaN` or division is invalid.\n *\n * @param {CalculableValue} molecular - The numerator of the fraction.\n * @param {CalculableValue} denominator - The denominator of the fraction.\n * @param {ToPercentageStringOptions} [options] - Optional output settings.\n * @returns {string} Formatted percentage string.\n *\n * @example\n * ```typescript\n * import { toPercentageString } from '@kikiutils/shared/math';\n *\n * console.log(toPercentageString(50, 200)); // 25.00%\n * console.log(toPercentageString(50, 200, { withSymbol: false })); // 25.00\n * console.log(toPercentageString(50, 200, { decimalPlaces: 1 })); // 25.0%\n * ```\n */\nexport function toPercentageString(\n    molecular: CalculableValue,\n    denominator: CalculableValue,\n    options?: ToPercentageStringOptions,\n) {\n    const molecularDecimal = new Decimal(molecular.toString());\n    const denominatorDecimal = new Decimal(denominator.toString());\n    const calculationResult = molecularDecimal.div(denominatorDecimal);\n    const result = calculationResult.isNaN()\n        ? '0.00'\n        : calculationResult.times(100).toFixed(options?.decimalPlaces ?? 2);\n\n    return options?.withSymbol ?? true ? `${result}%` : result;\n}\n"],"names":["Decimal"],"mappings":";;;;AAqBA;;;;;;;;;;;;;;;;;;;;AAoBG;SACa,kBAAkB,CAC9B,SAA0B,EAC1B,WAA4B,EAC5B,OAAmC,EAAA;IAEnC,MAAM,gBAAgB,GAAG,IAAIA,kBAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC1D,MAAM,kBAAkB,GAAG,IAAIA,kBAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;IAC9D,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,GAAG,CAAC,kBAAkB,CAAC;AAClE,IAAA,MAAM,MAAM,GAAG,iBAAiB,CAAC,KAAK;AAClC,UAAE;AACF,UAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,IAAI,CAAC,CAAC;AAEvE,IAAA,OAAO,OAAO,EAAE,UAAU,IAAI,IAAI,GAAG,CAAA,EAAG,MAAM,CAAG,CAAA,CAAA,GAAG,MAAM;AAC9D;;;;"}

package/dist/math.d.ts

@@ -0,0 +1,43 @@
+import { Decimal } from 'decimal.js';
+type CalculableValue = Decimal.Value | {
+    toString: () => string;
+};
+/**
+ * Options for configuring the output of `toPercentageString`.
+ */
+export interface ToPercentageStringOptions {
+    /**
+     * Number of decimal places to include in the result.
+     * @default 2
+     */
+    decimalPlaces?: number;
+    /**
+     * Whether to include the '%' symbol in the result.
+     * @default true
+     */
+    withSymbol?: boolean;
+}
+/**
+ * Converts a fraction (numerator / denominator) into a percentage string.
+ *
+ * - Uses `decimal.js` for precise decimal calculations.
+ * - Supports custom decimal places and optional percentage symbol.
+ * - Returns `'0.00%'` if result is `NaN` or division is invalid.
+ *
+ * @param {CalculableValue} molecular - The numerator of the fraction.
+ * @param {CalculableValue} denominator - The denominator of the fraction.
+ * @param {ToPercentageStringOptions} [options] - Optional output settings.
+ * @returns {string} Formatted percentage string.
+ *
+ * @example
+ * ```typescript
+ * import { toPercentageString } from '@kikiutils/shared/math';
+ *
+ * console.log(toPercentageString(50, 200)); // 25.00%
+ * console.log(toPercentageString(50, 200, { withSymbol: false })); // 25.00
+ * console.log(toPercentageString(50, 200, { decimalPlaces: 1 })); // 25.0%
+ * ```
+ */
+export declare function toPercentageString(molecular: CalculableValue, denominator: CalculableValue, options?: ToPercentageStringOptions): string;
+export {};
+//# sourceMappingURL=math.d.ts.map

package/dist/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../src/math.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,KAAK,eAAe,GAAG,OAAO,CAAC,KAAK,GAAG;IAAE,QAAQ,EAAE,MAAM,MAAM,CAAA;CAAE,CAAC;AAElE;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACtC;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAC9B,SAAS,EAAE,eAAe,EAC1B,WAAW,EAAE,eAAe,EAC5B,OAAO,CAAC,EAAE,yBAAyB,UAUtC"}

package/dist/math.mjs

@@ -0,0 +1,35 @@
+import { Decimal } from 'decimal.js';
+
+/**
+ * Converts a fraction (numerator / denominator) into a percentage string.
+ *
+ * - Uses `decimal.js` for precise decimal calculations.
+ * - Supports custom decimal places and optional percentage symbol.
+ * - Returns `'0.00%'` if result is `NaN` or division is invalid.
+ *
+ * @param {CalculableValue} molecular - The numerator of the fraction.
+ * @param {CalculableValue} denominator - The denominator of the fraction.
+ * @param {ToPercentageStringOptions} [options] - Optional output settings.
+ * @returns {string} Formatted percentage string.
+ *
+ * @example
+ * ```typescript
+ * import { toPercentageString } from '@kikiutils/shared/math';
+ *
+ * console.log(toPercentageString(50, 200)); // 25.00%
+ * console.log(toPercentageString(50, 200, { withSymbol: false })); // 25.00
+ * console.log(toPercentageString(50, 200, { decimalPlaces: 1 })); // 25.0%
+ * ```
+ */
+function toPercentageString(molecular, denominator, options) {
+    const molecularDecimal = new Decimal(molecular.toString());
+    const denominatorDecimal = new Decimal(denominator.toString());
+    const calculationResult = molecularDecimal.div(denominatorDecimal);
+    const result = calculationResult.isNaN()
+        ? '0.00'
+        : calculationResult.times(100).toFixed(options?.decimalPlaces ?? 2);
+    return options?.withSymbol ?? true ? `${result}%` : result;
+}
+
+export { toPercentageString };
+//# sourceMappingURL=math.mjs.map

package/dist/math.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.mjs","sources":["../src/math.ts"],"sourcesContent":["import { Decimal } from 'decimal.js';\n\ntype CalculableValue = Decimal.Value | { toString: () => string };\n\n/**\n * Options for configuring the output of `toPercentageString`.\n */\nexport interface ToPercentageStringOptions {\n    /**\n     * Number of decimal places to include in the result.\n     * @default 2\n     */\n    decimalPlaces?: number;\n\n    /**\n     * Whether to include the '%' symbol in the result.\n     * @default true\n     */\n    withSymbol?: boolean;\n}\n\n/**\n * Converts a fraction (numerator / denominator) into a percentage string.\n *\n * - Uses `decimal.js` for precise decimal calculations.\n * - Supports custom decimal places and optional percentage symbol.\n * - Returns `'0.00%'` if result is `NaN` or division is invalid.\n *\n * @param {CalculableValue} molecular - The numerator of the fraction.\n * @param {CalculableValue} denominator - The denominator of the fraction.\n * @param {ToPercentageStringOptions} [options] - Optional output settings.\n * @returns {string} Formatted percentage string.\n *\n * @example\n * ```typescript\n * import { toPercentageString } from '@kikiutils/shared/math';\n *\n * console.log(toPercentageString(50, 200)); // 25.00%\n * console.log(toPercentageString(50, 200, { withSymbol: false })); // 25.00\n * console.log(toPercentageString(50, 200, { decimalPlaces: 1 })); // 25.0%\n * ```\n */\nexport function toPercentageString(\n    molecular: CalculableValue,\n    denominator: CalculableValue,\n    options?: ToPercentageStringOptions,\n) {\n    const molecularDecimal = new Decimal(molecular.toString());\n    const denominatorDecimal = new Decimal(denominator.toString());\n    const calculationResult = molecularDecimal.div(denominatorDecimal);\n    const result = calculationResult.isNaN()\n        ? '0.00'\n        : calculationResult.times(100).toFixed(options?.decimalPlaces ?? 2);\n\n    return options?.withSymbol ?? true ? `${result}%` : result;\n}\n"],"names":[],"mappings":";;AAqBA;;;;;;;;;;;;;;;;;;;;AAoBG;SACa,kBAAkB,CAC9B,SAA0B,EAC1B,WAA4B,EAC5B,OAAmC,EAAA;IAEnC,MAAM,gBAAgB,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC1D,MAAM,kBAAkB,GAAG,IAAI,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;IAC9D,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,GAAG,CAAC,kBAAkB,CAAC;AAClE,IAAA,MAAM,MAAM,GAAG,iBAAiB,CAAC,KAAK;AAClC,UAAE;AACF,UAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,IAAI,CAAC,CAAC;AAEvE,IAAA,OAAO,OAAO,EAAE,UAAU,IAAI,IAAI,GAAG,CAAA,EAAG,MAAM,CAAG,CAAA,CAAA,GAAG,MAAM;AAC9D;;;;"}

package/dist/number.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+const millify = require('millify');
+
+/**
+ * Converts a large number into a compact, human-readable string using `millify`.
+ *
+ * Applies lowercase units (e.g. 'k', 'm') and default precision of 2, unless overridden.
+ *
+ * @param {number} value - The number to format.
+ * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`.
+ * @returns {string} The compact number string.
+ *
+ * @example
+ * ```typescript
+ * import { toCompactNumberString } from '@kikiutils/shared/number';
+ *
+ * console.log(toCompactNumberString(1234567)); // 1.23m
+ * console.log(toCompactNumberString(1234567, { precision: 3 })); // 1.235m
+ * ```
+ */
+function toCompactNumberString(value, options) {
+    return millify.millify(value, {
+        lowercase: true,
+        precision: 2,
+        ...options,
+    });
+}
+
+exports.toCompactNumberString = toCompactNumberString;
+//# sourceMappingURL=number.cjs.map

package/dist/number.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.cjs","sources":["../src/number.ts"],"sourcesContent":["import { millify } from 'millify';\n\n/**\n * Converts a large number into a compact, human-readable string using `millify`.\n *\n * Applies lowercase units (e.g. 'k', 'm') and default precision of 2, unless overridden.\n *\n * @param {number} value - The number to format.\n * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`.\n * @returns {string} The compact number string.\n *\n * @example\n * ```typescript\n * import { toCompactNumberString } from '@kikiutils/shared/number';\n *\n * console.log(toCompactNumberString(1234567)); // 1.23m\n * console.log(toCompactNumberString(1234567, { precision: 3 })); // 1.235m\n * ```\n */\nexport function toCompactNumberString(value: number, options?: Parameters<typeof millify>[1]) {\n    return millify(\n        value,\n        {\n            lowercase: true,\n            precision: 2,\n            ...options,\n        },\n    );\n}\n"],"names":["millify"],"mappings":";;;;AAEA;;;;;;;;;;;;;;;;AAgBG;AACa,SAAA,qBAAqB,CAAC,KAAa,EAAE,OAAuC,EAAA;IACxF,OAAOA,eAAO,CACV,KAAK,EACL;AACI,QAAA,SAAS,EAAE,IAAI;AACf,QAAA,SAAS,EAAE,CAAC;AACZ,QAAA,GAAG,OAAO;AACb,KAAA,CACJ;AACL;;;;"}

package/dist/number.d.ts

@@ -0,0 +1,20 @@
+import { millify } from 'millify';
+/**
+ * Converts a large number into a compact, human-readable string using `millify`.
+ *
+ * Applies lowercase units (e.g. 'k', 'm') and default precision of 2, unless overridden.
+ *
+ * @param {number} value - The number to format.
+ * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`.
+ * @returns {string} The compact number string.
+ *
+ * @example
+ * ```typescript
+ * import { toCompactNumberString } from '@kikiutils/shared/number';
+ *
+ * console.log(toCompactNumberString(1234567)); // 1.23m
+ * console.log(toCompactNumberString(1234567, { precision: 3 })); // 1.235m
+ * ```
+ */
+export declare function toCompactNumberString(value: number, options?: Parameters<typeof millify>[1]): string;
+//# sourceMappingURL=number.d.ts.map

package/dist/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../src/number.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAElC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,UAS3F"}

package/dist/number.mjs

@@ -0,0 +1,29 @@
+import { millify } from 'millify';
+
+/**
+ * Converts a large number into a compact, human-readable string using `millify`.
+ *
+ * Applies lowercase units (e.g. 'k', 'm') and default precision of 2, unless overridden.
+ *
+ * @param {number} value - The number to format.
+ * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`.
+ * @returns {string} The compact number string.
+ *
+ * @example
+ * ```typescript
+ * import { toCompactNumberString } from '@kikiutils/shared/number';
+ *
+ * console.log(toCompactNumberString(1234567)); // 1.23m
+ * console.log(toCompactNumberString(1234567, { precision: 3 })); // 1.235m
+ * ```
+ */
+function toCompactNumberString(value, options) {
+    return millify(value, {
+        lowercase: true,
+        precision: 2,
+        ...options,
+    });
+}
+
+export { toCompactNumberString };
+//# sourceMappingURL=number.mjs.map

package/dist/number.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.mjs","sources":["../src/number.ts"],"sourcesContent":["import { millify } from 'millify';\n\n/**\n * Converts a large number into a compact, human-readable string using `millify`.\n *\n * Applies lowercase units (e.g. 'k', 'm') and default precision of 2, unless overridden.\n *\n * @param {number} value - The number to format.\n * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`.\n * @returns {string} The compact number string.\n *\n * @example\n * ```typescript\n * import { toCompactNumberString } from '@kikiutils/shared/number';\n *\n * console.log(toCompactNumberString(1234567)); // 1.23m\n * console.log(toCompactNumberString(1234567, { precision: 3 })); // 1.235m\n * ```\n */\nexport function toCompactNumberString(value: number, options?: Parameters<typeof millify>[1]) {\n    return millify(\n        value,\n        {\n            lowercase: true,\n            precision: 2,\n            ...options,\n        },\n    );\n}\n"],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;AAgBG;AACa,SAAA,qBAAqB,CAAC,KAAa,EAAE,OAAuC,EAAA;IACxF,OAAO,OAAO,CACV,KAAK,EACL;AACI,QAAA,SAAS,EAAE,IAAI;AACf,QAAA,SAAS,EAAE,CAAC;AACZ,QAAA,GAAG,OAAO;AACb,KAAA,CACJ;AACL;;;;"}

package/dist/pino.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+const pino = require('pino');
+const pinoPretty = require('pino-pretty');
+
+/**
+ * Configure pinoPretty to enhance the log output.
+ */
+const stream = pinoPretty.PinoPretty({
+    colorize: true, // Enable colored output for better readability
+    ignore: 'hostname,pid', // Exclude 'hostname' and 'pid' fields from the logs
+    translateTime: 'SYS:yyyy-mm-dd HH:MM:ss.l', // Format the timestamp in 'yyyy-mm-dd HH:MM:ss.l' format
+});
+/**
+ * A pino logger instance with the configured stream.
+ *
+ * The logger's level is determined based on the `PINO_LOGGER_LEVEL` and `NODE_ENV` environment variables.
+ * If `PINO_LOGGER_LEVEL` is set, it will be used; otherwise, if `NODE_ENV` is `production`,
+ * the level will be set to `error`.
+ *
+ * To manually change the level, assign the desired level to `logger.level`.
+ *
+ * See available levels [here](https://getpino.io/#/docs/api?id=level-string).
+ *
+ * @example
+ * ```typescript
+ * import logger from '@kikiutils/shared/pino';
+ *
+ * logger.info('test'); // [2024-07-11 12:12:30.085] INFO: test
+ *
+ * // Manually change the level
+ * logger.level = 'info';
+ * ```
+ */
+const pinoLogger = pino.pino({}, stream);
+const logger = pinoLogger;
+// eslint-disable-next-line style/max-len
+pinoLogger.level = process.env.PINO_LOGGER_LEVEL || (process.env.NODE_ENV === 'production' ? 'error' : pinoLogger.level);
+
+exports.logger = logger;
+exports.pinoLogger = pinoLogger;
+//# sourceMappingURL=pino.cjs.map

package/dist/pino.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pino.cjs","sources":["../src/pino.ts"],"sourcesContent":["import { pino } from 'pino';\nimport { PinoPretty } from 'pino-pretty';\n\n/**\n * Configure pinoPretty to enhance the log output.\n */\nconst stream = PinoPretty({\n    colorize: true, // Enable colored output for better readability\n    ignore: 'hostname,pid', // Exclude 'hostname' and 'pid' fields from the logs\n    translateTime: 'SYS:yyyy-mm-dd HH:MM:ss.l', // Format the timestamp in 'yyyy-mm-dd HH:MM:ss.l' format\n});\n\n/**\n * A pino logger instance with the configured stream.\n *\n * The logger's level is determined based on the `PINO_LOGGER_LEVEL` and `NODE_ENV` environment variables.\n * If `PINO_LOGGER_LEVEL` is set, it will be used; otherwise, if `NODE_ENV` is `production`,\n * the level will be set to `error`.\n *\n * To manually change the level, assign the desired level to `logger.level`.\n *\n * See available levels [here](https://getpino.io/#/docs/api?id=level-string).\n *\n * @example\n * ```typescript\n * import logger from '@kikiutils/shared/pino';\n *\n * logger.info('test'); // [2024-07-11 12:12:30.085] INFO: test\n *\n * // Manually change the level\n * logger.level = 'info';\n * ```\n */\nexport const pinoLogger = pino({}, stream);\nexport const logger = pinoLogger;\n// eslint-disable-next-line style/max-len\npinoLogger.level = process.env.PINO_LOGGER_LEVEL || (process.env.NODE_ENV === 'production' ? 'error' : pinoLogger.level);\n"],"names":["PinoPretty","pino"],"mappings":";;;;;AAGA;;AAEG;AACH,MAAM,MAAM,GAAGA,qBAAU,CAAC;IACtB,QAAQ,EAAE,IAAI;IACd,MAAM,EAAE,cAAc;IACtB,aAAa,EAAE,2BAA2B;AAC7C,CAAA,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;AAoBG;AACU,MAAA,UAAU,GAAGC,SAAI,CAAC,EAAE,EAAE,MAAM;AAClC,MAAM,MAAM,GAAG;AACtB;AACA,UAAU,CAAC,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,iBAAiB,KAAK,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,GAAG,OAAO,GAAG,UAAU,CAAC,KAAK,CAAC;;;;;"}

package/dist/pino.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A pino logger instance with the configured stream.
+ *
+ * The logger's level is determined based on the `PINO_LOGGER_LEVEL` and `NODE_ENV` environment variables.
+ * If `PINO_LOGGER_LEVEL` is set, it will be used; otherwise, if `NODE_ENV` is `production`,
+ * the level will be set to `error`.
+ *
+ * To manually change the level, assign the desired level to `logger.level`.
+ *
+ * See available levels [here](https://getpino.io/#/docs/api?id=level-string).
+ *
+ * @example
+ * ```typescript
+ * import logger from '@kikiutils/shared/pino';
+ *
+ * logger.info('test'); // [2024-07-11 12:12:30.085] INFO: test
+ *
+ * // Manually change the level
+ * logger.level = 'info';
+ * ```
+ */
+export declare const pinoLogger: import("pino").Logger<never, boolean>;
+export declare const logger: import("pino").Logger<never, boolean>;
+//# sourceMappingURL=pino.d.ts.map

package/dist/pino.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pino.d.ts","sourceRoot":"","sources":["../src/pino.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,UAAU,uCAAmB,CAAC;AAC3C,eAAO,MAAM,MAAM,uCAAa,CAAC"}

package/dist/pino.mjs

@@ -0,0 +1,39 @@
+import { pino } from 'pino';
+import { PinoPretty } from 'pino-pretty';
+
+/**
+ * Configure pinoPretty to enhance the log output.
+ */
+const stream = PinoPretty({
+    colorize: true, // Enable colored output for better readability
+    ignore: 'hostname,pid', // Exclude 'hostname' and 'pid' fields from the logs
+    translateTime: 'SYS:yyyy-mm-dd HH:MM:ss.l', // Format the timestamp in 'yyyy-mm-dd HH:MM:ss.l' format
+});
+/**
+ * A pino logger instance with the configured stream.
+ *
+ * The logger's level is determined based on the `PINO_LOGGER_LEVEL` and `NODE_ENV` environment variables.
+ * If `PINO_LOGGER_LEVEL` is set, it will be used; otherwise, if `NODE_ENV` is `production`,
+ * the level will be set to `error`.
+ *
+ * To manually change the level, assign the desired level to `logger.level`.
+ *
+ * See available levels [here](https://getpino.io/#/docs/api?id=level-string).
+ *
+ * @example
+ * ```typescript
+ * import logger from '@kikiutils/shared/pino';
+ *
+ * logger.info('test'); // [2024-07-11 12:12:30.085] INFO: test
+ *
+ * // Manually change the level
+ * logger.level = 'info';
+ * ```
+ */
+const pinoLogger = pino({}, stream);
+const logger = pinoLogger;
+// eslint-disable-next-line style/max-len
+pinoLogger.level = process.env.PINO_LOGGER_LEVEL || (process.env.NODE_ENV === 'production' ? 'error' : pinoLogger.level);
+
+export { logger, pinoLogger };
+//# sourceMappingURL=pino.mjs.map

package/dist/pino.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pino.mjs","sources":["../src/pino.ts"],"sourcesContent":["import { pino } from 'pino';\nimport { PinoPretty } from 'pino-pretty';\n\n/**\n * Configure pinoPretty to enhance the log output.\n */\nconst stream = PinoPretty({\n    colorize: true, // Enable colored output for better readability\n    ignore: 'hostname,pid', // Exclude 'hostname' and 'pid' fields from the logs\n    translateTime: 'SYS:yyyy-mm-dd HH:MM:ss.l', // Format the timestamp in 'yyyy-mm-dd HH:MM:ss.l' format\n});\n\n/**\n * A pino logger instance with the configured stream.\n *\n * The logger's level is determined based on the `PINO_LOGGER_LEVEL` and `NODE_ENV` environment variables.\n * If `PINO_LOGGER_LEVEL` is set, it will be used; otherwise, if `NODE_ENV` is `production`,\n * the level will be set to `error`.\n *\n * To manually change the level, assign the desired level to `logger.level`.\n *\n * See available levels [here](https://getpino.io/#/docs/api?id=level-string).\n *\n * @example\n * ```typescript\n * import logger from '@kikiutils/shared/pino';\n *\n * logger.info('test'); // [2024-07-11 12:12:30.085] INFO: test\n *\n * // Manually change the level\n * logger.level = 'info';\n * ```\n */\nexport const pinoLogger = pino({}, stream);\nexport const logger = pinoLogger;\n// eslint-disable-next-line style/max-len\npinoLogger.level = process.env.PINO_LOGGER_LEVEL || (process.env.NODE_ENV === 'production' ? 'error' : pinoLogger.level);\n"],"names":[],"mappings":";;;AAGA;;AAEG;AACH,MAAM,MAAM,GAAG,UAAU,CAAC;IACtB,QAAQ,EAAE,IAAI;IACd,MAAM,EAAE,cAAc;IACtB,aAAa,EAAE,2BAA2B;AAC7C,CAAA,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;AAoBG;AACU,MAAA,UAAU,GAAG,IAAI,CAAC,EAAE,EAAE,MAAM;AAClC,MAAM,MAAM,GAAG;AACtB;AACA,UAAU,CAAC,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,iBAAiB,KAAK,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,GAAG,OAAO,GAAG,UAAU,CAAC,KAAK,CAAC;;;;"}

package/dist/random.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+/**
+ * Generates a value using a provided generator function, where the input length
+ * is determined by two levels of nested random ranges:
+ *
+ * 1. First, a random number (`innerMin`) is chosen between `minMin` and `minMax`.
+ * 2. Then, a final length is chosen between `Math.max(innerMin, maxMin)` and `maxMax`.
+ * 3. The generator is called with the final length and its result is returned.
+ *
+ * This function supports any return type by using a generic type parameter.
+ *
+ * @typeParam T - The return type of the generator function.
+ *
+ * @param generator - A function that accepts a length and returns a value of type T.
+ * @param minMin - Lower bound of the first random range.
+ * @param minMax - Upper bound of the first random range.
+ * @param maxMin - Lower bound of the second random range.
+ * @param maxMax - Upper bound of the second random range.
+ * @returns The result of the generator function using the computed final length.
+ */
+function generateWithNestedRandomLength(generator, minMin, minMax, maxMin, maxMax) {
+    const random = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
+    const innerMin = random(minMin, minMax);
+    const finalLength = random(Math.max(innerMin, maxMin), maxMax);
+    return generator(finalLength);
+}
+
+exports.generateWithNestedRandomLength = generateWithNestedRandomLength;
+//# sourceMappingURL=random.cjs.map

package/dist/random.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.cjs","sources":["../src/random.ts"],"sourcesContent":["/**\n * Generates a value using a provided generator function, where the input length\n * is determined by two levels of nested random ranges:\n *\n * 1. First, a random number (`innerMin`) is chosen between `minMin` and `minMax`.\n * 2. Then, a final length is chosen between `Math.max(innerMin, maxMin)` and `maxMax`.\n * 3. The generator is called with the final length and its result is returned.\n *\n * This function supports any return type by using a generic type parameter.\n *\n * @typeParam T - The return type of the generator function.\n *\n * @param generator - A function that accepts a length and returns a value of type T.\n * @param minMin - Lower bound of the first random range.\n * @param minMax - Upper bound of the first random range.\n * @param maxMin - Lower bound of the second random range.\n * @param maxMax - Upper bound of the second random range.\n * @returns The result of the generator function using the computed final length.\n */\nexport function generateWithNestedRandomLength<T = string>(\n    generator: (length: number) => T,\n    minMin: number,\n    minMax: number,\n    maxMin: number,\n    maxMax: number,\n) {\n    const random = (min: number, max: number) => Math.floor(Math.random() * (max - min + 1)) + min;\n    const innerMin = random(minMin, minMax);\n    const finalLength = random(Math.max(innerMin, maxMin), maxMax);\n    return generator(finalLength);\n}\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;;;;AAkBG;AACG,SAAU,8BAA8B,CAC1C,SAAgC,EAChC,MAAc,EACd,MAAc,EACd,MAAc,EACd,MAAc,EAAA;AAEd,IAAA,MAAM,MAAM,GAAG,CAAC,GAAW,EAAE,GAAW,KAAK,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG;IAC9F,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;AACvC,IAAA,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC;AAC9D,IAAA,OAAO,SAAS,CAAC,WAAW,CAAC;AACjC;;;;"}

package/dist/random.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Generates a value using a provided generator function, where the input length
+ * is determined by two levels of nested random ranges:
+ *
+ * 1. First, a random number (`innerMin`) is chosen between `minMin` and `minMax`.
+ * 2. Then, a final length is chosen between `Math.max(innerMin, maxMin)` and `maxMax`.
+ * 3. The generator is called with the final length and its result is returned.
+ *
+ * This function supports any return type by using a generic type parameter.
+ *
+ * @typeParam T - The return type of the generator function.
+ *
+ * @param generator - A function that accepts a length and returns a value of type T.
+ * @param minMin - Lower bound of the first random range.
+ * @param minMax - Upper bound of the first random range.
+ * @param maxMin - Lower bound of the second random range.
+ * @param maxMax - Upper bound of the second random range.
+ * @returns The result of the generator function using the computed final length.
+ */
+export declare function generateWithNestedRandomLength<T = string>(generator: (length: number) => T, minMin: number, minMax: number, maxMin: number, maxMax: number): T;
+//# sourceMappingURL=random.d.ts.map

package/dist/random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../src/random.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,8BAA8B,CAAC,CAAC,GAAG,MAAM,EACrD,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,CAAC,EAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,KAMjB"}

package/dist/random.mjs

@@ -0,0 +1,28 @@
+/**
+ * Generates a value using a provided generator function, where the input length
+ * is determined by two levels of nested random ranges:
+ *
+ * 1. First, a random number (`innerMin`) is chosen between `minMin` and `minMax`.
+ * 2. Then, a final length is chosen between `Math.max(innerMin, maxMin)` and `maxMax`.
+ * 3. The generator is called with the final length and its result is returned.
+ *
+ * This function supports any return type by using a generic type parameter.
+ *
+ * @typeParam T - The return type of the generator function.
+ *
+ * @param generator - A function that accepts a length and returns a value of type T.
+ * @param minMin - Lower bound of the first random range.
+ * @param minMax - Upper bound of the first random range.
+ * @param maxMin - Lower bound of the second random range.
+ * @param maxMax - Upper bound of the second random range.
+ * @returns The result of the generator function using the computed final length.
+ */
+function generateWithNestedRandomLength(generator, minMin, minMax, maxMin, maxMax) {
+    const random = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
+    const innerMin = random(minMin, minMax);
+    const finalLength = random(Math.max(innerMin, maxMin), maxMax);
+    return generator(finalLength);
+}
+
+export { generateWithNestedRandomLength };
+//# sourceMappingURL=random.mjs.map

package/dist/random.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.mjs","sources":["../src/random.ts"],"sourcesContent":["/**\n * Generates a value using a provided generator function, where the input length\n * is determined by two levels of nested random ranges:\n *\n * 1. First, a random number (`innerMin`) is chosen between `minMin` and `minMax`.\n * 2. Then, a final length is chosen between `Math.max(innerMin, maxMin)` and `maxMax`.\n * 3. The generator is called with the final length and its result is returned.\n *\n * This function supports any return type by using a generic type parameter.\n *\n * @typeParam T - The return type of the generator function.\n *\n * @param generator - A function that accepts a length and returns a value of type T.\n * @param minMin - Lower bound of the first random range.\n * @param minMax - Upper bound of the first random range.\n * @param maxMin - Lower bound of the second random range.\n * @param maxMax - Upper bound of the second random range.\n * @returns The result of the generator function using the computed final length.\n */\nexport function generateWithNestedRandomLength<T = string>(\n    generator: (length: number) => T,\n    minMin: number,\n    minMax: number,\n    maxMin: number,\n    maxMax: number,\n) {\n    const random = (min: number, max: number) => Math.floor(Math.random() * (max - min + 1)) + min;\n    const innerMin = random(minMin, minMax);\n    const finalLength = random(Math.max(innerMin, maxMin), maxMax);\n    return generator(finalLength);\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;AAkBG;AACG,SAAU,8BAA8B,CAC1C,SAAgC,EAChC,MAAc,EACd,MAAc,EACd,MAAc,EACd,MAAc,EAAA;AAEd,IAAA,MAAM,MAAM,GAAG,CAAC,GAAW,EAAE,GAAW,KAAK,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG;IAC9F,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;AACvC,IAAA,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC;AAC9D,IAAA,OAAO,SAAS,CAAC,WAAW,CAAC;AACjC;;;;"}

package/dist/string.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+const DIGITS = '0123456789';
+const LOWERCASE = 'abcdefghijklmnopqrstuvwxyz';
+const UPPERCASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const CHARSETS = {
+    'alphabetic': LOWERCASE + UPPERCASE,
+    'alphanumeric': DIGITS + LOWERCASE + UPPERCASE,
+    'lowercase': LOWERCASE,
+    'lowercase-numeric': DIGITS + LOWERCASE,
+    'numeric': DIGITS,
+    'uppercase': UPPERCASE,
+    'uppercase-numeric': DIGITS + UPPERCASE,
+};
+/**
+ * Generates a random string of a given length using a specified character set.
+ *
+ * @param {number} length - The length of the string to generate. Must be a positive integer.
+ * @param {RandomStringMode} [mode] - The character set to use.
+ * @returns {string} The generated random string.
+ *
+ * @throws {Error} If the length is not a positive integer or the mode is unsupported.
+ *
+ * @example
+ * ```typescript
+ * import { randomString } from '@kikiutils/shared/string';
+ *
+ * console.log(randomString(8)); // e.g. 'aZbXwTyQ' (alphabetic)
+ * console.log(randomString(6, 'numeric')); // e.g. '402398'
+ * console.log(randomString(10, 'alphanumeric')); // e.g. 'a9Z4pQ8xY2'
+ * ```
+ */
+function randomString(length, mode = 'alphabetic') {
+    if (!Number.isInteger(length) || length <= 0) {
+        throw new Error(`Invalid length: ${length}. Must be a positive integer.`);
+    }
+    const charset = CHARSETS[mode];
+    if (!charset)
+        throw new Error(`Unsupported mode: ${mode}`);
+    return Array.from({ length }, () => charset[Math.floor(Math.random() * charset.length)]).join('');
+}
+
+exports.randomString = randomString;
+//# sourceMappingURL=string.cjs.map

package/dist/string.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.cjs","sources":["../src/string.ts"],"sourcesContent":["export type RandomStringMode =\n  | 'alphabetic'\n  | 'alphanumeric'\n  | 'lowercase'\n  | 'lowercase-numeric'\n  | 'numeric'\n  | 'uppercase'\n  | 'uppercase-numeric';\n\nconst DIGITS = '0123456789';\nconst LOWERCASE = 'abcdefghijklmnopqrstuvwxyz';\nconst UPPERCASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';\nconst CHARSETS: Record<RandomStringMode, string> = {\n    'alphabetic': LOWERCASE + UPPERCASE,\n    'alphanumeric': DIGITS + LOWERCASE + UPPERCASE,\n    'lowercase': LOWERCASE,\n    'lowercase-numeric': DIGITS + LOWERCASE,\n    'numeric': DIGITS,\n    'uppercase': UPPERCASE,\n    'uppercase-numeric': DIGITS + UPPERCASE,\n};\n\n/**\n * Generates a random string of a given length using a specified character set.\n *\n * @param {number} length - The length of the string to generate. Must be a positive integer.\n * @param {RandomStringMode} [mode] - The character set to use.\n * @returns {string} The generated random string.\n *\n * @throws {Error} If the length is not a positive integer or the mode is unsupported.\n *\n * @example\n * ```typescript\n * import { randomString } from '@kikiutils/shared/string';\n *\n * console.log(randomString(8)); // e.g. 'aZbXwTyQ' (alphabetic)\n * console.log(randomString(6, 'numeric')); // e.g. '402398'\n * console.log(randomString(10, 'alphanumeric')); // e.g. 'a9Z4pQ8xY2'\n * ```\n */\nexport function randomString(length: number, mode: RandomStringMode = 'alphabetic') {\n    if (!Number.isInteger(length) || length <= 0) {\n        throw new Error(`Invalid length: ${length}. Must be a positive integer.`);\n    }\n\n    const charset = CHARSETS[mode];\n    if (!charset) throw new Error(`Unsupported mode: ${mode}`);\n    return Array.from({ length }, () => charset[Math.floor(Math.random() * charset.length)]).join('');\n}\n"],"names":[],"mappings":";;AASA,MAAM,MAAM,GAAG,YAAY;AAC3B,MAAM,SAAS,GAAG,4BAA4B;AAC9C,MAAM,SAAS,GAAG,4BAA4B;AAC9C,MAAM,QAAQ,GAAqC;IAC/C,YAAY,EAAE,SAAS,GAAG,SAAS;AACnC,IAAA,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;AAC9C,IAAA,WAAW,EAAE,SAAS;IACtB,mBAAmB,EAAE,MAAM,GAAG,SAAS;AACvC,IAAA,SAAS,EAAE,MAAM;AACjB,IAAA,WAAW,EAAE,SAAS;IACtB,mBAAmB,EAAE,MAAM,GAAG,SAAS;CAC1C;AAED;;;;;;;;;;;;;;;;;AAiBG;SACa,YAAY,CAAC,MAAc,EAAE,OAAyB,YAAY,EAAA;AAC9E,IAAA,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC,EAAE;AAC1C,QAAA,MAAM,IAAI,KAAK,CAAC,mBAAmB,MAAM,CAAA,6BAAA,CAA+B,CAAC;;AAG7E,IAAA,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC;AAC9B,IAAA,IAAI,CAAC,OAAO;AAAE,QAAA,MAAM,IAAI,KAAK,CAAC,qBAAqB,IAAI,CAAA,CAAE,CAAC;AAC1D,IAAA,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;AACrG;;;;"}

package/dist/string.d.ts

@@ -0,0 +1,21 @@
+export type RandomStringMode = 'alphabetic' | 'alphanumeric' | 'lowercase' | 'lowercase-numeric' | 'numeric' | 'uppercase' | 'uppercase-numeric';
+/**
+ * Generates a random string of a given length using a specified character set.
+ *
+ * @param {number} length - The length of the string to generate. Must be a positive integer.
+ * @param {RandomStringMode} [mode] - The character set to use.
+ * @returns {string} The generated random string.
+ *
+ * @throws {Error} If the length is not a positive integer or the mode is unsupported.
+ *
+ * @example
+ * ```typescript
+ * import { randomString } from '@kikiutils/shared/string';
+ *
+ * console.log(randomString(8)); // e.g. 'aZbXwTyQ' (alphabetic)
+ * console.log(randomString(6, 'numeric')); // e.g. '402398'
+ * console.log(randomString(10, 'alphanumeric')); // e.g. 'a9Z4pQ8xY2'
+ * ```
+ */
+export declare function randomString(length: number, mode?: RandomStringMode): string;
+//# sourceMappingURL=string.d.ts.map

package/dist/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../src/string.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GACxB,YAAY,GACZ,cAAc,GACd,WAAW,GACX,mBAAmB,GACnB,SAAS,GACT,WAAW,GACX,mBAAmB,CAAC;AAexB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE,gBAA+B,UAQjF"}