@gtkx/utils 0.21.0 → 1.0.0-rc.2

package/dist/string/pascal-case.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Converts an underscore- or hyphen-delimited string to Pascal case.
+ *
+ * Splits only on `_` and `-` and capitalizes each segment's first character, so GObject acronyms
+ * are preserved (`pascalCase("GLArea")` stays `"GLArea"`).
+ *
+ * @param str - The string to convert.
+ * @returns The Pascal-cased string.
+ *
+ * @example
+ * pascalCase("icon_name"); // "IconName"
+ * pascalCase("scrolled-window"); // "ScrolledWindow"
+ */
+declare function pascalCase(str: string): string;
+export { pascalCase };
+//# sourceMappingURL=pascal-case.d.ts.map

package/dist/string/pascal-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pascal-case.d.ts","sourceRoot":"","sources":["../../src/string/pascal-case.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,iBAAS,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEvC;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/string/pascal-case.js

@@ -0,0 +1,20 @@
+import { upperFirst } from "./upper-first.js";
+import { mapWordSegments } from "./word-segments.js";
+/**
+ * Converts an underscore- or hyphen-delimited string to Pascal case.
+ *
+ * Splits only on `_` and `-` and capitalizes each segment's first character, so GObject acronyms
+ * are preserved (`pascalCase("GLArea")` stays `"GLArea"`).
+ *
+ * @param str - The string to convert.
+ * @returns The Pascal-cased string.
+ *
+ * @example
+ * pascalCase("icon_name"); // "IconName"
+ * pascalCase("scrolled-window"); // "ScrolledWindow"
+ */
+function pascalCase(str) {
+    return mapWordSegments(str, upperFirst);
+}
+export { pascalCase };
+//# sourceMappingURL=pascal-case.js.map

package/dist/string/pascal-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pascal-case.js","sourceRoot":"","sources":["../../src/string/pascal-case.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;GAYG;AACH,SAAS,UAAU,CAAC,GAAW;IAC3B,OAAO,eAAe,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;AAC5C,CAAC;AAED,OAAO,EAAE,UAAU,EAAE,CAAC","sourcesContent":["import { upperFirst } from \"./upper-first.js\";\nimport { mapWordSegments } from \"./word-segments.js\";\n\n/**\n * Converts an underscore- or hyphen-delimited string to Pascal case.\n *\n * Splits only on `_` and `-` and capitalizes each segment's first character, so GObject acronyms\n * are preserved (`pascalCase(\"GLArea\")` stays `\"GLArea\"`).\n *\n * @param str - The string to convert.\n * @returns The Pascal-cased string.\n *\n * @example\n * pascalCase(\"icon_name\"); // \"IconName\"\n * pascalCase(\"scrolled-window\"); // \"ScrolledWindow\"\n */\nfunction pascalCase(str: string): string {\n    return mapWordSegments(str, upperFirst);\n}\n\nexport { pascalCase };\n"]}

package/dist/string/upper-first.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts the first character of a string to upper case.
+ *
+ * @param str - The string to transform.
+ * @returns The string with its first character upper-cased.
+ *
+ * @example
+ * upperFirst("fred"); // "Fred"
+ * upperFirst("Fred"); // "Fred"
+ */
+declare function upperFirst(str: string): string;
+export { upperFirst };
+//# sourceMappingURL=upper-first.d.ts.map

package/dist/string/upper-first.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upper-first.d.ts","sourceRoot":"","sources":["../../src/string/upper-first.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,iBAAS,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEvC;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/string/upper-first.js

