@rebasepro/utils 0.0.1-canary.4d4fb3e

package/src/objects.ts

@@ -0,0 +1,376 @@
+import hash from "object-hash";
+import { GeoPoint } from "@rebasepro/types";
+
+/** @private is the value an empty array? */
+export const isEmptyArray = (value?: unknown) =>
+    Array.isArray(value) && value.length === 0;
+
+/** @private is the given object a Function? */
+export const isFunction = (obj: unknown): obj is Function =>
+    typeof obj === "function";
+
+/** @private is the given object an integer? */
+export const isInteger = (obj: unknown): boolean =>
+    String(Math.floor(Number(obj))) === String(obj);
+
+/** @private is the given object a NaN? */
+// eslint-disable-next-line no-self-compare
+export const isNaN = (obj: unknown): boolean => obj !== obj;
+
+/**
+ * Deeply get a value from an object via its path.
+ */
+export function getIn(
+    obj: Record<string, unknown> | unknown[] | unknown,
+    key: string | string[],
+    def?: unknown,
+    p = 0
+) {
+    const path = toPath(key);
+    while (obj && p < path.length) {
+        obj = (obj as Record<string, unknown>)[path[p++]];
+    }
+
+    // check if path is not in the end
+    if (p !== path.length && !obj) {
+        return def;
+    }
+
+    return obj === undefined ? def : obj;
+}
+
+export function setIn<T>(obj: T, path: string, value: unknown): T {
+    const res = clone(obj) as Record<string, unknown>;
+    let resVal: Record<string, unknown> = res;
+    let i = 0;
+    const pathArray = toPath(path);
+
+    for (; i < pathArray.length - 1; i++) {
+        const currentPath: string = pathArray[i];
+        const currentObj = getIn(obj as Record<string, unknown>, pathArray.slice(0, i + 1));
+
+        if (currentObj && (isObject(currentObj) || Array.isArray(currentObj))) {
+            resVal = resVal[currentPath] = clone(currentObj) as Record<string, unknown>;
+        } else {
+            const nextPath: string = pathArray[i + 1];
+            resVal = resVal[currentPath] =
+                (isInteger(nextPath) && Number(nextPath) >= 0 ? [] : {}) as Record<string, unknown>;
+        }
+    }
+
+    // Return original object if new value is the same as current
+    if ((i === 0 ? obj as Record<string, unknown> : resVal)[pathArray[i]] === value) {
+        return obj;
+    }
+
+    if (value === undefined) {
+        delete resVal[pathArray[i]];
+    } else {
+        resVal[pathArray[i]] = value;
+    }
+
+    // If the path array has a single element, the loop did not run.
+    // Deleting on `resVal` had no effect in this scenario, so we delete on the result instead.
+    if (i === 0 && value === undefined) {
+        delete res[pathArray[i]];
+    }
+
+    return res as T;
+}
+
+export function clone<T>(value: T): T {
+    if (Array.isArray(value)) {
+        return [...value] as unknown as T;
+    } else if (typeof value === "object" && value !== null) {
+        return { ...value } as T;
+    } else {
+        return value; // This is for primitive types which do not need cloning.
+    }
+}
+
+function toPath(value: string | string[]) {
+    if (Array.isArray(value)) return value; // Already in path array form.
+    // Replace brackets with dots, remove leading/trailing dots, then split by dot.
+    return value.replace(/\[(\d+)]/g, ".$1").replace(/^\./, "").replace(/\.$/, "").split(".");
+}
+
+
+export const pick: <T extends Record<string, unknown>>(obj: T, ...args: (keyof T)[]) => Partial<T> = <T extends Record<string, unknown>>(obj: T, ...args: (keyof T)[]) => ({
+    ...args.reduce<Record<string, unknown>>((res, key) => ({
+        ...res,
+        [key as string]: obj[key as string]
+    }), {})
+}) as Partial<T>;
+
+export function isObject(item: unknown): item is Record<string, unknown> {
+    return !!item && typeof item === "object" && !Array.isArray(item);
+}
+
+export function isPlainObject(obj: unknown): obj is Record<string, unknown> {
+    // 1. Rule out non-objects, null, and arrays
+    if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+        return false;
+    }
+
+    // 2. Get the object's direct prototype
+    const proto = Object.getPrototypeOf(obj);
+
+    // 3. A plain object's direct prototype is Object.prototype
+    return proto === Object.prototype;
+}
+
+export function mergeDeep<T extends object, U extends object>(
+    target: T,
+    source: U,
+    ignoreUndefined: boolean = false
+): T & U {
+    // If target is not a true object (e.g., null, array, primitive), return target itself.
+    if (!isObject(target)) {
+        return target as T & U;
+    }
+
+    // Create a shallow copy of the target to avoid modifying the original object.
+    const output = { ...target };
+
+    // If source is not a true object, there's nothing to merge from it.
+    // Return the shallow copy of target.
+    if (!isObject(source)) {
+        return output as T & U;
+    }
+
+    // Iterate over keys in the source object.
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const sourceValue = source[key];
+            const outputValue = (output as Record<string, unknown>)[key]; // Current value in our merged object (originating from target)
+
+            // Skip if source value is undefined and ignoreUndefined is true.
+            // This handles both not adding new undefined properties and not overwriting existing properties with undefined.
+            if (ignoreUndefined && sourceValue === undefined) {
+                continue;
+            }
+
+            if ((sourceValue as unknown) instanceof Date) {
+                // If source value is a Date, create a new Date instance.
+                (output as Record<string, unknown>)[key] = new Date((sourceValue as unknown as Date).getTime());
+            } else if (Array.isArray(sourceValue)) {
+                if (Array.isArray(outputValue)) {
+                    const newArray = [];
+                    const maxLength = Math.max(outputValue.length, sourceValue.length);
+                    for (let i = 0; i < maxLength; i++) {
+                        const sourceItem = sourceValue[i];
+                        const targetItem = outputValue[i];
+
+                        if (i >= sourceValue.length) { // source is shorter
+                            newArray[i] = targetItem;
+                        } else if (i >= outputValue.length) { // target is shorter
+                            newArray[i] = sourceItem;
+                        } else if (sourceItem === null) {
+                            newArray[i] = targetItem;
+                        } else if (isPlainObject(sourceItem) && isPlainObject(targetItem)) {
+                            // Only recursively merge plain objects, preserve class instances
+                            newArray[i] = mergeDeep(targetItem, sourceItem, ignoreUndefined);
+                        } else {
+                            // For class instances and primitives, use source directly
+                            newArray[i] = sourceItem;
+                        }
+                    }
+                    (output as Record<string, unknown>)[key] = newArray;
+                } else {
+                    // If output's value (from target) is not an array,
+                    // overwrite with a shallow copy of the source array.
+                    (output as Record<string, unknown>)[key] = [...sourceValue];
+                }
+            } else if (isPlainObject(sourceValue)) {
+                // If source value is a plain object (not a class instance like EntityReference, GeoPoint, etc.):
+                if (isPlainObject(outputValue)) {
+                    // If the corresponding value in output (from target) is also a plain object, recurse.
+                    // Ensure the ignoreUndefined flag is passed down.
+                    (output as Record<string, unknown>)[key] = mergeDeep(outputValue as Record<string, unknown>, sourceValue, ignoreUndefined);
+                } else {
+                    // If output's value (from target) is not a plain object (e.g., null, primitive, class instance, or key didn't exist in original target),
+                    // overwrite with the source object.
+                    (output as Record<string, unknown>)[key] = sourceValue;
+                }
+            } else if (isObject(sourceValue)) {
+                // If source value is a class instance (not a plain object), use it directly to preserve prototype
+                (output as Record<string, unknown>)[key] = sourceValue;
+            } else {
+                // If source value is a primitive, null, or undefined (and not ignored).
+                (output as Record<string, unknown>)[key] = sourceValue;
+            }
+        }
+    }
+
+    return output as T & U;
+}
+
+export function getValueInPath(o: object | undefined, path: string): unknown {
+    if (!o) return undefined;
+    if (typeof o === "object") {
+        if (path in o) {
+            return (o as Record<string, unknown>)[path];
+        }
+        if (path.includes(".") || path.includes("[")) {
+            let pathSegments = path.split(/[.[]/);
+            if (path.includes("[")) {
+                pathSegments = pathSegments.map(segment => segment.replace("]", ""));
+            }
+            const firstSegment = pathSegments[0];
+            const isArrayAndIndexExists = Array.isArray((o as Record<string, unknown>)[firstSegment]) && !isNaN(parseInt(pathSegments[1]));
+            const nextObject = isArrayAndIndexExists
+                ? ((o as Record<string, unknown>)[firstSegment] as unknown[])[parseInt(pathSegments[1])]
+                : (o as Record<string, unknown>)[firstSegment];
+
+            const nextPath = pathSegments.slice(isArrayAndIndexExists ? 2 : 1).join(".");
+            if (nextPath === "")
+                return nextObject;
+            return getValueInPath(nextObject as object | undefined, nextPath);
+        }
+    }
+    return undefined;
+}
+
+export function removeInPath(o: object, path: string): object | undefined {
+    let currentObject = { ...o };
+    const parts = path.split(".");
+    const last = parts.pop();
+    for (const part of parts) {
+        currentObject = (currentObject as Record<string, unknown>)[part] as Record<string, unknown>;
+    }
+    if (last)
+        delete (currentObject as Record<string, unknown>)[last];
+    return currentObject;
+}
+
+export function removeFunctions(o: unknown): unknown {
+    if (o === undefined) return undefined;
+    if (o === null) return null;
+    if (typeof o === "object") {
+        // Handle arrays first - map over them recursively
+        if (Array.isArray(o)) {
+            return o.map(v => removeFunctions(v));
+        }
+        // Preserve class instances (EntityReference, GeoPoint, etc.) - don't recurse into them
+        if (!isPlainObject(o)) {
+            return o;
+        }
+        return Object.entries(o)
+            .filter(([_, value]) => typeof value !== "function")
+            .map(([key, value]) => {
+                if (Array.isArray(value)) {
+                    return { [key]: value.map(v => removeFunctions(v)) };
+                } else if (typeof value === "object") {
+                    return { [key]: removeFunctions(value) };
+                } else return { [key]: value };
+            })
+            .reduce((a, b) => ({ ...a, ...b }), {});
+    }
+    return o;
+}
+
+export function getHashValue<T>(v: T): string | null {
+    if (!v) return null;
+    if (typeof v === "object" && v !== null) {
+        if ("id" in v)
+            return String((v as Record<string, unknown>).id);
+        else if (v instanceof Date)
+            return v.toLocaleString();
+        else if (v instanceof GeoPoint)
+            return hash(v as unknown as Record<string, unknown>);
+    }
+    return hash(v as object, { ignoreUnknown: true });
+}
+
+export function removeUndefined(value: unknown, removeEmptyStrings?: boolean): unknown {
+    if (typeof value === "function") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((v: unknown) => removeUndefined(v, removeEmptyStrings));
+    }
+    if (typeof value === "object") {
+        if (value === null)
+            return value;
+        // Preserve class instances (EntityReference, GeoPoint, etc.) - don't recurse into them
+        if (!isPlainObject(value)) {
+            return value;
+        }
+        const res: Record<string, unknown> = {};
+        Object.keys(value).forEach((key) => {
+            if (!isEmptyObject(value as object)) {
+                const childRes = removeUndefined((value as Record<string, unknown>)[key], removeEmptyStrings);
+                const isString = typeof childRes === "string";
+                const shouldKeepIfString = !removeEmptyStrings || (removeEmptyStrings && !isString) || (removeEmptyStrings && isString && childRes !== "");
+                if (childRes !== undefined && !isEmptyObject(childRes as object) && shouldKeepIfString)
+                    res[key] = childRes;
+            }
+        });
+        return res;
+    }
+    return value;
+}
+
+export function removeNulls(value: unknown): unknown {
+    if (typeof value === "function") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((v: unknown) => removeNulls(v));
+    }
+    if (typeof value === "object") {
+        if (value === null)
+            return value;
+        // Preserve class instances (EntityReference, GeoPoint, etc.) - don't recurse into them
+        if (!isPlainObject(value)) {
+            return value;
+        }
+        const res: Record<string, unknown> = {};
+        const obj = value as Record<string, unknown>;
+        Object.keys(obj).forEach((key) => {
+            if (obj[key] !== null)
+                res[key] = removeNulls(obj[key]);
+        });
+        return res;
+    }
+    return value;
+}
+
+export function isEmptyObject(obj: object) {
+    return obj &&
+        Object.getPrototypeOf(obj) === Object.prototype &&
+        Object.keys(obj).length === 0
+}
+
+export function removePropsIfExisting(source: Record<string, unknown> | unknown[], comparison: Record<string, unknown> | unknown[]) {
+    const isObject = (val: unknown): val is Record<string, unknown> => typeof val === "object" && val !== null;
+    const isArray = (val: unknown): val is unknown[] => Array.isArray(val);
+
+    if (!isObject(source) || !isObject(comparison)) {
+        return source;
+    }
+
+    const res = isArray(source) ? [...source] : { ...source };
+
+    if (isArray(res)) {
+        for (let i = res.length - 1; i >= 0; i--) {
+            if (res[i] === comparison[i]) {
+                res.splice(i, 1);
+            } else if (isObject(res[i]) && isObject(comparison[i])) {
+                res[i] = removePropsIfExisting(res[i] as Record<string, unknown>, (comparison as unknown as unknown[])[i] as Record<string, unknown>);
+            }
+        }
+    } else {
+        Object.keys(comparison).forEach(key => {
+            if (key in res) {
+                if (isObject(res[key]) && isObject(comparison[key])) {
+                    res[key] = removePropsIfExisting(res[key], comparison[key]);
+                } else if (res[key] === comparison[key]) {
+                    delete res[key];
+                }
+            }
+        });
+    }
+
+    return res;
+}

