@ooneex/utils 0.0.5 → 0.0.6

package/dist/capitalizeWord.d.ts

@@ -0,0 +1,2 @@
+export declare const capitalizeWord: (word: string) => string;
+//# sourceMappingURL=capitalizeWord.d.ts.map

package/dist/capitalizeWord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capitalizeWord.d.ts","sourceRoot":"","sources":["../src/capitalizeWord.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,KAAG,MAE7C,CAAC"}

package/dist/dataURLtoFile.d.ts

@@ -0,0 +1,2 @@
+export declare const dataURLtoFile: (dataurl: string, filename: string) => File;
+//# sourceMappingURL=dataURLtoFile.d.ts.map

package/dist/dataURLtoFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataURLtoFile.d.ts","sourceRoot":"","sources":["../src/dataURLtoFile.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,EAAE,UAAU,MAAM,SAW9D,CAAC"}

package/dist/formatRelativeNumber.d.ts

@@ -0,0 +1,5 @@
+export declare const formatRelativeNumber: (num: number, config?: {
+    precision?: number;
+    lang?: string;
+}) => string;
+//# sourceMappingURL=formatRelativeNumber.d.ts.map

package/dist/formatRelativeNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatRelativeNumber.d.ts","sourceRoot":"","sources":["../src/formatRelativeNumber.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,GAAI,KAAK,MAAM,EAAE,SAAS;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,KAAG,MAMlG,CAAC"}

package/dist/index.d.ts

@@ -1,69 +1,16 @@
-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";
-}
+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";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC"}

package/dist/millisecondsToHMS.d.ts

@@ -0,0 +1,2 @@
+export declare const millisecondsToHMS: (ms: number) => string;
+//# sourceMappingURL=millisecondsToHMS.d.ts.map

package/dist/millisecondsToHMS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"millisecondsToHMS.d.ts","sourceRoot":"","sources":["../src/millisecondsToHMS.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,GAAI,IAAI,MAAM,KAAG,MAe9C,CAAC"}

package/dist/parseEnvVars.d.ts

@@ -0,0 +1,2 @@
+export declare const parseEnvVars: <T = Record<string, unknown>>(envs: Record<string, unknown>) => T;
+//# sourceMappingURL=parseEnvVars.d.ts.map

package/dist/parseEnvVars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseEnvVars.d.ts","sourceRoot":"","sources":["../src/parseEnvVars.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,GAAI,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,CAUzF,CAAC"}

package/dist/parseString.d.ts

@@ -0,0 +1,2 @@
+export declare const parseString: <T = unknown>(text: string) => T;
+//# sourceMappingURL=parseString.d.ts.map

package/dist/parseString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseString.d.ts","sourceRoot":"","sources":["../src/parseString.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,GAAI,CAAC,GAAG,OAAO,EAAE,MAAM,MAAM,KAAG,CA4CvD,CAAC"}

package/dist/random.d.ts

@@ -0,0 +1,6 @@
+export declare const random: {
+    nanoid(size?: number): string;
+    stringInt(size?: number): string;
+    nanoidFactory(size?: number): (size?: number) => string;
+};
+//# 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":"AAEA,eAAO,MAAM,MAAM;kBACH,MAAM,GAAG,MAAM;qBAGZ,MAAM,GAAG,MAAM;yBAGX,MAAM,GAAG,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM;CAGxD,CAAC"}

package/dist/secondsToHMS.d.ts

@@ -0,0 +1,2 @@
+export declare const secondsToHMS: (seconds: number) => string;
+//# sourceMappingURL=secondsToHMS.d.ts.map

package/dist/secondsToHMS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secondsToHMS.d.ts","sourceRoot":"","sources":["../src/secondsToHMS.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,KAAG,MAe9C,CAAC"}

package/dist/secondsToMS.d.ts

@@ -0,0 +1,2 @@
+export declare const secondsToMS: (seconds: number) => string;
+//# sourceMappingURL=secondsToMS.d.ts.map