@@ -0,0 +1,15 @@
+/**
+ * Converts the first character of a string to upper case.
+ *
+ * @param str - The string to transform.
+ * @returns The string with its first character upper-cased.
+ *
+ * @example
+ * upperFirst("fred"); // "Fred"
+ * upperFirst("Fred"); // "Fred"
+ */
+function upperFirst(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+export { upperFirst };
+//# sourceMappingURL=upper-first.js.map

package/dist/string/upper-first.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upper-first.js","sourceRoot":"","sources":["../../src/string/upper-first.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,SAAS,UAAU,CAAC,GAAW;IAC3B,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACtD,CAAC;AAED,OAAO,EAAE,UAAU,EAAE,CAAC","sourcesContent":["/**\n * Converts the first character of a string to upper case.\n *\n * @param str - The string to transform.\n * @returns The string with its first character upper-cased.\n *\n * @example\n * upperFirst(\"fred\"); // \"Fred\"\n * upperFirst(\"Fred\"); // \"Fred\"\n */\nfunction upperFirst(str: string): string {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\nexport { upperFirst };\n"]}

package/dist/string/word-segments.d.ts

@@ -0,0 +1,3 @@
+declare function mapWordSegments(input: string, mapSegment: (part: string, index: number) => string): string;
+export { mapWordSegments };
+//# sourceMappingURL=word-segments.d.ts.map

package/dist/string/word-segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"word-segments.d.ts","sourceRoot":"","sources":["../../src/string/word-segments.ts"],"names":[],"mappings":"AAIA,iBAAS,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,CAQnG;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/string/word-segments.js

@@ -0,0 +1,12 @@
+function splitWords(input) {
+    return input.split(/[_-]/g).filter((part) => part.length > 0);
+}
+function mapWordSegments(input, mapSegment) {
+    const parts = splitWords(input);
+    if (parts.length === 0) {
+        return input;
+    }
+    return parts.map((part, index) => mapSegment(part, index)).join("");
+}
+export { mapWordSegments };
+//# sourceMappingURL=word-segments.js.map

package/dist/string/word-segments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"word-segments.js","sourceRoot":"","sources":["../../src/string/word-segments.ts"],"names":[],"mappings":"AAAA,SAAS,UAAU,CAAC,KAAa;IAC7B,OAAO,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AAClE,CAAC;AAED,SAAS,eAAe,CAAC,KAAa,EAAE,UAAmD;IACvF,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;IAEhC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACrB,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AACxE,CAAC;AAED,OAAO,EAAE,eAAe,EAAE,CAAC","sourcesContent":["function splitWords(input: string): string[] {\n    return input.split(/[_-]/g).filter((part) => part.length > 0);\n}\n\nfunction mapWordSegments(input: string, mapSegment: (part: string, index: number) => string): string {\n    const parts = splitWords(input);\n\n    if (parts.length === 0) {\n        return input;\n    }\n\n    return parts.map((part, index) => mapSegment(part, index)).join(\"\");\n}\n\nexport { mapWordSegments };\n"]}

package/dist/util/index.d.ts

@@ -0,0 +1,2 @@
+export { packageVersion } from "./package-version.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/util/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/util/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/util/index.js

@@ -0,0 +1,2 @@
+export { packageVersion } from "./package-version.js";
+//# sourceMappingURL=index.js.map

package/dist/util/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/util/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC","sourcesContent":["export { packageVersion } from \"./package-version.js\";\n"]}

package/dist/util/package-version.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Reads the `version` field from the `package.json` next to the calling module.
+ *
+ * @param importMetaUrl - The caller's `import.meta.url`, used to resolve the sibling `package.json`.
+ * @returns The package's version string.
+ *
+ * @example
+ * packageVersion(import.meta.url); // "1.2.3"
+ */
+declare function packageVersion(importMetaUrl: string): string;
+export { packageVersion };
+//# sourceMappingURL=package-version.d.ts.map

package/dist/util/package-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-version.d.ts","sourceRoot":"","sources":["../../src/util/package-version.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,iBAAS,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/util/package-version.js

@@ -0,0 +1,15 @@
+import { createRequire } from "node:module";
+/**
+ * Reads the `version` field from the `package.json` next to the calling module.
+ *
+ * @param importMetaUrl - The caller's `import.meta.url`, used to resolve the sibling `package.json`.
+ * @returns The package's version string.
+ *
+ * @example
+ * packageVersion(import.meta.url); // "1.2.3"
+ */
+function packageVersion(importMetaUrl) {
+    return createRequire(importMetaUrl)("../package.json").version;
+}
+export { packageVersion };
+//# sourceMappingURL=package-version.js.map