package/src/os.ts

@@ -0,0 +1,13 @@
+export function getOS() {
+    let OS = "Unknown";
+    if (navigator.userAgent.indexOf("Win") !== -1) OS = "Windows";
+    if (navigator.userAgent.indexOf("Mac") !== -1) OS = "MacOS";
+    if (navigator.userAgent.indexOf("X11") !== -1) OS = "UNIX";
+    if (navigator.userAgent.indexOf("Linux") !== -1) OS = "Linux";
+    return OS;
+}
+
+export function getAltSymbol() {
+    if (getOS() === "MacOS") return "⌥";
+    return "Alt";
+}

package/src/plurals.ts

@@ -0,0 +1,188 @@
+/**
+ * Returns the plural of an English word.
+ *
+ * @param {string} word
+ * @param {number} [amount]
+ * @returns {string}
+ */
+export function plural(word: string, amount?: number): string {
+    if (amount !== undefined && amount === 1) {
+        return word
+    }
+    const plurals: { [key: string]: string } = {
+        "(quiz)$": "$1zes",
+        "^(ox)$": "$1en",
+        "([m|l])ouse$": "$1ice",
+        "(matr|vert|ind)ix|ex$": "$1ices",
+        "(x|ch|ss|sh)$": "$1es",
+        "([^aeiouy]|qu)y$": "$1ies",
+        "(hive)$": "$1s",
+        "(?:([^f])fe|([lr])f)$": "$1$2ves",
+        "(shea|lea|loa|thie)f$": "$1ves",
+        sis$: "ses",
+        "([ti])um$": "$1a",
+        "(tomat|potat|ech|her|vet)o$": "$1oes",
+        "(bu)s$": "$1ses",
+        "(alias)$": "$1es",
+        "(octop)us$": "$1i",
+        "(ax|test)is$": "$1es",
+        "(us)$": "$1es",
+        "([^s]+)$": "$1s"
+    }
+    const irregular: { [key: string]: string } = {
+        move: "moves",
+        foot: "feet",
+        goose: "geese",
+        sex: "sexes",
+        child: "children",
+        man: "men",
+        tooth: "teeth",
+        person: "people"
+    }
+    const uncountable: string[] = [
+        "sheep",
+        "fish",
+        "deer",
+        "moose",
+        "series",
+        "species",
+        "money",
+        "rice",
+        "information",
+        "equipment",
+        "bison",
+        "cod",
+        "offspring",
+        "pike",
+        "salmon",
+        "shrimp",
+        "swine",
+        "trout",
+        "aircraft",
+        "hovercraft",
+        "spacecraft",
+        "sugar",
+        "tuna",
+        "you",
+        "wood"
+    ]
+    // save some time in the case that singular and plural are the same
+    if (uncountable.indexOf(word.toLowerCase()) >= 0) {
+        return word;
+    }
+    // check for irregular forms
+    for (const w in irregular) {
+        const pattern = new RegExp(`${w}$`, "i")
+        const replace = irregular[w]
+        if (pattern.test(word)) {
+            return word.replace(pattern, replace);
+        }
+    }
+    // check for matches using regular expressions
+    for (const reg in plurals) {
+        const pattern = new RegExp(reg, "i")
+        if (pattern.test(word)) {
+            return word.replace(pattern, plurals[reg])
+        }
+    }
+    return word;
+}
+
+/**
+ * Returns the singular of an English word.
+ *
+ * @param {string} word
+ * @param {number} [amount]
+ * @returns {string}
+ */
+export function singular(word: string, amount?: number): string {
+    if (amount !== undefined && amount !== 1) {
+        return word;
+    }
+    const singulars: { [key: string]: string } = {
+        "(quiz)zes$": "$1",
+        "(matr)ices$": "$1ix",
+        "(vert|ind)ices$": "$1ex",
+        "^(ox)en$": "$1",
+        "(alias)es$": "$1",
+        "(octop|vir)i$": "$1us",
+        "(cris|ax|test)es$": "$1is",
+        "(shoe)s$": "$1",
+        "(o)es$": "$1",
+        "(bus)es$": "$1",
+        "([m|l])ice$": "$1ouse",
+        "(x|ch|ss|sh)es$": "$1",
+        "(m)ovies$": "$1ovie",
+        "(s)eries$": "$1eries",
+        "([^aeiouy]|qu)ies$": "$1y",
+        "([lr])ves$": "$1f",
+        "(tive)s$": "$1",
+        "(hive)s$": "$1",
+        "(li|wi|kni)ves$": "$1fe",
+        "(shea|loa|lea|thie)ves$": "$1f",
+        "(^analy)ses$": "$1sis",
+        "((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$": "$1$2sis",
+        "([ti])a$": "$1um",
+        "(n)ews$": "$1ews",
+        "(h|bl)ouses$": "$1ouse",
+        "(corpse)s$": "$1",
+        "(us)es$": "$1",
+        s$: ""
+    }
+    const irregular: { [key: string]: string } = {
+        move: "moves",
+        foot: "feet",
+        goose: "geese",
+        sex: "sexes",
+        child: "children",
+        man: "men",
+        tooth: "teeth",
+        person: "people"
+    }
+    const uncountable: string[] = [
+        "sheep",
+        "fish",
+        "deer",
+        "moose",
+        "series",
+        "species",
+        "money",
+        "rice",
+        "information",
+        "equipment",
+        "bison",
+        "cod",
+        "offspring",
+        "pike",
+        "salmon",
+        "shrimp",
+        "swine",
+        "trout",
+        "aircraft",
+        "hovercraft",
+        "spacecraft",
+        "sugar",
+        "tuna",
+        "you",
+        "wood"
+    ]
+    // save some time in the case that singular and plural are the same
+    if (uncountable.indexOf(word.toLowerCase()) >= 0) {
+        return word;
+    }
+    // check for irregular forms
+    for (const w in irregular) {
+        const pattern = new RegExp(`${irregular[w]}$`, "i");
+        if (pattern.test(word)) {
+            return word.replace(pattern, w);
+        }
+    }
+    // check for matches using regular expressions
+    for (const reg in singulars) {
+        const pattern = new RegExp(reg, "i");
+        if (pattern.test(word)) {
+            return word.replace(pattern, singulars[reg]);
+        }
+    }
+    return word;
+}