package/dist/secondsToMS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secondsToMS.d.ts","sourceRoot":"","sources":["../src/secondsToMS.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,SAAS,MAAM,KAAG,MAI7C,CAAC"}

package/dist/sleep.d.ts

@@ -0,0 +1,2 @@
+export declare const sleep: (ms: number) => Promise<void>;
+//# sourceMappingURL=sleep.d.ts.map

package/dist/sleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../src/sleep.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,GAAI,IAAI,MAAM,KAAG,OAAO,CAAC,IAAI,CAE9C,CAAC"}

package/dist/splitToWords.d.ts

@@ -0,0 +1,2 @@
+export declare const splitToWords: (input: string) => RegExpMatchArray | [];
+//# sourceMappingURL=splitToWords.d.ts.map

package/dist/splitToWords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splitToWords.d.ts","sourceRoot":"","sources":["../src/splitToWords.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,0BAEzC,CAAC"}

package/dist/toCamelCase.d.ts

@@ -0,0 +1,2 @@
+export declare const toCamelCase: (input: string) => string;
+//# sourceMappingURL=toCamelCase.d.ts.map

package/dist/toCamelCase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toCamelCase.d.ts","sourceRoot":"","sources":["../src/toCamelCase.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,KAAG,MAI3C,CAAC"}

package/dist/toKebabCase.d.ts

@@ -0,0 +1,2 @@
+export declare const toKebabCase: (input: string) => string;
+//# sourceMappingURL=toKebabCase.d.ts.map

package/dist/toKebabCase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toKebabCase.d.ts","sourceRoot":"","sources":["../src/toKebabCase.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,KAAG,MAG3C,CAAC"}

package/dist/toPascalCase.d.ts

@@ -0,0 +1,2 @@
+export declare const toPascalCase: (input: string) => string;
+//# sourceMappingURL=toPascalCase.d.ts.map

package/dist/toPascalCase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toPascalCase.d.ts","sourceRoot":"","sources":["../src/toPascalCase.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,KAAG,MAG5C,CAAC"}

package/dist/trim.d.ts

@@ -0,0 +1,2 @@
+export declare const trim: (text: string, char?: string) => string;
+//# sourceMappingURL=trim.d.ts.map

package/dist/trim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trim.d.ts","sourceRoot":"","sources":["../src/trim.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,EAAE,aAAU,KAAG,MAO/C,CAAC"}

package/package.json

@@ -1,13 +1,20 @@
 {
   "name": "@ooneex/utils",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
   "license": "MIT",
   "scripts": {
-    "compile": "tsc ./src/index.ts --declaration --emitDeclarationOnly --target ES2022 --moduleResolution bundler --outfile dist/index.d.ts",
+    "compile": "tsc -p tsconfig.build.json",
     "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"
   },
@@ -15,9 +22,5 @@
   "peerDependencies": {},
   "dependencies": {
     "nanoid": "^5.1.6"
-  },
-  "files": [
-    "dist/**/*.js",
-    "dist/**/*.d.ts"
-  ]
+  }
 }

package/src/capitalizeWord.ts

@@ -0,0 +1,3 @@
+export const capitalizeWord = (word: string): string => {
+  return word ? word[0]?.toUpperCase() + word.slice(1).toLowerCase() : word;
+};

package/src/dataURLtoFile.ts

@@ -0,0 +1,12 @@
+export const dataURLtoFile = (dataurl: string, filename: string) => {
+  const arr = dataurl.split(",");
+  const mimeMatch = arr[0]?.match(/:(.*?);/);
+  const mime = mimeMatch ? mimeMatch[1] : "";
+  const bstr = atob(arr[1] as string);
+  let n = bstr.length;
+  const u8arr = new Uint8Array(n);
+  while (n--) {
+    u8arr[n] = bstr.charCodeAt(n);
+  }
+  return new File([u8arr], filename, { type: mime });
+};

package/src/formatRelativeNumber.ts