package/dist/util/package-version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-version.js","sourceRoot":"","sources":["../../src/util/package-version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;GAQG;AACH,SAAS,cAAc,CAAC,aAAqB;IACzC,OAAQ,aAAa,CAAC,aAAa,CAAC,CAAC,iBAAiB,CAAyB,CAAC,OAAO,CAAC;AAC5F,CAAC;AAED,OAAO,EAAE,cAAc,EAAE,CAAC","sourcesContent":["import { createRequire } from \"node:module\";\n\n/**\n * Reads the `version` field from the `package.json` next to the calling module.\n *\n * @param importMetaUrl - The caller's `import.meta.url`, used to resolve the sibling `package.json`.\n * @returns The package's version string.\n *\n * @example\n * packageVersion(import.meta.url); // \"1.2.3\"\n */\nfunction packageVersion(importMetaUrl: string): string {\n    return (createRequire(importMetaUrl)(\"../package.json\") as { version: string }).version;\n}\n\nexport { packageVersion };\n"]}

package/package.json

@@ -1,14 +1,22 @@
 {
   "name": "@gtkx/utils",
-  "version": "0.21.0",
-  "description": "Cross-package utilities shared by GTKX runtime entry points",
+  "version": "1.0.0-rc.2",
+  "description": "Cross-package utilities shared by the GTKX packages and toolchain: logging, error formatting, string and class helpers",
+  "keywords": [
+    "gtkx",
+    "gtk",
+    "gtk4",
+    "utils",
+    "linux",
+    "desktop"
+  ],
   "homepage": "https://gtkx.dev",
   "bugs": {
     "url": "https://github.com/gtkx-org/gtkx/issues"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/gtkx-org/gtkx.git",
+    "url": "git+https://github.com/gtkx-org/gtkx.git",
     "directory": "packages/utils"
   },
   "license": "MPL-2.0",
@@ -17,7 +25,6 @@
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "source": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     }
@@ -27,9 +34,13 @@
     "dist",
     "src"
   ],
+  "dependencies": {
+    "picocolors": "^1.1.1"
+  },
+  "engines": {
+    "node": ">=24"
+  },
   "scripts": {
-    "build": "tsc -b",
-    "test": "vitest run",
-    "typecheck": "tsc -b --emitDeclarationOnly"
+    "release": "tsx ../../scripts/release-package.ts"
   }
 }

package/src/array/index-before-or-end.ts

@@ -0,0 +1,27 @@
+/**
+ * Finds the index of the first item matching `before`, or `list.length` when `before` is `null` or
+ * nothing matches. Use it to resolve where a new item should be inserted so it lands before the
+ * referenced one, defaulting to the end.
+ *
+ * @template T - The list item type.
+ * @template B - The reference value type.
+ * @param list - The list to search.
+ * @param before - The item to insert before, or `null` to target the end.
+ * @param isMatch - Called with each item and the non-null `before`; return `true` on a match.
+ * @returns The matched index, or `list.length`.
+ */
+const indexBeforeOrEnd = <T, B>(
+    list: T[],
+    before: B | null,
+    isMatch: (item: T, before: B) => boolean,
+): number => {
+    if (before === null) {
+        return list.length;
+    }
+
+    const index = list.findIndex((item) => isMatch(item, before));
+
+    return index === -1 ? list.length : index;
+};
+
+export { indexBeforeOrEnd };

package/src/array/index.ts

@@ -0,0 +1,5 @@
+export { indexBeforeOrEnd } from "./index-before-or-end.js";
+export { remove } from "./remove.js";
+export { sortStringsBy } from "./sort-strings-by.js";
+export { sortStrings } from "./sort-strings.js";
+export { uniqBy } from "./uniq-by.js";

package/src/array/remove.ts

@@ -0,0 +1,20 @@
+/**
+ * Removes the first strictly-equal (`===`) occurrence of `value` from `arr` in place.
+ *
+ * @template T - The type of the array elements.
+ * @param arr - The array to mutate.
+ * @param value - The value to remove.
+ *
+ * @example
+ * const items = ["a", "b", "c"];
+ * remove(items, "b"); // items is now ["a", "c"]
+ */
+function remove<T>(arr: T[], value: T): void {
+    const index = arr.indexOf(value);
+
+    if (index !== -1) {
+        arr.splice(index, 1);
+    }
+}
+
+export { remove };

