@elyukai/utils 0.1.2

package/dist/roman.js

@@ -0,0 +1,47 @@
+import { minus } from "./string/number.js";
+const signPairs = [
+    ["I", "V"],
+    ["X", "L"],
+    ["C", "D"],
+    ["M", "ↁ"],
+];
+const romanizeNatural = (num) => num
+    .toString(10)
+    .split("")
+    .reverse()
+    .map((digit, index) => {
+    const pair = signPairs[index];
+    if (pair === undefined) {
+        return "?";
+    }
+    const value = parseInt(digit, 10);
+    const [one, five] = pair;
+    if (value <= 3) {
+        return one.repeat(value);
+    }
+    else if (value === 4) {
+        return one + five;
+    }
+    else if (value <= 8) {
+        return five + one.repeat(value - 5);
+    }
+    else {
+        return one + (signPairs[index + 1]?.[0] ?? "?");
+    }
+})
+    .reverse()
+    .join("");
+/**
+ * Converts a number to a roman numeral.
+ */
+export const romanize = (num) => {
+    if (num === 0) {
+        return "0";
+    }
+    else if (num < 0) {
+        return minus + romanizeNatural(-num);
+    }
+    else {
+        return romanizeNatural(num);
+    }
+};

package/dist/string/number.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The minus sign.
+ */
+export declare const minus = "\u2212";
+/**
+ * The plus/minus sign.
+ */
+export declare const plusMinus = "\u00B1";
+/**
+ * Forces signing on the given number, returning `undefined` on zero.
+ */
+export declare const signIgnoreZero: (x: number) => string | undefined;
+/**
+ * Forces signing on the given number.
+ */
+export declare const sign: (x: number) => string;
+/**
+ * Returns the sign of the given number. Returns `undefined` if the number is
+ * zero.
+ */
+export declare const signStr: (x: number) => string | undefined;
+/**
+ * Converts a string to an integer. If the string is not a valid integer, it
+ * returns `undefined`.
+ */
+export declare const parseInt: (str: string) => number | undefined;
+/**
+ * Converts a string to a natural number. If the string is not a valid natural
+ * number, it returns `undefined`.
+ */
+export declare const parseNat: (str: string) => number | undefined;

package/dist/string/number.js

@@ -0,0 +1,40 @@
+import { isInteger, isNaturalNumber } from "./regex.js";
+/**
+ * The minus sign.
+ */
+export const minus = "−";
+/**
+ * The plus/minus sign.
+ */
+export const plusMinus = "\xB1";
+/**
+ * Forces signing on the given number, returning `undefined` on zero.
+ */
+export const signIgnoreZero = (x) => x > 0
+    ? `+${x.toString()}`
+    : x < 0
+        ? `${minus}\u2060${Math.abs(x).toString()}`
+        : undefined;
+/**
+ * Forces signing on the given number.
+ */
+export const sign = (x) => x > 0
+    ? `+${x.toString()}`
+    : x < 0
+        ? `${minus}\u2060${Math.abs(x).toString()}`
+        : "0";
+/**
+ * Returns the sign of the given number. Returns `undefined` if the number is
+ * zero.
+ */
+export const signStr = (x) => x > 0 ? "+" : x < 0 ? minus : undefined;
+/**
+ * Converts a string to an integer. If the string is not a valid integer, it
+ * returns `undefined`.
+ */
+export const parseInt = (str) => str.length > 0 && isInteger(str) ? Number.parseInt(str, 10) : undefined;
+/**
+ * Converts a string to a natural number. If the string is not a valid natural
+ * number, it returns `undefined`.
+ */
+export const parseNat = (str) => str.length > 0 && isNaturalNumber(str) ? Number.parseInt(str, 10) : undefined;

package/dist/string/regex.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Checks if the provided string is a string representation of a natural number.
+ * @param test The string to test.
+ */
+export declare const isNaturalNumber: (test: string) => boolean;
+/**
+ * Checks if the provided string is a string representation of an integer.
+ * @param test The string to test.
+ */
+export declare const isInteger: (test: string) => boolean;
+/**
+ * Checks if the provided string is a string representation of a floating-point
+ * number. Both `.` and `,` are accepted as decimal separators.
+ * @param test The string to test.
+ */
+export declare const isFloat: (test: string) => boolean;
+/**
+ * Checks if the provided string either is an empty string or passes the given
+ * test function.
+ * @param check The test function to apply if the string is not empty.
+ * @param test The string to test.
+ */
+export declare const isEmptyOr: (check: (test: string) => boolean, test: string) => boolean;
+/**
+ * Checks if the provided string is a valid URL.
+ * @param test The string to test.
+ */
+export declare const isUrl: (test: string) => boolean;

package/dist/string/regex.js