@@ -0,0 +1,7 @@
+export const formatRelativeNumber = (num: number, config?: { precision?: number; lang?: string }): string => {
+  return new Intl.NumberFormat(config?.lang ?? "en-GB", {
+    notation: "compact",
+    compactDisplay: "short",
+    maximumFractionDigits: config?.precision ?? 1,
+  }).format(num);
+};

package/src/index.ts

@@ -0,0 +1,15 @@
+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/src/millisecondsToHMS.ts

@@ -0,0 +1,16 @@
+export const millisecondsToHMS = (ms: number): string => {
+  const totalSeconds = Math.floor(ms / 1000);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+
+  if (hours > 0) {
+    return `${hours}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+  }
+
+  if (minutes > 0) {
+    return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+  }
+
+  return seconds.toString();
+};

package/src/parseEnvVars.ts

@@ -0,0 +1,14 @@
+import { parseString } from "./parseString";
+import { toCamelCase } from "./toCamelCase";
+
+export const parseEnvVars = <T = Record<string, unknown>>(envs: Record<string, unknown>): T => {
+  const vars: Record<string, unknown> = {};
+
+  for (const key in envs) {
+    const k = toCamelCase(key);
+    const value = parseString(envs[key] as string) as unknown;
+    vars[k] = value;
+  }
+
+  return vars as T;
+};

package/src/parseString.ts

@@ -0,0 +1,47 @@
+import { trim } from "./trim";
+
+export const parseString = <T = unknown>(text: string): T => {
+  if (/^[0-9]+$/.test(text)) {
+    return Number.parseInt(text, 10) as T;
+  }
+
+  if (/^[0-9]+[.][0-9]+$/.test(text)) {
+    return Number.parseFloat(text) as T;
+  }
+
+  if (/^true$/i.test(text)) {
+    return true as T;
+  }
+
+  if (/^false$/i.test(text)) {
+    return false as T;
+  }
+
+  if (/^null$/i.test(text)) {
+    return null as T;
+  }
+
+  if (/^\[/.test(text) && /]$/.test(text)) {
+    const trimmedText = trim(text, "\\[|\\]");
+
+    let values: unknown[] = trimmedText.split(/, */);
+
+    values = values.map((value) => {
+      return parseString(value as string);
+    });
+
+    return values as T;
+  }
+
+  try {
+    const result = JSON.parse(text);
+
+    if (result === Number.POSITIVE_INFINITY || result === Number.NEGATIVE_INFINITY) {
+      return text as T;
+    }
+
+    return result;
+  } catch {
+    return text as T;
+  }
+};

package/src/random.ts

@@ -0,0 +1,13 @@
+import { customAlphabet } from "nanoid";
+
+export const random = {
+  nanoid(size?: number): string {
+    return customAlphabet("1234567890abcdef", size ?? 10)();
+  },
+  stringInt(size?: number): string {
+    return customAlphabet("1234567890", size ?? 10)();
+  },
+  nanoidFactory(size?: number): (size?: number) => string {
+    return customAlphabet("1234567890abcdef", size ?? 10);
+  },
+};

package/src/secondsToHMS.ts

@@ -0,0 +1,16 @@
+export const secondsToHMS = (seconds: number): string => {
+  const totalSeconds = Math.floor(seconds);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const remainingSeconds = totalSeconds % 60;
+
+  if (hours > 0) {
+    return `${hours}:${minutes.toString().padStart(2, "0")}:${remainingSeconds.toString().padStart(2, "0")}`;
+  }
+
+  if (minutes > 0) {
+    return `${minutes}:${remainingSeconds.toString().padStart(2, "0")}`;
+  }
+
+  return remainingSeconds.toString();
+};

package/src/secondsToMS.ts

@@ -0,0 +1,5 @@
+export const secondsToMS = (seconds: number): string => {
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}:${remainingSeconds.toString().padStart(2, "0")}`;
+};

package/src/sleep.ts

@@ -0,0 +1,3 @@
+export const sleep = (ms: number): Promise<void> => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};