package/src/array/sort-strings-by.ts

@@ -0,0 +1,17 @@
+/**
+ * Returns the items sorted by a string key using locale-aware comparison.
+ *
+ * @template T - The type of items being sorted.
+ * @param items - The items to sort.
+ * @param key - Maps an item to the string its order is decided by.
+ * @returns A new array of the items in ascending locale order of their keys.
+ *
+ * @example
+ * sortStringsBy([{ name: "b" }, { name: "a" }], (item) => item.name);
+ * // [{ name: "a" }, { name: "b" }]
+ */
+function sortStringsBy<T>(items: Iterable<T>, key: (item: T) => string): T[] {
+    return [...items].toSorted((a, b) => key(a).localeCompare(key(b)));
+}
+
+export { sortStringsBy };

package/src/array/sort-strings.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns the values sorted as strings using locale-aware comparison.
+ *
+ * @param values - The strings to sort.
+ * @returns A new array of the values in ascending locale order.
+ *
+ * @example
+ * sortStrings(["b", "a", "c"]); // ["a", "b", "c"]
+ */
+function sortStrings(values: Iterable<string>): string[] {
+    return [...values].toSorted((a, b) => a.localeCompare(b));
+}
+
+export { sortStrings };

package/src/array/uniq-by.ts

@@ -0,0 +1,33 @@
+/**
+ * Returns a new array of the unique elements of `arr`, keyed by the value the `mapper` returns.
+ *
+ * When two elements map to the same key the first occurrence is kept and later ones discarded,
+ * preserving first-seen order.
+ *
+ * @template T - The type of elements in the array.
+ * @param arr - The array to deduplicate.
+ * @param mapper - Maps an element to the key its uniqueness is decided by.
+ * @returns A new array containing only the first element seen for each distinct key.
+ *
+ * @example
+ * uniqBy([2.1, 1.2, 2.3], Math.floor); // [2.1, 1.2]
+ * uniqBy([{ id: "a" }, { id: "a" }, { id: "b" }], (item) => item.id); // [{ id: "a" }, { id: "b" }]
+ */
+function uniqBy<T>(arr: T[], mapper: (item: T, index: number, array: T[]) => unknown): T[] {
+    const seen: Map<unknown, T> = new Map();
+    let index = 0;
+
+    for (const item of arr) {
+        const key = mapper(item, index, arr);
+
+        if (!seen.has(key)) {
+            seen.set(key, item);
+        }
+
+        index++;
+    }
+
+    return seen.values().toArray();
+}
+
+export { uniqBy };

package/src/class/any-class.ts

@@ -0,0 +1,10 @@
+/**
+ * A constructor value of any (possibly abstract) class producing instances of `T`.
+ */
+type AnyClass<T extends object = object> = (abstract new (
+    ...args: never[]
+) => T) & {
+    prototype: T;
+};
+
+export { type AnyClass };

package/src/class/get-parent-class.ts

@@ -0,0 +1,15 @@
+import type { AnyClass } from "./any-class.js";
+
+/**
+ * Returns the direct superclass of `cls`, or `null` when it has no class ancestor.
+ *
+ * @param cls - The class whose prototype parent to inspect.
+ * @returns The parent class, or `null` when there is none.
+ */
+function getParentClass(cls: AnyClass): AnyClass | null {
+    const parent: unknown = Object.getPrototypeOf(cls);
+
+    return typeof parent === "function" && parent !== Function.prototype ? (parent as AnyClass) : null;
+}
+
+export { getParentClass };

package/src/class/index.ts

@@ -0,0 +1,3 @@
+export type { AnyClass } from "./any-class.js";
+export { getParentClass } from "./get-parent-class.js";
+export { walkClassChain } from "./walk-class-chain.js";

package/src/class/walk-class-chain.ts

