@ooneex/utils 0.0.5 → 0.0.8

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ooneex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,335 +1,671 @@
 # @ooneex/utils
 
-A comprehensive collection of utility functions for common programming tasks including string manipulation, number formatting, time conversion, and more.
+A comprehensive TypeScript/JavaScript utility library providing essential helper functions for string manipulation, time formatting, data parsing, and more. This package offers a collection of lightweight, type-safe utilities designed to streamline common development tasks across web applications.
+
+![Browser](https://img.shields.io/badge/Browser-Compatible-green?style=flat-square&logo=googlechrome)
+![Bun](https://img.shields.io/badge/Bun-Compatible-orange?style=flat-square&logo=bun)
+![Deno](https://img.shields.io/badge/Deno-Compatible-blue?style=flat-square&logo=deno)
+![Node.js](https://img.shields.io/badge/Node.js-Compatible-green?style=flat-square&logo=node.js)
+![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue?style=flat-square&logo=typescript)
+![MIT License](https://img.shields.io/badge/License-MIT-yellow?style=flat-square)
+
+## Features
+
+✅ **String Manipulation** - Case conversion utilities (camelCase, PascalCase, kebab-case)
+
+✅ **Time Formatting** - Convert seconds/milliseconds to human-readable formats
+
+✅ **Data Parsing** - Intelligent string parsing with type inference
+
+✅ **Type-Safe** - Full TypeScript support with proper type definitions
+
+✅ **Lightweight** - Minimal dependencies and optimized bundle size
+
+✅ **Cross-Platform** - Works in Browser, Node.js, Bun, and Deno
+
+✅ **Environment Variables** - Parse and transform environment variables
+
+✅ **File Utilities** - Convert data URLs to File objects
+
+✅ **Random Generation** - Generate random IDs and strings
+
+✅ **Number Formatting** - Format numbers with locale-aware compact notation
+
+✅ **Zero Dependencies** - Only one small dependency (nanoid) for random generation
 
 ## Installation
 
+### Bun
 ```bash
-npm install @ooneex/utils
-# or
 bun add @ooneex/utils
-# or
-yarn add @ooneex/utils
-# or
+```
+
+### pnpm
+```bash
 pnpm add @ooneex/utils
 ```
 
+### Yarn
+```bash
+yarn add @ooneex/utils
+```
+
+### npm
+```bash
+npm install @ooneex/utils
+```
+
 ## Usage
 
+### String Manipulation
+
 ```typescript
-import { capitalizeWord, formatRelativeNumber, random, sleep, dataURLtoFile } from '@ooneex/utils';
+import {
+  capitalizeWord,
+  toCamelCase,
+  toPascalCase,
+  toKebabCase,
+  splitToWords,
+  trim
+} from '@ooneex/utils';
+
+// Capitalize words
+console.log(capitalizeWord('hello')); // 'Hello'
+console.log(capitalizeWord('WORLD')); // 'World'
+
+// Case conversions
+console.log(toCamelCase('hello world')); // 'helloWorld'
+console.log(toPascalCase('hello world')); // 'HelloWorld'
+console.log(toKebabCase('Hello World')); // 'hello-world'
+
+// Split strings to words
+console.log(splitToWords('HelloWorldExample')); // ['Hello', 'World', 'Example']
+console.log(splitToWords('hello-world_example')); // ['hello', 'world', 'example']
+
+// Advanced trimming
+console.log(trim('...hello...', '\\.')); // 'hello'
+console.log(trim('[test]', '\\[|\\]')); // 'test'
 ```
 
-## API Reference
+### Time Formatting
 
-### File Utilities
+```typescript
+import {
+  secondsToHMS,
+  secondsToMS,
+  millisecondsToHMS,
+  sleep
+} from '@ooneex/utils';
+
+// Convert seconds to time formats
+console.log(secondsToHMS(3661)); // '1:01:01'
+console.log(secondsToHMS(125)); // '2:05'
+console.log(secondsToHMS(45)); // '45'
+
+console.log(secondsToMS(125)); // '2:05'
+console.log(secondsToMS(45)); // '0:45'
+
+// Convert milliseconds to time format
+console.log(millisecondsToHMS(3661000)); // '1:01:01'
+console.log(millisecondsToHMS(125000)); // '2:05'
+
+// Async sleep utility
+await sleep(1000); // Wait 1 second
+```
 
-#### `dataURLtoFile(dataurl: string, filename: string): File`
+### Data Parsing
 
-Converts a data URL string into a File object, useful for handling base64-encoded file data.
+```typescript
+import { parseString, parseEnvVars } from '@ooneex/utils';
+
+// Intelligent string parsing with type inference
+console.log(parseString('123')); // 123 (number)
+console.log(parseString('12.34')); // 12.34 (number)
+console.log(parseString('true')); // true (boolean)
+console.log(parseString('false')); // false (boolean)
+console.log(parseString('null')); // null
+console.log(parseString('[1,2,3]')); // [1, 2, 3] (array)
+console.log(parseString('{"name":"John"}')); // {name: "John"} (object)
+console.log(parseString('1e5')); // 100000 (scientific notation)
+console.log(parseString('hello')); // 'hello' (string fallback)
+
+// Parse environment variables
+const envs = {
+  'API_PORT': '3000',
+  'DEBUG_MODE': 'true',
+  'ALLOWED_HOSTS': '["localhost", "127.0.0.1"]'
+};
+
+const parsed = parseEnvVars(envs);
+// Result: { apiPort: 3000, debugMode: true, allowedHosts: ['localhost', '127.0.0.1'] }
+```
+
+### Number Formatting
+
+```typescript
+import { formatRelativeNumber } from '@ooneex/utils';
+
+// Format numbers with compact notation
+console.log(formatRelativeNumber(1000)); // '1K'
+console.log(formatRelativeNumber(1500)); // '1.5K'
+console.log(formatRelativeNumber(1000000)); // '1M'
+console.log(formatRelativeNumber(2500000)); // '2.5M'
+console.log(formatRelativeNumber(1000000000)); // '1B'
+
+// Custom precision
+console.log(formatRelativeNumber(1234, { precision: 2 })); // '1.23K'
+console.log(formatRelativeNumber(1234, { precision: 0 })); // '1K'
+
+// Different locales
+console.log(formatRelativeNumber(1500, { lang: 'de-DE' })); // '1500'
+console.log(formatRelativeNumber(1500000, { lang: 'de-DE' })); // '1,5 Mio.'
+console.log(formatRelativeNumber(1500, { lang: 'fr-FR' })); // '1,5 k'
+```
+
+### File Utilities
 
-**Examples:**
 ```typescript
 import { dataURLtoFile } from '@ooneex/utils';
 
-// Convert a data URL to a File object
+// Convert data URL to File object
 const dataUrl = 'data:text/plain;base64,SGVsbG8gV29ybGQ=';
 const file = dataURLtoFile(dataUrl, 'hello.txt');
 
-// Use with image data URLs
-const imageDataUrl = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB...';
-const imageFile = dataURLtoFile(imageDataUrl, 'image.png');
-
-// The resulting File object can be used in FormData or uploaded
-const formData = new FormData();
-formData.append('file', file);
+console.log(file.name); // 'hello.txt'
+console.log(file.type); // 'text/plain'
+console.log(file.size); // 11
 ```
 
-### String Utilities
+### Random Generation
 
-#### `capitalizeWord(word: string): string`
+```typescript
+import { random } from '@ooneex/utils';
 
-Capitalizes the first letter of a word and makes the rest lowercase.
+// Generate random hex strings
+console.log(random.nanoid()); // 'a1b2c3d4e5' (10 chars default)
+console.log(random.nanoid(8)); // 'f6e5d4c3' (8 chars)
 
-**Examples:**
-```typescript
-import { capitalizeWord } from '@ooneex/utils';
+// Generate numeric strings
+console.log(random.stringInt()); // '1234567890' (10 digits default)
+console.log(random.stringInt(6)); // '123456' (6 digits)
 
-capitalizeWord('hello');      // 'Hello'
-capitalizeWord('WORLD');      // 'World'
-capitalizeWord('javaScript'); // 'Javascript'
-capitalizeWord('');           // ''
+// Create a factory function
+const generateId = random.nanoidFactory(12);
+console.log(generateId()); // 12-character hex string
+console.log(generateId(8)); // 8-character hex string (overrides factory size)
 ```
 
-#### `splitToWords(input: string): string[]`
+## API Reference
+
+### String Utilities
+
+#### `capitalizeWord(word: string): string`
+Capitalizes the first letter and lowercases the rest.
 
-Splits a string into an array of words, handling camelCase, PascalCase, kebab-case, snake_case, and more.
+**Parameters:**
+- `word` - The word to capitalize
 
-**Examples:**
+**Returns:** Capitalized word
+
+**Example:**
 ```typescript
-import { splitToWords } from '@ooneex/utils';
-
-splitToWords('helloWorld');           // ['hello', 'World']
-splitToWords('PascalCaseString');     // ['Pascal', 'Case', 'String']
-splitToWords('kebab-case-string');    // ['kebab', 'case', 'string']
-splitToWords('snake_case_string');    // ['snake', 'case', 'string']
-splitToWords('HTMLElement123');       // ['HTML', 'Element', '123']
-splitToWords('URLParser');            // ['URL', 'Parser']
+capitalizeWord('hello'); // 'Hello'
+capitalizeWord('WORLD'); // 'World'
+capitalizeWord(''); // ''
 ```
 
 #### `toCamelCase(input: string): string`
+Converts string to camelCase.
 
-Converts a string to camelCase.
+**Parameters:**
+- `input` - The string to convert
 
-**Examples:**
-```typescript
-import { toCamelCase } from '@ooneex/utils';
+**Returns:** camelCase string
 
-toCamelCase('hello world');           // 'helloWorld'
-toCamelCase('PascalCaseString');      // 'pascalCaseString'
-toCamelCase('kebab-case-string');     // 'kebabCaseString'
-toCamelCase('snake_case_string');     // 'snakeCaseString'
-toCamelCase('  SPACED  STRING  ');    // 'spacedString'
+**Example:**
+```typescript
+toCamelCase('hello world'); // 'helloWorld'
+toCamelCase('Hello-World_Example'); // 'helloWorldExample'
+toCamelCase('API_KEY'); // 'apiKey'
 ```
 
 #### `toPascalCase(input: string): string`
+Converts string to PascalCase.
 
-Converts a string to PascalCase.
+**Parameters:**
+- `input` - The string to convert
 
-**Examples:**
-```typescript
-import { toPascalCase } from '@ooneex/utils';
+**Returns:** PascalCase string
 
-toPascalCase('hello world');          // 'HelloWorld'
-toPascalCase('camelCaseString');      // 'CamelCaseString'
-toPascalCase('kebab-case-string');    // 'KebabCaseString'
-toPascalCase('snake_case_string');    // 'SnakeCaseString'
-toPascalCase('  spaced  string  ');   // 'SpacedString'
+**Example:**
+```typescript
+toPascalCase('hello world'); // 'HelloWorld'
+toPascalCase('api-key'); // 'ApiKey'
+toPascalCase('user_name'); // 'UserName'
 ```
 
 #### `toKebabCase(input: string): string`
+Converts string to kebab-case.
 
-Converts a string to kebab-case.
+**Parameters:**
+- `input` - The string to convert
 
-**Examples:**
+**Returns:** kebab-case string
+
+**Example:**
 ```typescript
-import { toKebabCase } from '@ooneex/utils';
+toKebabCase('Hello World'); // 'hello-world'
+toKebabCase('camelCaseString'); // 'camel-case-string'
+toKebabCase('PascalCaseString'); // 'pascal-case-string'
+```
+
+#### `splitToWords(input: string): string[]`
+Splits a string into individual words, handling various naming conventions.
+
+**Parameters:**
+- `input` - The string to split
 
-toKebabCase('Hello World');           // 'hello-world'
-toKebabCase('camelCaseString');       // 'camel-case-string'
-toKebabCase('PascalCaseString');      // 'pascal-case-string'
-toKebabCase('snake_case_string');     // 'snake-case-string'
-toKebabCase('  SPACED  STRING  ');    // 'spaced-string'
+**Returns:** Array of words
+
+**Example:**
+```typescript
+splitToWords('HelloWorld'); // ['Hello', 'World']
+splitToWords('hello-world_example'); // ['hello', 'world', 'example']
+splitToWords('XMLHttpRequest'); // ['XML', 'Http', 'Request']
+splitToWords('user123Name'); // ['user', '123', 'Name']
 ```
 
 #### `trim(text: string, char?: string): string`
+Trims specified characters from the beginning and end of a string.
 
-Trims specified characters from the beginning and end of a string. Defaults to trimming whitespace.
+**Parameters:**
+- `text` - The string to trim
+- `char` - Characters to trim (default: space). Supports regex patterns.
 
-**Examples:**
-```typescript
-import { trim } from '@ooneex/utils';
+**Returns:** Trimmed string
 
-trim('  hello world  ');              // 'hello world'
-trim('...hello world...', '.');       // 'hello world'
-trim('[hello world]', '[');           // 'hello world]'
-trim('[hello world]', '\\[|\\]');     // 'hello world'
-trim('***hello world***', '*');       // 'hello world'
+**Example:**
+```typescript
+trim('  hello  '); // 'hello'
+trim('...hello...', '\\.'); // 'hello'
+trim('[test]', '\\[|\\]'); // 'test'
+trim('!!hello!!', '!'); // 'hello'
 ```
 
-### Parsing Utilities
+### Time Utilities
 
-#### `parseString<T = unknown>(text: string): T`
+#### `secondsToHMS(seconds: number): string`
+Converts seconds to HH:MM:SS or MM:SS or SS format.
 
-Intelligently parses a string into appropriate JavaScript types (number, boolean, array, object, etc.).
+**Parameters:**
+- `seconds` - Number of seconds
 
-**Examples:**
+**Returns:** Formatted time string
+
+**Example:**
 ```typescript
-import { parseString } from '@ooneex/utils';
-
-parseString('123');                   // 123 (number)
-parseString('45.67');                 // 45.67 (number)
-parseString('true');                  // true (boolean)
-parseString('false');                 // false (boolean)
-parseString('null');                  // null
-parseString('[1, 2, 3]');             // [1, 2, 3] (array)
-parseString('{"key": "value"}');      // { key: "value" } (object)
-parseString('hello');                 // 'hello' (string)
-parseString('[apple, banana, 123]'); // ['apple', 'banana', 123]
+secondsToHMS(3661); // '1:01:01' (1 hour, 1 minute, 1 second)
+secondsToHMS(125); // '2:05' (2 minutes, 5 seconds)
+secondsToHMS(45); // '45' (45 seconds)
+secondsToHMS(0); // '0'
 ```
 
-#### `parseEnvVars<T = Record<string, unknown>>(envs: Record<string, unknown>): T`
+#### `secondsToMS(seconds: number): string`
+Converts seconds to MM:SS format.
+
+**Parameters:**
+- `seconds` - Number of seconds
 
-Parses environment variables, converting keys to camelCase and values to appropriate types.
+**Returns:** MM:SS formatted string
 
-**Examples:**
+**Example:**
 ```typescript
-import { parseEnvVars } from '@ooneex/utils';
+secondsToMS(125); // '2:05'
+secondsToMS(45); // '0:45'
+secondsToMS(3661); // '61:01'
+```
 
-const envVars = {
-  'DATABASE_URL': 'postgresql://localhost:5432/db',
-  'PORT': '3000',
-  'ENABLE_LOGGING': 'true',
-  'MAX_CONNECTIONS': '100'
-};
+#### `millisecondsToHMS(ms: number): string`
+Converts milliseconds to HH:MM:SS or MM:SS or SS format.
 
-const parsed = parseEnvVars(envVars);
-// {
-//   databaseUrl: 'postgresql://localhost:5432/db',
-//   port: 3000,
-//   enableLogging: true,
-//   maxConnections: 100
-// }
+**Parameters:**
+- `ms` - Number of milliseconds
+
+**Returns:** Formatted time string
+
+**Example:**
+```typescript
+millisecondsToHMS(3661000); // '1:01:01'
+millisecondsToHMS(125000); // '2:05'
+millisecondsToHMS(45000); // '45'
+millisecondsToHMS(500); // '0'
 ```
 
-### Number Formatting
+#### `sleep(ms: number): Promise<void>`
+Creates a promise that resolves after the specified number of milliseconds.
 
-#### `formatRelativeNumber(num: number, config?: { precision?: number; lang?: string }): string`
+**Parameters:**
+- `ms` - Number of milliseconds to wait
 
-Formats numbers using compact notation (K, M, B, etc.).
+**Returns:** Promise that resolves after the delay
 
-**Examples:**
+**Example:**
 ```typescript
-import { formatRelativeNumber } from '@ooneex/utils';
-
-formatRelativeNumber(1234);                           // '1.2K'
-formatRelativeNumber(1234567);                        // '1.2M'
-formatRelativeNumber(1234567890);                     // '1.2B'
-formatRelativeNumber(1234, { precision: 0 });         // '1K'
-formatRelativeNumber(1234, { precision: 2 });         // '1.23K'
-formatRelativeNumber(1234, { lang: 'de' });           // '1,2 Tsd.'
-formatRelativeNumber(1500000, { lang: 'fr' });        // '1,5 M'
+await sleep(1000); // Wait 1 second
+await sleep(500); // Wait 0.5 seconds
+
+// Usage in async function
+async function delayedLog() {
+  console.log('First');
+  await sleep(2000);
+  console.log('Second (2 seconds later)');
+}
 ```
 
-### Time Conversion
+### Data Parsing
 
-#### `millisecondsToHMS(ms: number): string`
+#### `parseString<T>(text: string): T`
+Intelligently parses a string and returns the appropriate type.
+
+**Parameters:**
+- `text` - The string to parse
 
-Converts milliseconds to HH:MM:SS or MM:SS format.
+**Returns:** Parsed value with inferred type
 
-**Examples:**
+**Supported Formats:**
+- Integers: `"123"` → `123`
+- Floats: `"12.34"` → `12.34`
+- Scientific notation: `"1e5"` → `100000`
+- Booleans: `"true"`, `"false"` (case insensitive)
+- Null: `"null"` (case insensitive)
+- Arrays: `"[1,2,3]"` → `[1, 2, 3]`
+- Objects: `'{"key":"value"}'` → `{key: "value"}`
+- JSON strings: `'"hello"'` → `"hello"`
+
+**Example:**
 ```typescript
-import { millisecondsToHMS } from '@ooneex/utils';
-
-millisecondsToHMS(30000);          // '30'
-millisecondsToHMS(90000);          // '1:30'
-millisecondsToHMS(3661000);        // '1:01:01'
-millisecondsToHMS(45000);          // '45'
-millisecondsToHMS(125000);         // '2:05'
-millisecondsToHMS(7323000);        // '2:02:03'
+parseString('123'); // 123 (number)
+parseString('12.34'); // 12.34 (number)
+parseString('1e3'); // 1000 (number)
+parseString('true'); // true (boolean)
+parseString('null'); // null
+parseString('[1,2,3]'); // [1, 2, 3] (array)
+parseString('{"name":"John"}'); // {name: "John"} (object)
+parseString('hello'); // 'hello' (string fallback)
+
+// With type annotation
+const num = parseString<number>('123'); // TypeScript knows it's a number
+const arr = parseString<number[]>('[1,2,3]'); // TypeScript knows it's number[]
 ```
 
-#### `secondsToHMS(seconds: number): string`
+#### `parseEnvVars<T>(envs: Record<string, string>): T`
+Parses environment variables, converting keys to camelCase and values using `parseString`.
 
-Converts seconds to HH:MM:SS or MM:SS format.
+**Parameters:**
+- `envs` - Object with environment variable key-value pairs
 
-**Examples:**
+**Returns:** Object with camelCase keys and parsed values
+
+**Example:**
 ```typescript
-import { secondsToHMS } from '@ooneex/utils';
-
-secondsToHMS(30);                  // '30'
-secondsToHMS(90);                  // '1:30'
-secondsToHMS(3661);                // '1:01:01'
-secondsToHMS(45);                  // '45'
-secondsToHMS(125);                 // '2:05'
-secondsToHMS(7323);                // '2:02:03'
+const envVars = {
+  'API_PORT': '3000',
+  'DEBUG_MODE': 'true',
+  'ALLOWED_HOSTS': '["localhost", "127.0.0.1"]',
+  'MAX_CONNECTIONS': '100',
+  'ENABLE_SSL': 'false'
+};
+
+const config = parseEnvVars(envVars);
+// Result:
+// {
+//   apiPort: 3000,
+//   debugMode: true,
+//   allowedHosts: ['localhost', '127.0.0.1'],
+//   maxConnections: 100,
+//   enableSsl: false
+// }
+
+// With type annotation
+interface Config {
+  apiPort: number;
+  debugMode: boolean;
+  allowedHosts: string[];
+}
+const typedConfig = parseEnvVars<Config>(envVars);
 ```
 
-#### `secondsToMS(seconds: number): string`
+### Number Utilities
 
-Converts seconds to MM:SS format.
+#### `formatRelativeNumber(num: number, config?: { precision?: number; lang?: string }): string`
+Formats numbers using compact notation with locale support.
+
+**Parameters:**
+- `num` - The number to format
+- `config.precision` - Maximum decimal places (default: 1)
+- `config.lang` - Locale code (default: 'en-GB')
+
+**Returns:** Formatted number string
 
-**Examples:**
+**Example:**
 ```typescript
-import { secondsToMS } from '@ooneex/utils';
+formatRelativeNumber(1000); // '1K'
+formatRelativeNumber(1500); // '1.5K'
+formatRelativeNumber(1000000); // '1M'
+formatRelativeNumber(1000000000); // '1B'
+
+// Custom precision
+formatRelativeNumber(1234, { precision: 2 }); // '1.23K'
+formatRelativeNumber(1234, { precision: 0 }); // '1K'
+
+// Different locales
+formatRelativeNumber(1500, { lang: 'de-DE' }); // '1500'
+formatRelativeNumber(1500000, { lang: 'de-DE' }); // '1,5 Mio.'
+formatRelativeNumber(1500, { lang: 'fr-FR' }); // '1,5 k'
+formatRelativeNumber(1500, { lang: 'es-ES' }); // '1,5 mil'
+```
+
+### File Utilities
+
+#### `dataURLtoFile(dataurl: string, filename: string): File`
+Converts a data URL to a File object.
+
+**Parameters:**
+- `dataurl` - The data URL string
+- `filename` - The desired filename for the File object
 
-secondsToMS(30);                   // '0:30'
-secondsToMS(90);                   // '1:30'
-secondsToMS(125);                  // '2:05'
-secondsToMS(3661);                 // '61:01'
+**Returns:** File object
+
+**Example:**
+```typescript
+// Text file
+const textDataUrl = 'data:text/plain;base64,SGVsbG8gV29ybGQ=';
+const textFile = dataURLtoFile(textDataUrl, 'hello.txt');
+console.log(textFile.name); // 'hello.txt'
+console.log(textFile.type); // 'text/plain'
+console.log(textFile.size); // 11
+
+// Image file
+const imgDataUrl = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==';
+const imgFile = dataURLtoFile(imgDataUrl, 'pixel.png');
+console.log(imgFile.type); // 'image/png'
+
+// Usage with FileReader
+const reader = new FileReader();
+reader.onload = (e) => console.log(e.target?.result);
+reader.readAsText(textFile);
 ```
 
 ### Random Generation
 
-#### `random`
+#### `random.nanoid(size?: number): string`
+Generates a random hexadecimal string.
+
+**Parameters:**
+- `size` - Length of the generated string (default: 10)
 
-Object containing various random string generation functions.
+**Returns:** Random hex string
 
-**Examples:**
+**Example:**
 ```typescript
-import { random } from '@ooneex/utils';
+random.nanoid(); // 'a1b2c3d4e5' (10 characters)
+random.nanoid(8); // 'f6e5d4c3' (8 characters)
+random.nanoid(16); // '1a2b3c4d5e6f7890' (16 characters)
+```
 
-// Generate random hexadecimal string (default 10 characters)
-random.nanoid();                   // 'a1b2c3d4e5'
-random.nanoid(5);                  // '1a2b3'
-random.nanoid(16);                 // '1234567890abcdef'
+#### `random.stringInt(size?: number): string`
+Generates a random numeric string.
 
-// Generate random numeric string
-random.stringInt();                // '1234567890'
-random.stringInt(5);               // '12345'
+**Parameters:**
+- `size` - Length of the generated string (default: 10)
 
-// Create a factory function for consistent length
-const generateId = random.nanoidFactory(8);
-generateId();                      // 'a1b2c3d4'
-generateId();                      // '5e6f7890'
+**Returns:** Random numeric string
+
+**Example:**
+```typescript
+random.stringInt(); // '1234567890' (10 digits)
+random.stringInt(6); // '123456' (6 digits)
+random.stringInt(4); // '9876' (4 digits)
 ```
 
-### Async Utilities
+#### `random.nanoidFactory(size?: number): (size?: number) => string`
+Creates a factory function for generating random hex strings.
 
-#### `sleep(ms: number): Promise<void>`
+**Parameters:**
+- `size` - Default length for the factory (default: 10)
 
-Creates a promise that resolves after the specified number of milliseconds, useful for adding delays in async functions.
+**Returns:** Factory function that accepts optional size parameter
 
-**Examples:**
+**Example:**
 ```typescript
-import { sleep } from '@ooneex/utils';
+const generateId = random.nanoidFactory(12);
+generateId(); // 12-character hex string
+generateId(8); // 8-character hex string (overrides factory default)
+generateId(16); // 16-character hex string
 
-// Wait for 1 second
-await sleep(1000);
+const generateShortId = random.nanoidFactory(6);
+generateShortId(); // 6-character hex string
+```
 
-// Use in async function
-async function delayedOperation() {
-  console.log('Starting...');
-  await sleep(2000);  // Wait 2 seconds
-  console.log('Done!');
-}
+## Advanced Usage
 
-// Use with other async operations
-async function retryWithDelay() {
-  for (let i = 0; i < 3; i++) {
-    try {
-      await someOperation();
-      break;
-    } catch (error) {
-      if (i < 2) await sleep(1000); // Wait 1 second before retry
-    }
-  }
+### Environment Configuration
+
+```typescript
+import { parseEnvVars } from '@ooneex/utils';
+
+// Define your configuration interface
+interface AppConfig {
+  port: number;
+  host: string;
+  debug: boolean;
+  features: string[];
+  dbConfig: {
+    host: string;
+    port: number;
+  };
 }
+
+// Parse environment variables
+const envConfig = parseEnvVars<Partial<AppConfig>>(process.env);
+
+// Merge with defaults
+const config: AppConfig = {
+  port: 3000,
+  host: 'localhost',
+  debug: false,
+  features: [],
+  dbConfig: { host: 'localhost', port: 5432 },
+  ...envConfig
+};
 ```
 
-## Type Safety
+### String Processing Pipeline
 
-All functions are fully typed with TypeScript, providing excellent IDE support and compile-time type checking.
+```typescript
+import { splitToWords, toCamelCase, capitalizeWord } from '@ooneex/utils';
+
+function processUserInput(input: string): {
+  words: string[];
+  camelCase: string;
+  title: string;
+  kebabCase: string;
+} {
+  const words = splitToWords(input);
+
+  return {
+    words,
+    camelCase: toCamelCase(input),
+    title: words.map(capitalizeWord).join(' '),
+    kebabCase: toKebabCase(input)
+  };
+}
+
+const result = processUserInput('user-profile_settings');
+// {
+//   words: ['user', 'profile', 'settings'],
+//   camelCase: 'userProfileSettings',
+//   title: 'User Profile Settings',
+//   kebabCase: 'user-profile-settings'
+// }
+```
+
+### Time-based Progress Tracking
 
 ```typescript
-// Generic type support
-const parsedNumber = parseString<number>('123');     // Type: number
-const parsedArray = parseString<string[]>('[a,b,c]'); // Type: string[]
+import { millisecondsToHMS, formatRelativeNumber } from '@ooneex/utils';
 
-// Environment variables with custom type
-interface AppConfig {
-  port: number;
-  databaseUrl: string;
-  enableLogging: boolean;
+class ProgressTracker {
+  private startTime: number;
+  private itemsProcessed: number = 0;
+  private totalItems: number;
+
+  constructor(totalItems: number) {
+    this.startTime = Date.now();
+    this.totalItems = totalItems;
+  }
+
+  update(processed: number): string {
+    this.itemsProcessed = processed;
+    const elapsed = Date.now() - this.startTime;
+    const rate = processed / (elapsed / 1000);
+    const remaining = (this.totalItems - processed) / rate * 1000;
+
+    return [
+      `Processed: ${formatRelativeNumber(processed)}/${formatRelativeNumber(this.totalItems)}`,
+      `Elapsed: ${millisecondsToHMS(elapsed)}`,
+      `ETA: ${millisecondsToHMS(remaining)}`
+    ].join(' | ');
+  }
 }
 
-const config = parseEnvVars<AppConfig>(process.env);
+const tracker = new ProgressTracker(100000);
+console.log(tracker.update(15000));
+// "Processed: 15K/100K | Elapsed: 2:30 | ETA: 14:10"
 ```
 
 ## License
 
-MIT
+This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.
 
 ## Contributing
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+
+### Development Setup
+
+1. Clone the repository
+2. Install dependencies: `bun install`
+3. Run tests: `bun run test`
+4. Build the project: `bun run build`
+
+### Guidelines
+
+- Write tests for new features
+- Follow the existing code style
+- Update documentation for API changes
+- Ensure all tests pass before submitting PR
+
+---
+
+Made with ❤️ by the Ooneex team

package/dist/index.d.ts

@@ -1,69 +1,23 @@
-declare module "capitalizeWord" {
-    export const capitalizeWord: (word: string) => string;
-}
-declare module "dataURLtoFile" {
-    export const dataURLtoFile: (dataurl: string, filename: string) => File;
-}
-declare module "formatRelativeNumber" {
-    export const formatRelativeNumber: (num: number, config?: {
-        precision?: number;
-        lang?: string;
-    }) => string;
-}
-declare module "millisecondsToHMS" {
-    export const millisecondsToHMS: (ms: number) => string;
-}
-declare module "trim" {
-    export const trim: (text: string, char?: string) => string;
-}
-declare module "parseString" {
-    export const parseString: <T = unknown>(text: string) => T;
-}
-declare module "splitToWords" {
-    export const splitToWords: (input: string) => RegExpMatchArray | [];
-}
-declare module "toCamelCase" {
-    export const toCamelCase: (input: string) => string;
-}
-declare module "parseEnvVars" {
-    export const parseEnvVars: <T = Record<string, unknown>>(envs: Record<string, unknown>) => T;
-}
-declare module "random" {
-    export const random: {
-        nanoid(size?: number): string;
-        stringInt(size?: number): string;
-        nanoidFactory(size?: number): (size?: number) => string;
-    };
-}
-declare module "secondsToHMS" {
-    export const secondsToHMS: (seconds: number) => string;
-}
-declare module "secondsToMS" {
-    export const secondsToMS: (seconds: number) => string;
-}
-declare module "sleep" {
-    export const sleep: (ms: number) => Promise<void>;
-}
-declare module "toKebabCase" {
-    export const toKebabCase: (input: string) => string;
-}
-declare module "toPascalCase" {
-    export const toPascalCase: (input: string) => string;
-}
-declare module "index" {
-    export { capitalizeWord } from "capitalizeWord";
-    export { dataURLtoFile } from "dataURLtoFile";
-    export { formatRelativeNumber } from "formatRelativeNumber";
-    export { millisecondsToHMS } from "millisecondsToHMS";
-    export { parseEnvVars } from "parseEnvVars";
-    export { parseString } from "parseString";
-    export { random } from "random";
-    export { secondsToHMS } from "secondsToHMS";
-    export { secondsToMS } from "secondsToMS";
-    export { sleep } from "sleep";
-    export { splitToWords } from "splitToWords";
-    export { toCamelCase } from "toCamelCase";
-    export { toKebabCase } from "toKebabCase";
-    export { toPascalCase } from "toPascalCase";
-    export { trim } from "trim";
-}
+declare const capitalizeWord: (word: string) => string;
+declare const dataURLtoFile: (dataurl: string, filename: string) => File;
+declare const formatRelativeNumber: (num: number, config?: {
+	precision?: number;
+	lang?: string;
+}) => string;
+declare const millisecondsToHMS: (ms: number) => string;
+declare const parseEnvVars: <T = Record<string, string>>(envs: Record<string, string>) => T;
+declare const parseString: <T = unknown>(text: string) => T;
+declare const random: {
+	nanoid(size?: number): string;
+	stringInt(size?: number): string;
+	nanoidFactory(size?: number): (size?: number) => string;
+};
+declare const secondsToHMS: (seconds: number) => string;
+declare const secondsToMS: (seconds: number) => string;
+declare const sleep: (ms: number) => Promise<void>;
+declare const splitToWords: (input: string) => string[];
+declare const toCamelCase: (input: string) => string;
+declare const toKebabCase: (input: string) => string;
+declare const toPascalCase: (input: string) => string;
+declare const trim: (text: string, char?: string) => string;
+export { trim, toPascalCase, toKebabCase, toCamelCase, splitToWords, sleep, secondsToMS, secondsToHMS, random, parseString, parseEnvVars, millisecondsToHMS, formatRelativeNumber, dataURLtoFile, capitalizeWord };

package/dist/index.js

@@ -1 +1,3 @@
-var i=(r)=>{return r?r[0]?.toUpperCase()+r.slice(1).toLowerCase():r};var g=(r,t)=>{let o=r.split(","),n=o[0]?.match(/:(.*?);/),e=n?n[1]:"",l=atob(o[1]),a=l.length,f=new Uint8Array(a);while(a--)f[a]=l.charCodeAt(a);return new File([f],t,{type:e})};var d=(r,t)=>{return new Intl.NumberFormat(t?.lang??"en-GB",{notation:"compact",compactDisplay:"short",maximumFractionDigits:t?.precision??1}).format(r)};var S=(r)=>{let t=Math.floor(r/1000),o=Math.floor(t/3600),n=Math.floor(t%3600/60),e=t%60;if(o>0)return`${o}:${n.toString().padStart(2,"0")}:${e.toString().padStart(2,"0")}`;if(n>0)return`${n}:${e.toString().padStart(2,"0")}`;return e.toString()};var p=(r,t=" ")=>{if([".","[","]","(",")","+","*","^","$","?","/","\\"].includes(t))t=`\\${t}`;let o=new RegExp(`^${t}+|${t}+$`,"g");return r.replace(o,"")};var m=(r)=>{if(/^[0-9]+$/.test(r))return Number.parseInt(r,10);if(/^[0-9]+[.][0-9]+$/.test(r))return Number.parseFloat(r);if(/^true$/i.test(r))return!0;if(/^false$/i.test(r))return!1;if(/^null$/i.test(r))return null;if(/^\[/.test(r)&&/]$/.test(r)){let o=p(r,"\\[|\\]").split(/, */);return o=o.map((n)=>{return m(n)}),o}try{let t=JSON.parse(r);if(t===Number.POSITIVE_INFINITY||t===Number.NEGATIVE_INFINITY)return r;return t}catch{return r}};var b=/\p{Lu}\p{Ll}+/u,T=/\p{Lu}+(?=(\p{Lu}\p{Ll})|\P{L}|\b)/u,$=/(\p{Ll}+)/u,x=/\p{L}+/u,C=/\p{N}+/u,M=new RegExp(`${b.source}|${T.source}|${$.source}|${x.source}|${C.source}`,"gu"),s=(r)=>{return r.match(M)??[]};var c=(r)=>{r=r.trim();let[t="",...o]=s(r);return[t.toLowerCase(),...o.map(i)].join("")};var h=(r)=>{let t={};for(let o in r){let n=c(o),e=m(r[o]);t[n]=e}return t};import{customAlphabet as u}from"nanoid";var N={nanoid(r){return u("1234567890abcdef",r??10)()},stringInt(r){return u("1234567890",r??10)()},nanoidFactory(r){return u("1234567890abcdef",r??10)}};var w=(r)=>{let t=Math.floor(r),o=Math.floor(t/3600),n=Math.floor(t%3600/60),e=t%60;if(o>0)return`${o}:${n.toString().padStart(2,"0")}:${e.toString().padStart(2,"0")}`;if(n>0)return`${n}:${e.toString().padStart(2,"0")}`;return e.toString()};var F=(r)=>{let t=Math.floor(r/60),o=r%60;return`${t}:${o.toString().padStart(2,"0")}`};var k=(r)=>{return new Promise((t)=>setTimeout(t,r))};var I=(r)=>{return r=r.trim(),s(r).join("-").toLowerCase()};var v=(r)=>{return r=r.trim(),s(r).map(i).join("")};export{p as trim,v as toPascalCase,I as toKebabCase,c as toCamelCase,s as splitToWords,k as sleep,F as secondsToMS,w as secondsToHMS,N as random,m as parseString,h as parseEnvVars,S as millisecondsToHMS,d as formatRelativeNumber,g as dataURLtoFile,i as capitalizeWord};
+var i=(r)=>r?r[0]?.toUpperCase()+r.slice(1).toLowerCase():r;var u=(r,t)=>{let o=r.split(","),s=o[0]?.match(/:(.*?);/)?.[1]||"",f=atob(o[1]),a=f.length,g=new Uint8Array(a);while(a--)g[a]=f.charCodeAt(a);return new File([g],t,{type:s})};var d=(r,t)=>new Intl.NumberFormat(t?.lang??"en-GB",{notation:"compact",compactDisplay:"short",maximumFractionDigits:t?.precision??1}).format(r);var S=(r)=>{let t=Math.floor(r/1000),o=Math.floor(t/3600),e=Math.floor(t%3600/60),s=t%60;if(o>0)return`${o}:${e.toString().padStart(2,"0")}:${s.toString().padStart(2,"0")}`;if(e>0)return`${e}:${s.toString().padStart(2,"0")}`;return s.toString()};var p=(r,t=" ")=>{if([".","[","]","(",")","+","*","^","$","?","/","\\"].includes(t))t=`\\${t}`;let o=new RegExp(`^${t}+|${t}+$`,"g");return r.replace(o,"")};var m=(r)=>{if(/^[0-9]+$/.test(r))return Number.parseInt(r,10);if(/^[0-9]+[.][0-9]+$/.test(r))return Number.parseFloat(r);if(/^true$/i.test(r))return!0;if(/^false$/i.test(r))return!1;if(/^null$/i.test(r))return null;if(/^\[/.test(r)&&/]$/.test(r)){let o=p(r,"\\[|\\]").split(/, */);return o=o.map((e)=>m(e)),o}try{let t=JSON.parse(r);if(t===Number.POSITIVE_INFINITY||t===Number.NEGATIVE_INFINITY)return r;return t}catch{return r}};var b=/\p{Lu}\p{Ll}+/u,T=/\p{Lu}+(?=(\p{Lu}\p{Ll})|\P{L}|\b)/u,$=/(\p{Ll}+)/u,x=/\p{L}+/u,M=/\p{N}+/u,h=new RegExp(`${b.source}|${T.source}|${$.source}|${x.source}|${M.source}`,"gu"),n=(r)=>r.match(h)??[];var c=(r)=>{r=r.trim();let[t="",...o]=n(r);return[t.toLowerCase(),...o.map(i)].join("")};var C=(r)=>{let t={};for(let o in r){let e=c(o),s=m(r[o]);t[e]=s}return t};import{customAlphabet as l}from"nanoid";var F={nanoid(r){return l("1234567890abcdef",r??10)()},stringInt(r){return l("1234567890",r??10)()},nanoidFactory(r){return l("1234567890abcdef",r??10)}};var N=(r)=>{let t=Math.floor(r),o=Math.floor(t/3600),e=Math.floor(t%3600/60),s=t%60;if(o>0)return`${o}:${e.toString().padStart(2,"0")}:${s.toString().padStart(2,"0")}`;if(e>0)return`${e}:${s.toString().padStart(2,"0")}`;return s.toString()};var I=(r)=>{let t=Math.floor(r/60),o=r%60;return`${t}:${o.toString().padStart(2,"0")}`};var v=(r)=>new Promise((t)=>setTimeout(t,r));var w=(r)=>{return r=r.trim(),n(r).join("-").toLowerCase()};var y=(r)=>{return r=r.trim(),n(r).map(i).join("")};export{p as trim,y as toPascalCase,w as toKebabCase,c as toCamelCase,n as splitToWords,v as sleep,I as secondsToMS,N as secondsToHMS,F as random,m as parseString,C as parseEnvVars,S as millisecondsToHMS,d as formatRelativeNumber,u as dataURLtoFile,i as capitalizeWord};
+
+//# debugId=D3540DB7AD21EC7364756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,24 @@
+{
+  "version": 3,
+  "sources": ["src/capitalizeWord.ts", "src/dataURLtoFile.ts", "src/formatRelativeNumber.ts", "src/millisecondsToHMS.ts", "src/trim.ts", "src/parseString.ts", "src/splitToWords.ts", "src/toCamelCase.ts", "src/parseEnvVars.ts", "src/random.ts", "src/secondsToHMS.ts", "src/secondsToMS.ts", "src/sleep.ts", "src/toKebabCase.ts", "src/toPascalCase.ts"],
+  "sourcesContent": [
+    "export const capitalizeWord = (word: string): string =>\n  word ? word[0]?.toUpperCase() + word.slice(1).toLowerCase() : word;\n",
+    "export const dataURLtoFile = (dataurl: string, filename: string): File => {\n  const arr = dataurl.split(\",\");\n  const mimeMatch = arr[0]?.match(/:(.*?);/);\n  const mime = mimeMatch?.[1] || \"\";\n  const bstr = atob(arr[1] as string);\n  let n = bstr.length;\n  const u8arr = new Uint8Array(n);\n  while (n--) {\n    u8arr[n] = bstr.charCodeAt(n);\n  }\n  return new File([u8arr], filename, { type: mime });\n};\n",
+    "export const formatRelativeNumber = (num: number, config?: { precision?: number; lang?: string }): string =>\n  new Intl.NumberFormat(config?.lang ?? \"en-GB\", {\n    notation: \"compact\",\n    compactDisplay: \"short\",\n    maximumFractionDigits: config?.precision ?? 1,\n  }).format(num);\n",
+    "export const millisecondsToHMS = (ms: number): string => {\n  const totalSeconds = Math.floor(ms / 1000);\n  const hours = Math.floor(totalSeconds / 3600);\n  const minutes = Math.floor((totalSeconds % 3600) / 60);\n  const seconds = totalSeconds % 60;\n\n  if (hours > 0) {\n    return `${hours}:${minutes.toString().padStart(2, \"0\")}:${seconds.toString().padStart(2, \"0\")}`;\n  }\n\n  if (minutes > 0) {\n    return `${minutes}:${seconds.toString().padStart(2, \"0\")}`;\n  }\n\n  return seconds.toString();\n};\n",
+    "export const trim = (text: string, char = \" \"): string => {\n  if ([\".\", \"[\", \"]\", \"(\", \")\", \"+\", \"*\", \"^\", \"$\", \"?\", \"/\", \"\\\\\"].includes(char)) {\n    char = `\\\\${char}`;\n  }\n\n  const reg = new RegExp(`^${char}+|${char}+$`, \"g\");\n  return text.replace(reg, \"\");\n};\n",
+    "import { trim } from \"./trim\";\n\nexport const parseString = <T = unknown>(text: string): T => {\n  if (/^[0-9]+$/.test(text)) {\n    return Number.parseInt(text, 10) as T;\n  }\n\n  if (/^[0-9]+[.][0-9]+$/.test(text)) {\n    return Number.parseFloat(text) as T;\n  }\n\n  if (/^true$/i.test(text)) {\n    return true as T;\n  }\n\n  if (/^false$/i.test(text)) {\n    return false as T;\n  }\n\n  if (/^null$/i.test(text)) {\n    return null as T;\n  }\n\n  if (/^\\[/.test(text) && /]$/.test(text)) {\n    const trimmedText = trim(text, \"\\\\[|\\\\]\");\n\n    let values: unknown[] = trimmedText.split(/, */);\n\n    values = values.map((value) => parseString(value as string));\n\n    return values as T;\n  }\n\n  try {\n    const result = JSON.parse(text);\n\n    if (result === Number.POSITIVE_INFINITY || result === Number.NEGATIVE_INFINITY) {\n      return text as T;\n    }\n\n    return result;\n  } catch {\n    return text as T;\n  }\n};\n",
+    "const CAPITALIZED_WORD_REGEXP = /\\p{Lu}\\p{Ll}+/u; // e.g. Apple\nconst ACRONYM_REGEXP = /\\p{Lu}+(?=(\\p{Lu}\\p{Ll})|\\P{L}|\\b)/u; // e.g. ID, URL, handles an acronym followed by a capitalized word e.g. HTMLElement\nconst LOWERCASED_WORD_REGEXP = /(\\p{Ll}+)/u; // e.g. apple\nconst ANY_LETTERS = /\\p{L}+/u; // will match any sequence of letters, including in languages without a concept of upper/lower case\nconst DIGITS_REGEXP = /\\p{N}+/u; // e.g. 123\n\nconst WORD_OR_NUMBER_REGEXP = new RegExp(\n  `${CAPITALIZED_WORD_REGEXP.source}|${ACRONYM_REGEXP.source}|${LOWERCASED_WORD_REGEXP.source}|${ANY_LETTERS.source}|${DIGITS_REGEXP.source}`,\n  \"gu\",\n);\n\nexport const splitToWords = (input: string): string[] => input.match(WORD_OR_NUMBER_REGEXP) ?? [];\n",
+    "import { capitalizeWord } from \"./capitalizeWord\";\nimport { splitToWords } from \"./splitToWords\";\n\nexport const toCamelCase = (input: string): string => {\n  input = input.trim();\n  const [first = \"\", ...rest] = splitToWords(input);\n  return [first.toLowerCase(), ...rest.map(capitalizeWord)].join(\"\");\n};\n",
+    "import { parseString } from \"./parseString\";\nimport { toCamelCase } from \"./toCamelCase\";\n\nexport const parseEnvVars = <T = Record<string, string>>(envs: Record<string, string>): T => {\n  const vars: Record<string, string> = {};\n\n  for (const key in envs) {\n    const k = toCamelCase(key);\n    const value = parseString(envs[key] as string) as string;\n    vars[k] = value;\n  }\n\n  return vars as T;\n};\n",
+    "import { customAlphabet } from \"nanoid\";\n\nexport const random = {\n  nanoid(size?: number): string {\n    return customAlphabet(\"1234567890abcdef\", size ?? 10)();\n  },\n  stringInt(size?: number): string {\n    return customAlphabet(\"1234567890\", size ?? 10)();\n  },\n  nanoidFactory(size?: number): (size?: number) => string {\n    return customAlphabet(\"1234567890abcdef\", size ?? 10);\n  },\n};\n",
+    "export const secondsToHMS = (seconds: number): string => {\n  const totalSeconds = Math.floor(seconds);\n  const hours = Math.floor(totalSeconds / 3600);\n  const minutes = Math.floor((totalSeconds % 3600) / 60);\n  const remainingSeconds = totalSeconds % 60;\n\n  if (hours > 0) {\n    return `${hours}:${minutes.toString().padStart(2, \"0\")}:${remainingSeconds.toString().padStart(2, \"0\")}`;\n  }\n\n  if (minutes > 0) {\n    return `${minutes}:${remainingSeconds.toString().padStart(2, \"0\")}`;\n  }\n\n  return remainingSeconds.toString();\n};\n",
+    "export const secondsToMS = (seconds: number): string => {\n  const minutes = Math.floor(seconds / 60);\n  const remainingSeconds = seconds % 60;\n  return `${minutes}:${remainingSeconds.toString().padStart(2, \"0\")}`;\n};\n",
+    "export const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));\n",
+    "import { splitToWords } from \"./splitToWords\";\n\nexport const toKebabCase = (input: string): string => {\n  input = input.trim();\n  return splitToWords(input).join(\"-\").toLowerCase();\n};\n",
+    "import { capitalizeWord } from \"./capitalizeWord\";\nimport { splitToWords } from \"./splitToWords\";\n\nexport const toPascalCase = (input: string): string => {\n  input = input.trim();\n  return splitToWords(input).map(capitalizeWord).join(\"\");\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "D3540DB7AD21EC7364756E2164756E21",
+  "names": []
+}

package/package.json

@@ -1,23 +1,36 @@
 {
   "name": "@ooneex/utils",
-  "version": "0.0.5",
   "description": "",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "version": "0.0.8",
   "type": "module",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "package.json"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
   "license": "MIT",
   "scripts": {
-    "compile": "tsc ./src/index.ts --declaration --emitDeclarationOnly --target ES2022 --moduleResolution bundler --outfile dist/index.d.ts",
-    "build": "rm -rf dist && bun run compile && bun build ./src/index.ts --outdir ./dist --target browser --format esm --packages external --minify",
-    "publish": "bun run build && bun publish --access public"
+    "test": "bun test tests",
+    "build": "bunup",
+    "lint": "tsgo --noEmit && bunx biome lint",
+    "publish:prod": "bun publish --tolerate-republish --access public",
+    "publish:pack": "bun pm pack --destination ./dist",
+    "publish:dry": "bun publish --dry-run"
   },
-  "devDependencies": {},
-  "peerDependencies": {},
   "dependencies": {
     "nanoid": "^5.1.6"
   },
-  "files": [
-    "dist/**/*.js",
-    "dist/**/*.d.ts"
-  ]
+  "devDependencies": {}
 }