@ooneex/utils 0.0.3 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ooneex/utils",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,7 +9,7 @@
   "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"
+    "publish": "bun run build && bun publish --access public"
   },
   "devDependencies": {},
   "peerDependencies": {},

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");
+    });
+  });
+});