@@ -0,0 +1,29 @@
+import type { AnyClass } from "./any-class.js";
+import { getParentClass } from "./get-parent-class.js";
+
+/**
+ * Walks the class chain from `cls` up through its ancestors, calling `visit` on each and returning
+ * the first result that is not `undefined`.
+ *
+ * @template T - The type produced by the visitor.
+ * @param cls - The class to start from, or `null` to visit nothing.
+ * @param visit - Called with each class in the chain; a defined return value stops the walk.
+ * @returns The first defined result from `visit`, or `undefined` when none was produced.
+ */
+function walkClassChain<T>(cls: AnyClass | null, visit: (ancestor: AnyClass) => T | undefined): T | undefined {
+    let current = cls;
+
+    while (current !== null) {
+        const result = visit(current);
+
+        if (result !== undefined) {
+            return result;
+        }
+
+        current = getParentClass(current);
+    }
+
+    return undefined;
+}
+
+export { walkClassChain };

package/src/error/error-like.ts

@@ -0,0 +1,19 @@
+import { isRecord } from "../predicate/is-record.js";
+
+function isErrorLike(value: unknown): value is { message: string } {
+    return isRecord(value) && "message" in value && typeof value.message === "string";
+}
+
+function readStream(value: unknown): string {
+    if (typeof value === "string") {
+        return value;
+    }
+
+    if (value instanceof Uint8Array || Buffer.isBuffer(value)) {
+        return value.toString();
+    }
+
+    return "";
+}
+
+export { isErrorLike, readStream };

package/src/error/error-message.ts

@@ -0,0 +1,17 @@
+import { isErrorLike } from "./error-like.js";
+
+/**
+ * Extracts a human-readable message from an unknown thrown value, falling back to its string form.
+ *
+ * @param error - The caught value to describe.
+ * @returns The value's message when it has one, otherwise its string form.
+ *
+ * @example
+ * errorMessage(new Error("boom")); // "boom"
+ * errorMessage(42); // "42"
+ */
+function errorMessage(error: unknown): string {
+    return Error.isError(error) || isErrorLike(error) ? error.message : String(error);
+}
+
+export { errorMessage };

package/src/error/format-child-process-error.ts

@@ -0,0 +1,24 @@
+import { isRecord } from "../predicate/is-record.js";
+import { readStream } from "./error-like.js";
+
+/**
+ * Combines the `stderr` and `stdout` of a failed child-process error into a single trimmed string.
+ *
+ * @param error - The child-process error to read output from.
+ * @returns The joined output, or `undefined` when neither stream carried any text.
+ *
+ * @example
+ * formatChildProcessError({ stderr: "boom" }); // "boom"
+ */
+function formatChildProcessError(error: unknown): string | undefined {
+    if (!isRecord(error)) {
+        return undefined;
+    }
+
+    const { stderr, stdout } = error;
+    const details = [readStream(stderr), readStream(stdout)].filter(Boolean).join("\n").trim();
+
+    return details.length > 0 ? details : undefined;
+}
+
+export { formatChildProcessError };

package/src/error/index.ts

@@ -0,0 +1,3 @@
+export { errorMessage } from "./error-message.js";
+export { formatChildProcessError } from "./format-child-process-error.js";
+export { normalizeError } from "./normalize-error.js";

package/src/error/normalize-error.ts

@@ -0,0 +1,22 @@
+import { isErrorLike } from "./error-like.js";
+import { errorMessage } from "./error-message.js";
+
+/**
+ * Coerces an unknown thrown value into an `Error`, reusing it when it already is one and otherwise
+ * wrapping its message while copying any error-like own properties.
+ *
+ * @param error - The caught value to normalize.
+ * @returns The value itself when it is an `Error`, otherwise a new `Error` carrying its message.
+ *
+ * @example
+ * normalizeError("boom"); // Error: boom
+ */
+function normalizeError(error: unknown): Error {
+    if (Error.isError(error)) {
+        return error;
+    }
+
+    return Object.assign(new Error(errorMessage(error)), isErrorLike(error) ? error : {});
+}
+
+export { normalizeError };

package/src/function/call-method.ts