package/src/splitToWords.ts

@@ -0,0 +1,14 @@
+const CAPITALIZED_WORD_REGEXP = /\p{Lu}\p{Ll}+/u; // e.g. Apple
+const 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
+const LOWERCASED_WORD_REGEXP = /(\p{Ll}+)/u; // e.g. apple
+const ANY_LETTERS = /\p{L}+/u; // will match any sequence of letters, including in languages without a concept of upper/lower case
+const DIGITS_REGEXP = /\p{N}+/u; // e.g. 123
+
+const WORD_OR_NUMBER_REGEXP = new RegExp(
+  `${CAPITALIZED_WORD_REGEXP.source}|${ACRONYM_REGEXP.source}|${LOWERCASED_WORD_REGEXP.source}|${ANY_LETTERS.source}|${DIGITS_REGEXP.source}`,
+  "gu",
+);
+
+export const splitToWords = (input: string) => {
+  return input.match(WORD_OR_NUMBER_REGEXP) ?? [];
+};

package/src/toCamelCase.ts

@@ -0,0 +1,8 @@
+import { capitalizeWord } from "./capitalizeWord";
+import { splitToWords } from "./splitToWords";
+
+export const toCamelCase = (input: string): string => {
+  input = input.trim();
+  const [first = "", ...rest] = splitToWords(input);
+  return [first.toLowerCase(), ...rest.map(capitalizeWord)].join("");
+};

package/src/toKebabCase.ts

@@ -0,0 +1,6 @@
+import { splitToWords } from "./splitToWords";
+
+export const toKebabCase = (input: string): string => {
+  input = input.trim();
+  return splitToWords(input).join("-").toLowerCase();
+};

package/src/toPascalCase.ts

@@ -0,0 +1,7 @@
+import { capitalizeWord } from "./capitalizeWord";
+import { splitToWords } from "./splitToWords";
+
+export const toPascalCase = (input: string): string => {
+  input = input.trim();
+  return splitToWords(input).map(capitalizeWord).join("");
+};

package/src/trim.ts

@@ -0,0 +1,8 @@
+export const trim = (text: string, char = " "): string => {
+  if ([".", "[", "]", "(", ")", "+", "*", "^", "$", "?", "/", "\\"].includes(char)) {
+    char = `\\${char}`;
+  }
+
+  const reg = new RegExp(`^${char}+|${char}+$`, "g");
+  return text.replace(reg, "");
+};

package/tests/capitalizeWord.spec.ts