@@ -0,0 +1,38 @@
+const naturalNumberPattern = /^(?:0|[1-9][0-9]*)$/u;
+const integerPattern = /^(?:0|-?[1-9][0-9]*)$/u;
+const floatPattern = /^(?:(?:0|-?[1-9][0-9]*)(?:[.,][0-9]+)?)$/u;
+/**
+ * Checks if the provided string is a string representation of a natural number.
+ * @param test The string to test.
+ */
+export const isNaturalNumber = (test) => naturalNumberPattern.test(test);
+/**
+ * Checks if the provided string is a string representation of an integer.
+ * @param test The string to test.
+ */
+export const isInteger = (test) => integerPattern.test(test);
+/**
+ * Checks if the provided string is a string representation of a floating-point
+ * number. Both `.` and `,` are accepted as decimal separators.
+ * @param test The string to test.
+ */
+export const isFloat = (test) => floatPattern.test(test);
+/**
+ * Checks if the provided string either is an empty string or passes the given
+ * test function.
+ * @param check The test function to apply if the string is not empty.
+ * @param test The string to test.
+ */
+export const isEmptyOr = (check, test) => test === "" || check(test);
+/**
+ * Checks if the provided string is a valid URL.
+ * @param test The string to test.
+ */
+export const isUrl = (test) => {
+    try {
+        return typeof new URL(test) === "object";
+    }
+    catch {
+        return false;
+    }
+};

package/dist/string.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Checks if a value is a non-empty string.
+ */
+export declare const isNonEmptyString: (value: string | null | undefined) => value is string;
+/**
+ * Splits a string into its constituent parts based on casing and separators.
+ */
+export declare const splitStringParts: (str: string) => string[];
+/**
+ * Converts a string to PascalCase.
+ */
+export declare const toPascalCase: (str: string) => string;
+/**
+ * Converts a string to camelCase.
+ */
+export declare const toCamelCase: (str: string) => string;
+/**
+ * Converts a string to kebab-case.
+ */
+export declare const toKebabCase: (str: string) => string;
+/**
+ * Converts a string to snake_case.
+ */
+export declare const toSnakeCase: (str: string) => string;
+/**
+ * Converts a string to Title Case.
+ */
+export declare const toTitleCase: (str: string) => string;
+/**
+ * Finds the longest common prefix among the provided strings.
+ */
+export declare const commonPrefix: (...strs: string[]) => string;

package/dist/string.js

