@ooneex/utils 0.0.3

package/README.md

@@ -0,0 +1,335 @@
+# @ooneex/utils
+
+A comprehensive collection of utility functions for common programming tasks including string manipulation, number formatting, time conversion, and more.
+
+## Installation
+
+```bash
+npm install @ooneex/utils
+# or
+bun add @ooneex/utils
+# or
+yarn add @ooneex/utils
+# or
+pnpm add @ooneex/utils
+```
+
+## Usage
+
+```typescript
+import { capitalizeWord, formatRelativeNumber, random, sleep, dataURLtoFile } from '@ooneex/utils';
+```
+
+## API Reference
+
+### File Utilities
+
+#### `dataURLtoFile(dataurl: string, filename: string): File`
+
+Converts a data URL string into a File object, useful for handling base64-encoded file data.
+
+**Examples:**
+```typescript
+import { dataURLtoFile } from '@ooneex/utils';
+
+// Convert a data URL to a 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);
+```
+
+### String Utilities
+
+#### `capitalizeWord(word: string): string`
+
+Capitalizes the first letter of a word and makes the rest lowercase.
+
+**Examples:**
+```typescript
+import { capitalizeWord } from '@ooneex/utils';
+
+capitalizeWord('hello');      // 'Hello'
+capitalizeWord('WORLD');      // 'World'
+capitalizeWord('javaScript'); // 'Javascript'
+capitalizeWord('');           // ''
+```
+
+#### `splitToWords(input: string): string[]`
+
+Splits a string into an array of words, handling camelCase, PascalCase, kebab-case, snake_case, and more.
+
+**Examples:**
+```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']
+```
+
+#### `toCamelCase(input: string): string`
+
+Converts a string to camelCase.
+
+**Examples:**
+```typescript
+import { toCamelCase } from '@ooneex/utils';
+
+toCamelCase('hello world');           // 'helloWorld'
+toCamelCase('PascalCaseString');      // 'pascalCaseString'
+toCamelCase('kebab-case-string');     // 'kebabCaseString'
+toCamelCase('snake_case_string');     // 'snakeCaseString'
+toCamelCase('  SPACED  STRING  ');    // 'spacedString'
+```
+
+#### `toPascalCase(input: string): string`
+
+Converts a string to PascalCase.
+
+**Examples:**
+```typescript
+import { toPascalCase } from '@ooneex/utils';
+
+toPascalCase('hello world');          // 'HelloWorld'
+toPascalCase('camelCaseString');      // 'CamelCaseString'
+toPascalCase('kebab-case-string');    // 'KebabCaseString'
+toPascalCase('snake_case_string');    // 'SnakeCaseString'
+toPascalCase('  spaced  string  ');   // 'SpacedString'
+```
+
+#### `toKebabCase(input: string): string`
+
+Converts a string to kebab-case.
+
+**Examples:**
+```typescript
+import { toKebabCase } from '@ooneex/utils';
+
+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'
+```
+
+#### `trim(text: string, char?: string): string`
+
+Trims specified characters from the beginning and end of a string. Defaults to trimming whitespace.
+
+**Examples:**
+```typescript
+import { trim } from '@ooneex/utils';
+
+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'
+```
+
+### Parsing Utilities
+
+#### `parseString<T = unknown>(text: string): T`
+
+Intelligently parses a string into appropriate JavaScript types (number, boolean, array, object, etc.).
+
+**Examples:**
+```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]
+```
+
+#### `parseEnvVars<T = Record<string, unknown>>(envs: Record<string, unknown>): T`
+
+Parses environment variables, converting keys to camelCase and values to appropriate types.
+
+**Examples:**
+```typescript
+import { parseEnvVars } from '@ooneex/utils';
+
+const envVars = {
+  'DATABASE_URL': 'postgresql://localhost:5432/db',
+  'PORT': '3000',
+  'ENABLE_LOGGING': 'true',
+  'MAX_CONNECTIONS': '100'
+};
+
+const parsed = parseEnvVars(envVars);
+// {
+//   databaseUrl: 'postgresql://localhost:5432/db',
+//   port: 3000,
+//   enableLogging: true,
+//   maxConnections: 100
+// }
+```
+
+### Number Formatting
+
+#### `formatRelativeNumber(num: number, config?: { precision?: number; lang?: string }): string`
+
+Formats numbers using compact notation (K, M, B, etc.).
+
+**Examples:**
+```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'
+```
+
+### Time Conversion
+
+#### `millisecondsToHMS(ms: number): string`
+
+Converts milliseconds to HH:MM:SS or MM:SS format.
+
+**Examples:**
+```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'
+```
+
+#### `secondsToHMS(seconds: number): string`
+
+Converts seconds to HH:MM:SS or MM:SS format.
+
+**Examples:**
+```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'
+```
+
+#### `secondsToMS(seconds: number): string`
+
+Converts seconds to MM:SS format.
+
+**Examples:**
+```typescript
+import { secondsToMS } from '@ooneex/utils';
+
+secondsToMS(30);                   // '0:30'
+secondsToMS(90);                   // '1:30'
+secondsToMS(125);                  // '2:05'
+secondsToMS(3661);                 // '61:01'
+```
+
+### Random Generation
+
+#### `random`
+
+Object containing various random string generation functions.
+
+**Examples:**
+```typescript
+import { random } from '@ooneex/utils';
+
+// Generate random hexadecimal string (default 10 characters)
+random.nanoid();                   // 'a1b2c3d4e5'
+random.nanoid(5);                  // '1a2b3'
+random.nanoid(16);                 // '1234567890abcdef'
+
+// Generate random numeric string
+random.stringInt();                // '1234567890'
+random.stringInt(5);               // '12345'
+
+// Create a factory function for consistent length
+const generateId = random.nanoidFactory(8);
+generateId();                      // 'a1b2c3d4'
+generateId();                      // '5e6f7890'
+```
+
+### Async Utilities
+
+#### `sleep(ms: number): Promise<void>`
+
+Creates a promise that resolves after the specified number of milliseconds, useful for adding delays in async functions.
+
+**Examples:**
+```typescript
+import { sleep } from '@ooneex/utils';
+
+// Wait for 1 second
+await sleep(1000);
+
+// Use in async function
+async function delayedOperation() {
+  console.log('Starting...');
+  await sleep(2000);  // Wait 2 seconds
+  console.log('Done!');
+}
+
+// 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
+    }
+  }
+}
+```
+
+## Type Safety
+
+All functions are fully typed with TypeScript, providing excellent IDE support and compile-time type checking.
+
+```typescript
+// Generic type support
+const parsedNumber = parseString<number>('123');     // Type: number
+const parsedArray = parseString<string[]>('[a,b,c]'); // Type: string[]
+
+// Environment variables with custom type
+interface AppConfig {
+  port: number;
+  databaseUrl: string;
+  enableLogging: boolean;
+}
+
+const config = parseEnvVars<AppConfig>(process.env);
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

package/index.d.ts

@@ -0,0 +1,69 @@
+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";
+}

package/index.js

@@ -0,0 +1 @@
+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};

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@ooneex/utils",
+  "version": "0.0.3",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "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 && cp package.json dist && cp README.md dist && cd dist && bun publish --access public"
+  },
+  "devDependencies": {},
+  "peerDependencies": {},
+  "dependencies": {
+    "nanoid": "^5.1.6"
+  }
+}