package/src/regexp.ts

@@ -0,0 +1,32 @@
+export function serializeRegExp(input: RegExp): string {
+    if (!input) return "";
+    // const fragments = input.toString().match(/\/(.*?)\/([a-z]*)?$/i);
+    // if (fragments) {
+    //     if (fragments[2])
+    //         return input.toString();
+    //     return fragments[1];
+    // }
+    return input.toString();
+}
+
+/**
+ * Get a RegExp out of a serialized string
+ * @param input
+ */
+export function hydrateRegExp(input?: string): RegExp | undefined {
+    if (!input) return undefined;
+    const fragments = input.match(/\/(.*?)\/([a-z]*)?$/i);
+    if (fragments) {
+        return new RegExp(fragments[1], fragments[2] || "");
+    } else {
+        return new RegExp(input, "");
+    }
+}
+
+export function isValidRegExp(input: string): boolean {
+    const fullRegexp = input.match(/\/((?![*+?])(?:[^\r\n[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*])+)\/((?:g(?:im?|mi?)?|i(?:gm?|mg?)?|m(?:gi?|ig?)?)?)/);
+    if (fullRegexp)
+        return true;
+    const simpleRegexp = input.match(/((?![*+?])(?:[^\r\n[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*])+)/);
+    return !!simpleRegexp;
+}

package/src/strings.ts

@@ -0,0 +1,84 @@
+const kebabCaseRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g;
+
+export const toKebabCase = (str: string) => {
+    const regExpMatchArray = str.match(kebabCaseRegex);
+    if (!regExpMatchArray) return "";
+    return regExpMatchArray
+        .map(x => x.toLowerCase())
+        .join("-");
+};
+
+const snakeCaseRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g;
+
+export const toSnakeCase = (str: string) => {
+    const regExpMatchArray = str.match(snakeCaseRegex);
+    if (!regExpMatchArray) return "";
+    return regExpMatchArray
+        .map(x => x.toLowerCase())
+        .join("_");
+};
+
+export function randomString(strLength = 5) {
+    return Math.random().toString(36).slice(2, 2 + strLength);
+}
+
+export function randomColor() {
+    return Math.floor(Math.random() * 16777215).toString(16);
+}
+
+export function slugify(text?: string, separator = "_", lowercase = true) {
+    if (!text) return "";
+    const from = "ãàáäâẽèéëêìíïîõòóöôùúüûñç·/_,:;-"
+    const to = `aaaaaeeeeeiiiiooooouuuunc${separator}${separator}${separator}${separator}${separator}${separator}${separator}`;
+
+    for (let i = 0, l = from.length; i < l; i++) {
+        text = text.replace(new RegExp(from.charAt(i), "g"), to.charAt(i));
+    }
+
+    text = text
+        .toString() // Cast to string
+        .trim() // Remove whitespace from both sides of a string
+        .replace(/^\s+|\s+$/g, "")
+        .replace(/\s+/g, separator) // Replace spaces with separator
+        .replace(/&/g, separator) // Replace & with separator
+        .replace(/[^\w\\-]+/g, "") // Remove all non-word chars
+        .replace(new RegExp("\\" + separator + "\\" + separator + "+", "g"),
+            separator); // Replace multiple separators with single one
+
+    return lowercase
+        ? text.toLowerCase() // Convert the string to lowercase letters
+        : text;
+}
+
+export function unslugify(slug?: string): string {
+    if (!slug) return "";
+    if (slug.includes("-") || slug.includes("_") || !slug.includes(" ")) {
+        const result = slug.replace(/[-_]/g, " ");
+        return result.replace(/\w\S*/g, function (txt) {
+            return txt.charAt(0).toUpperCase() + txt.substring(1);
+        }).trim();
+    } else {
+        return slug.trim();
+    }
+}
+
+export function prettifyIdentifier(input: string) {
+    if (!input) return "";
+
+    let text = input;
+
+    // 1. Handle camelCase and Acronyms
+    // Group 1 ($1 $2): Lowercase followed by Uppercase (e.g., imageURL -> image URL)
+    // Group 2 ($3 $4): Uppercase followed by Uppercase+lowercase (e.g., XMLParser -> XML Parser)
+    text = text.replace(/([a-z])([A-Z])|([A-Z])([A-Z][a-z])/g, "$1$3 $2$4");
+
+    // 2. Replace hyphens/underscores with spaces
+    text = text.replace(/[_-]+/g, " ");
+
+    // 3. Capitalize first letter of each word (Title Case)
+    const s = text
+        .trim()
+        .replace(/\b\w/g, (char) => char.toUpperCase());
+    console.log("Prettified identifier:", { input,s });
+    return s;
+}