@@ -0,0 +1,163 @@
+import { describe, expect, test } from "bun:test";
+import { capitalizeWord } from "@/index";
+
+describe("capitalizeWord", () => {
+  describe("basic functionality", () => {
+    test("should capitalize first letter of lowercase word", () => {
+      expect(capitalizeWord("hello")).toBe("Hello");
+    });
+
+    test("should capitalize first letter and lowercase the rest", () => {
+      expect(capitalizeWord("hELLO")).toBe("Hello");
+    });
+
+    test("should handle single character", () => {
+      expect(capitalizeWord("a")).toBe("A");
+    });
+
+    test("should handle uppercase single character", () => {
+      expect(capitalizeWord("A")).toBe("A");
+    });
+
+    test("should handle already capitalized word", () => {
+      expect(capitalizeWord("Hello")).toBe("Hello");
+    });
+
+    test("should handle mixed case word", () => {
+      expect(capitalizeWord("hElLo")).toBe("Hello");
+    });
+  });
+
+  describe("edge cases", () => {
+    test("should return empty string when input is empty", () => {
+      expect(capitalizeWord("")).toBe("");
+    });
+
+    test("should handle words with numbers", () => {
+      expect(capitalizeWord("hello123")).toBe("Hello123");
+    });
+
+    test("should handle words starting with numbers", () => {
+      expect(capitalizeWord("123hello")).toBe("123hello");
+    });
+
+    test("should handle special characters", () => {
+      expect(capitalizeWord("!hello")).toBe("!hello");
+    });
+
+    test("should handle words with special characters", () => {
+      expect(capitalizeWord("hello-world")).toBe("Hello-world");
+    });
+
+    test("should handle accented characters", () => {
+      expect(capitalizeWord("école")).toBe("École");
+    });
+
+    test("should handle non-latin characters", () => {
+      expect(capitalizeWord("привет")).toBe("Привет");
+    });
+  });
+
+  describe("whitespace handling", () => {
+    test("should handle words with leading spaces", () => {
+      expect(capitalizeWord(" hello")).toBe(" hello");
+    });
+
+    test("should handle words with trailing spaces", () => {
+      expect(capitalizeWord("hello ")).toBe("Hello ");
+    });
+
+    test("should handle single space", () => {
+      expect(capitalizeWord(" ")).toBe(" ");
+    });
+
+    test("should handle multiple spaces", () => {
+      expect(capitalizeWord("   ")).toBe("   ");
+    });
+
+    test("should handle tab character", () => {
+      expect(capitalizeWord("\t")).toBe("\t");
+    });
+
+    test("should handle newline character", () => {
+      expect(capitalizeWord("\n")).toBe("\n");
+    });
+  });
+
+  describe("parametrized tests", () => {
+    test.each([
+      ["word", "Word"],
+      ["WORD", "Word"],
+      ["wORD", "Word"],
+      ["test", "Test"],
+      ["javascript", "Javascript"],
+      ["typescript", "Typescript"],
+      ["react", "React"],
+    ])("capitalizeWord(%s) should return %s", (input, expected) => {
+      expect(capitalizeWord(input)).toBe(expected);
+    });
+  });
+
+  describe("type safety", () => {
+    test("should handle very long strings", () => {
+      const longString = "a".repeat(1000);
+      const result = capitalizeWord(longString);
+      expect(result).toHaveLength(1000);
+      expect(result[0]).toBe("A");
+      expect(result.slice(1)).toBe("a".repeat(999));
+    });
+
+    test("should handle unicode characters", () => {
+      expect(capitalizeWord("émile")).toBe("Émile");
+      expect(capitalizeWord("ñoño")).toBe("Ñoño");
+      expect(capitalizeWord("café")).toBe("Café");
+    });
+
+    test("should handle emoji", () => {
+      expect(capitalizeWord("😀hello")).toBe("😀hello");
+      expect(capitalizeWord("hello😀")).toBe("Hello😀");
+    });
+  });
+
+  describe("function behavior", () => {
+    test("should not mutate original string", () => {
+      const original = "hello";
+      const result = capitalizeWord(original);
+      expect(original).toBe("hello");
+      expect(result).toBe("Hello");
+    });
+
+    test("should return string type", () => {
+      const result = capitalizeWord("test");
+      expect(typeof result).toBe("string");
+    });
+
+    test("should handle consecutive calls consistently", () => {
+      const word = "hello";
+      const result1 = capitalizeWord(word);
+      const result2 = capitalizeWord(word);
+      expect(result1).toBe(result2);
+      expect(result1).toBe("Hello");
+    });
+  });
+
+  describe("real world examples", () => {
+    test("should capitalize common names", () => {
+      expect(capitalizeWord("john")).toBe("John");
+      expect(capitalizeWord("mary")).toBe("Mary");
+      expect(capitalizeWord("david")).toBe("David");
+    });
+
+    test("should handle programming terms", () => {
+      expect(capitalizeWord("function")).toBe("Function");
+      expect(capitalizeWord("variable")).toBe("Variable");
+      expect(capitalizeWord("method")).toBe("Method");
+    });
+
+    test("should handle common words", () => {
+      expect(capitalizeWord("the")).toBe("The");
+      expect(capitalizeWord("and")).toBe("And");
+      expect(capitalizeWord("but")).toBe("But");
+    });
+  });
+});