@@ -0,0 +1,96 @@
+/**
+ * Checks if a value is a non-empty string.
+ */
+export const isNonEmptyString = (value) => typeof value === "string" && value.length > 0;
+const letterOrDigit = /[a-zA-Z0-9]/;
+const uppercase = /[A-Z]/;
+const lowerCaseOrDigit = /[a-z0-9]/;
+const separator = /[^a-z0-9]/;
+const lastChar = (str) => str[str.length - 1];
+const lastElement = (arr) => arr[arr.length - 1];
+const isAllUppercase = (str) => str === str.toUpperCase();
+/**
+ * Splits a string into its constituent parts based on casing and separators.
+ */
+export const splitStringParts = (str) => [...new Intl.Segmenter().segment(str)].reduce((acc, segment, i, strArr) => {
+    const char = segment.segment;
+    if (acc.length === 0) {
+        return letterOrDigit.test(char) ? [char] : acc;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const lastPart = lastElement(acc);
+    if (uppercase.test(char)) {
+        const lastCharOfLastPart = lastChar(lastPart);
+        const nextSegment = strArr[i + 1];
+        const nextChar = nextSegment?.segment;
+        if (lastCharOfLastPart === undefined ||
+            (uppercase.test(lastCharOfLastPart) &&
+                (nextChar === undefined || separator.test(nextChar)))) {
+            return [...acc.slice(0, -1), lastPart + char];
+        }
+        else {
+            return [...acc, char];
+        }
+    }
+    if (lowerCaseOrDigit.test(char)) {
+        return [...acc.slice(0, -1), lastPart + char];
+    }
+    if (lastPart === "") {
+        return acc;
+    }
+    else {
+        return [...acc, ""];
+    }
+}, []);
+/**
+ * Converts a string to PascalCase.
+ */
+export const toPascalCase = (str) => splitStringParts(isAllUppercase(str) ? str.toLowerCase() : str)
+    .map((part) => isAllUppercase(part)
+    ? part
+    : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+    .join("");
+/**
+ * Converts a string to camelCase.
+ */
+export const toCamelCase = (str) => splitStringParts(isAllUppercase(str) ? str.toLowerCase() : str)
+    .map((part, i) => i === 0
+    ? part.toLowerCase()
+    : isAllUppercase(part)
+        ? part
+        : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+    .join("");
+/**
+ * Converts a string to kebab-case.
+ */
+export const toKebabCase = (str) => splitStringParts(str)
+    .map((part) => part.toLowerCase())
+    .join("-");
+/**
+ * Converts a string to snake_case.
+ */
+export const toSnakeCase = (str) => splitStringParts(str)
+    .map((part) => part.toLowerCase())
+    .join("_");
+/**
+ * Converts a string to Title Case.
+ */
+export const toTitleCase = (str) => splitStringParts(isAllUppercase(str) ? str.toLowerCase() : str)
+    .map((part) => isAllUppercase(part)
+    ? part
+    : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+    .join(" ");
+/**
+ * Finds the longest common prefix among the provided strings.
+ */
+export const commonPrefix = (...strs) => {
+    if (strs.length === 0) {
+        return "";
+    }
+    return strs.reduce((accPrefix, str) => {
+        const indexOfDifference = Array.from(accPrefix).findIndex((char, i) => str[i] !== char);
+        return indexOfDifference === -1
+            ? accPrefix
+            : accPrefix.slice(0, indexOfDifference);
+    });
+};

package/dist/typeSafety.d.ts

@@ -0,0 +1,38 @@
+/**
+ * This function is used to make sure that the `switch` is exhaustive. Place it
+ * in the `default` case of the `switch`.
+ *
+ * Optionally, you can pass a custom error message.
+ * @param _x - The value that is used in the `switch`.
+ * @param [msg] - A custom error message.
+ * @example
+ * const aorb = (x: "a" | "b") => {
+ *   switch (x) {
+ *     case "a": return 1
+ *     case "b": return 2
+ *     default: return assertExhaustive(x)
+ *   }
+ * }
+ */
+export declare function assertExhaustive(_x: never, msg?: string): never;
+/**
+ * Tries to execute a function, returning a default value if an error is thrown.
+ * @param f The function to execute.
+ * @param defaultValue The default value to return if an error is thrown.
+ * @returns The result of the function if successful, or the default value.
+ */
+export declare const trySafe: {
+    /**
+     * Tries to execute a function, returning `undefined` if an error is thrown.
+     * @param f The function to execute.
+     * @returns The result of the function if successful, or `undefined`.
+     */
+    <T>(f: () => T): T | undefined;
+    /**
+     * Tries to execute a function, returning a default value if an error is thrown.
+     * @param f The function to execute.
+     * @param defaultValue The default value to return if an error is thrown.
+     * @returns The result of the function if successful, or the default value.
+     */
+    <T>(f: () => T, defaultValue: T): T;
+};

package/dist/typeSafety.js

@@ -0,0 +1,33 @@
+/**
+ * This function is used to make sure that the `switch` is exhaustive. Place it
+ * in the `default` case of the `switch`.
+ *
+ * Optionally, you can pass a custom error message.
+ * @param _x - The value that is used in the `switch`.
+ * @param [msg] - A custom error message.
+ * @example
+ * const aorb = (x: "a" | "b") => {
+ *   switch (x) {
+ *     case "a": return 1
+ *     case "b": return 2
+ *     default: return assertExhaustive(x)
+ *   }
+ * }
+ */
+export function assertExhaustive(_x, msg = "The switch is not exhaustive.") {
+    throw new Error(msg);
+}
+/**
+ * Tries to execute a function, returning a default value if an error is thrown.
+ * @param f The function to execute.
+ * @param defaultValue The default value to return if an error is thrown.
+ * @returns The result of the function if successful, or the default value.
+ */
+export const trySafe = (f, defaultValue) => {
+    try {
+        return f();
+    }
+    catch {
+        return defaultValue;
+    }
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@elyukai/utils",
+  "version": "0.1.2",
+  "description": "A set of JavaScript helper functions.",
+  "files": [
+    "dist",
+    "!dist/**/*.tsbuildinfo",
+    "AUTHORS",
+    "CHANGELOG.md"
+  ],
+  "exports": {
+    "./*": "./dist/*.js"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "watch": "tsc -b -w",
+    "test": "node --import tsx --test",
+    "lint": "eslint",
+    "format": "prettier \"{src,test}/**/*.{ts,tsx}\" --write",
+    "format:check": "prettier \"{src,test}/**/*.{ts,tsx}\" --check",
+    "release": "commit-and-tag-version",
+    "release:sign": "commit-and-tag-version --sign --signoff"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/elyukai/ts-utils.git"
+  },
+  "author": "Lukas Obermann",
+  "license": "MPL-2.0",
+  "bugs": {
+    "url": "https://github.com/elyukai/ts-utils/issues"
+  },
+  "homepage": "https://github.com/elyukai/ts-utils#readme",
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/node": "^25.0.10",
+    "commit-and-tag-version": "^12.6.1",
+    "eslint": "^9.39.2",
+    "glob": "^13.0.0",
+    "prettier": "^3.8.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.53.1"
+  },
+  "type": "module"
+}