@@ -0,0 +1,22 @@
+/**
+ * Calls the named method on `target` with the given arguments, returning `undefined` when the
+ * property is missing or not callable.
+ *
+ * @param target - The object to read the method from and bind as `this`.
+ * @param method - The name of the method to look up.
+ * @param args - The arguments passed to the method.
+ * @returns The method's return value, or `undefined` when it is not a function.
+ *
+ * @example
+ * callMethod(console, "log", ["hi"]); // logs "hi"; returns undefined
+ */
+const isCallable = (value: unknown): value is (this: object, ...args: unknown[]) => unknown =>
+    typeof value === "function";
+
+function callMethod(target: object, method: string, args: unknown[]): unknown {
+    const fn: unknown = Reflect.get(target, method);
+
+    return isCallable(fn) ? Reflect.apply(fn, target, args) : undefined;
+}
+
+export { callMethod };

package/src/function/index.ts

@@ -0,0 +1 @@
+export { callMethod } from "./call-method.js";

package/src/index.ts

@@ -1,10 +1,13 @@
-export type { AnyClass } from "./class.js";
-export { isShallowArrayEqual, isShallowEqual, omit, reverseNumericEnum } from "./collection.js";
-export { errorMessage } from "./error.js";
-export {
-    exitCodeForSignal,
-    type GracefulShutdownHandle,
-    installGracefulShutdown,
-} from "./graceful-shutdown.js";
-export { quote, toIdentifier } from "./source.js";
-export { toCamelCase, toKebabCase, toPascalCase, toUpperFirst } from "./string.js";
+export * from "./array/index.js";
+export * from "./class/index.js";
+export * from "./error/index.js";
+export * from "./function/index.js";
+export * from "./log/index.js";
+export * from "./map/index.js";
+export * from "./object/index.js";
+export * from "./predicate/index.js";
+export * from "./process/index.js";
+export * from "./set/index.js";
+export * from "./source/index.js";
+export * from "./string/index.js";
+export * from "./util/index.js";

package/src/log/create-logger.ts

@@ -0,0 +1,18 @@
+import { Logger, type LoggerOptions } from "./logger.js";
+
+/**
+ * Creates a {@link Logger} scoped to the given namespace.
+ *
+ * @param namespace - Namespace added to the log prefix and matched against debug configuration.
+ * @param options - Further logger options, excluding the namespace.
+ * @returns A new namespaced logger.
+ *
+ * @example
+ * const log = createLogger("react");
+ * log.info("mounted");
+ */
+function createLogger(namespace: string, options: Omit<LoggerOptions, "namespace"> = {}): Logger {
+    return new Logger({ ...options, namespace });
+}
+
+export { createLogger };

package/src/log/default-logger.ts

@@ -0,0 +1,49 @@
+import { Logger } from "./logger.js";
+
+/**
+ * The default namespace-less {@link Logger} backing the module-level {@link info}, {@link warn},
+ * {@link error}, and {@link debug} functions.
+ */
+const logger: Logger = new Logger();
+
+/**
+ * Writes an informational line through the shared {@link logger}.
+ *
+ * @param message - The message text.
+ * @param rest - Extra values appended after the message, formatted for display.
+ */
+function info(message: string, ...rest: unknown[]): void {
+    logger.info(message, ...rest);
+}
+
+/**
+ * Writes a warning line through the shared {@link logger}.
+ *
+ * @param message - The message text.
+ * @param rest - Extra values appended after the message, formatted for display.
+ */
+function warn(message: string, ...rest: unknown[]): void {
+    logger.warn(message, ...rest);
+}
+
+/**
+ * Writes an error line through the shared {@link logger}.
+ *
+ * @param message - The message text.
+ * @param rest - Extra values appended after the message, formatted for display.
+ */
+function error(message: string, ...rest: unknown[]): void {
+    logger.error(message, ...rest);
+}
+
+/**
+ * Writes a debug line through the shared {@link logger} when debug output is enabled.
+ *
+ * @param message - The message text.
+ * @param rest - Extra values appended after the message, formatted for display.
+ */
+function debug(message: string, ...rest: unknown[]): void {
+    logger.debug(message, ...rest);
+}
+
+export { logger, info, warn, error, debug };

package/src/log/index.ts

@@ -0,0 +1,3 @@
+export { createLogger } from "./create-logger.js";
+export { debug, error, info, logger, warn } from "./default-logger.js";
+export { Logger, type LoggerOptions, type OutputStream } from "./logger.js";