@gtkx/utils 1.0.0-rc.3 → 1.0.0

package/src/predicate/is-plain-object.ts

@@ -1,17 +1,3 @@
-/**
- * Checks whether a value is a plain object, i.e. one whose prototype is `Object.prototype` or `null`.
- *
- * Class instances, arrays, and other exotic objects return `false`.
- *
- * @param value - The value to test.
- * @returns `true` when `value` is a plain object.
- *
- * @example
- * isPlainObject({ a: 1 }); // true
- * isPlainObject(Object.create(null)); // true
- * isPlainObject([1, 2]); // false
- * isPlainObject(new Date()); // false
- */
 function isPlainObject(value: unknown): value is Record<string, unknown> {
     if (typeof value !== "object" || value === null) {
         return false;

package/src/predicate/is-record.ts

@@ -1,14 +1,3 @@
-/**
- * Checks whether a value is a non-null object (including arrays and class instances, excluding `null`).
- *
- * @param value - The value to test.
- * @returns `true` when `value` is a non-null object.
- *
- * @example
- * isRecord({ a: 1 }); // true
- * isRecord(null); // false
- * isRecord("x"); // false
- */
 function isRecord(value: unknown): value is Record<string, unknown> {
     return typeof value === "object" && value !== null;
 }

package/src/predicate/is-same-array-by.ts

@@ -1,15 +1,3 @@
-/**
- * Checks whether two arrays have the same length and elements the comparator treats as equal, in order.
- *
- * @template T - The type of the array elements.
- * @param a - The first array.
- * @param b - The second array.
- * @param isEqual - Compares elements at the same index; return `true` when they are equal.
- * @returns `true` when the arrays are element-wise equal under `isEqual`.
- *
- * @example
- * isSameArrayBy([{ id: 1 }], [{ id: 1 }], (x, y) => x.id === y.id); // true
- */
 function isSameArrayBy<T>(a: T[], b: T[], isEqual: (x: T, y: T) => boolean): boolean {
     if (a.length !== b.length) {
         return false;

package/src/predicate/is-same-array.ts

@@ -1,17 +1,5 @@
-import { isSameArrayBy } from "./is-same-array-by.js";
+import { isSameArrayBy } from "./is-same-array-by.ts";
 
-/**
- * Checks whether two arrays have the same length and strictly equal (`===`) elements in order.
- *
- * @template T - The type of the array elements.
- * @param a - The first array.
- * @param b - The second array.
- * @returns `true` when the arrays are element-wise strictly equal.
- *
- * @example
- * isSameArray([1, 2], [1, 2]); // true
- * isSameArray([1, 2], [2, 1]); // false
- */
 function isSameArray<T>(a: T[], b: T[]): boolean {
     return isSameArrayBy(a, b, (x, y) => x === y);
 }

package/src/predicate/is-shallow-equal.ts

@@ -1,20 +1,6 @@
-import { areObjectKeysEqual } from "./are-object-keys-equal.js";
-import { isPlainObject } from "./is-plain-object.js";
+import { areObjectKeysEqual } from "./are-object-keys-equal.ts";
+import { isPlainObject } from "./is-plain-object.ts";
 
-/**
- * Checks whether two values are shallowly equal: identical, or plain objects with the same own
- * enumerable keys and strictly equal (`===`) values. Values that are not both plain objects are
- * equal only when identical.
- *
- * @param a - The first value.
- * @param b - The second value.
- * @returns `true` when the values are shallowly equal.
- *
- * @example
- * isShallowEqual({ a: 1 }, { a: 1 }); // true
- * isShallowEqual({ a: 1 }, { a: 2 }); // false
- * isShallowEqual(3, 3); // true
- */
 const isStrictEqual = (a: unknown, b: unknown): boolean => a === b;
 
 function isShallowEqual(a: unknown, b: unknown): boolean {

package/src/process/exit-code-for-signal.ts

@@ -1,14 +1,3 @@
-/**
- * Maps a terminating signal to its conventional process exit code (130 for `SIGINT`, 143 otherwise),
- * or 0 when no signal is given.
- *
- * @param signal - The signal that triggered termination, or `null`.
- * @returns The conventional exit code for the signal.
- *
- * @example
- * exitCodeForSignal("SIGINT"); // 130
- * exitCodeForSignal(null); // 0
- */
 function exitCodeForSignal(signal: NodeJS.Signals | null): number {
     if (!signal) {
         return 0;

package/src/process/index.ts

@@ -1,3 +1,4 @@
-export { exitCodeForSignal } from "./exit-code-for-signal.js";
-export { installGracefulShutdown } from "./install-graceful-shutdown.js";
-export { resolveExecutable } from "./resolve-executable.js";
+export { exitCodeForSignal } from "./exit-code-for-signal.ts";
+export { installGracefulShutdown } from "./install-graceful-shutdown.ts";
+export { resolveExecutable, tryResolveExecutable } from "./resolve-executable.ts";
+export { spawnWithParentDeathSignal } from "./spawn-with-parent-death-signal.ts";

package/src/process/install-graceful-shutdown.ts

@@ -1,5 +1,5 @@
-import { error } from "../log/default-logger.js";
-import { exitCodeForSignal } from "./exit-code-for-signal.js";
+import { error } from "../log/default-logger.ts";
+import { exitCodeForSignal } from "./exit-code-for-signal.ts";
 
 type GracefulShutdownOptions = {
     onSignal: (signal: NodeJS.Signals) => void | Promise<void>;
@@ -14,8 +14,8 @@ type ShutdownState = {
     forceKillMs: number;
     coalesceWindowMs: number;
     firstSignal: NodeJS.Signals | null;
-    exited: boolean;
-    coalescing: boolean;
+    hasExited: boolean;
+    isCoalescing: boolean;
     forceTimer: NodeJS.Timeout | null;
     coalesceTimer: NodeJS.Timeout | null;
 };
@@ -37,11 +37,11 @@ const clearTimers = (state: ShutdownState): void => {
 };
 
 const finish = (state: ShutdownState, signal: NodeJS.Signals, isGraceful: boolean): void => {
-    if (state.exited) {
+    if (state.hasExited) {
         return;
     }
 
-    state.exited = true;
+    state.hasExited = true;
     clearTimers(state);
     const { exitCode } = state.options;
     const defaultCode = isGraceful ? 0 : exitCodeForSignal(signal);
@@ -62,10 +62,10 @@ const beginShutdown = (state: ShutdownState, signal: NodeJS.Signals): void => {
     state.firstSignal = signal;
 
     if (state.coalesceWindowMs > 0) {
-        state.coalescing = true;
+        state.isCoalescing = true;
 
         state.coalesceTimer = setTimeout(() => {
-            state.coalescing = false;
+            state.isCoalescing = false;
         }, state.coalesceWindowMs);
 
         state.coalesceTimer.unref();
@@ -90,7 +90,7 @@ const handle = (state: ShutdownState, signal: NodeJS.Signals): void => {
         return;
     }
 
-    if (state.coalescing) {
+    if (state.isCoalescing) {
         return;
     }
 
@@ -98,20 +98,14 @@ const handle = (state: ShutdownState, signal: NodeJS.Signals): void => {
     finish(state, signal, false);
 };
 
-/**
- * Registers handlers for `SIGINT`, `SIGTERM`, and `SIGHUP` that run the given cleanup callback once
- * and then exit, forcing exit if a repeated signal arrives or the cleanup exceeds its timeout.
- *
- * @param options - The shutdown callbacks and timing configuration.
- */
 function installGracefulShutdown(options: GracefulShutdownOptions): void {
     const state: ShutdownState = {
         options,
         forceKillMs: options.forceKillAfterMs ?? DEFAULT_FORCE_KILL_TIMEOUT_MS,
         coalesceWindowMs: options.coalesceWindowMs ?? DEFAULT_COALESCE_WINDOW_MS,
         firstSignal: null,
-        exited: false,
-        coalescing: false,
+        hasExited: false,
+        isCoalescing: false,
         forceTimer: null,
         coalesceTimer: null,
     };
@@ -123,4 +117,4 @@ function installGracefulShutdown(options: GracefulShutdownOptions): void {
     }
 }
 
-export { installGracefulShutdown, type GracefulShutdownOptions };
+export { installGracefulShutdown };

package/src/process/kill-marked-processes.ts

@@ -0,0 +1,44 @@
+import { readdirSync, readFileSync } from "node:fs";
+
+const PROCESS_MARKER = "GTKX_PROCESS_GUARD";
+const MAX_KILL_PASSES = 8;
+
+const isMarked = (pid: number, prefix: string): boolean => {
+    try {
+        return readFileSync(`/proc/${String(pid)}/environ`, "utf8")
+            .split("\0")
+            .some((assignment) => assignment.startsWith(prefix));
+    } catch {
+        return false;
+    }
+};
+
+const markedPids = (prefix: string): number[] =>
+    readdirSync("/proc")
+        .map(Number)
+        .filter((pid) => Number.isSafeInteger(pid) && pid > 1 && pid !== process.pid)
+        .filter((pid) => isMarked(pid, prefix));
+
+const killPid = (pid: number): void => {
+    try {
+        process.kill(pid, "SIGKILL");
+    } catch {
+        return;
+    }
+};
+
+function killMarkedProcesses(prefix: string): void {
+    for (let pass = 0; pass < MAX_KILL_PASSES; pass += 1) {
+        const pids = markedPids(prefix);
+
+        if (pids.length === 0) {
+            return;
+        }
+
+        for (const pid of pids) {
+            killPid(pid);
+        }
+    }
+}
+
+export { PROCESS_MARKER, killMarkedProcesses };

package/src/process/process-guard.ts

@@ -0,0 +1,20 @@
+import { killMarkedProcesses } from "./kill-marked-processes.ts";
+
+const GUARD_PREFIX = process.argv[2] ?? "";
+const WATCHED_SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"] as const satisfies NodeJS.Signals[];
+
+const sweep = (): void => {
+    if (GUARD_PREFIX.length > 0) {
+        killMarkedProcesses(GUARD_PREFIX);
+    }
+
+    process.exit(0);
+};
+
+process.stdin.resume();
+process.stdin.on("end", sweep);
+process.stdin.on("error", sweep);
+
+for (const signal of WATCHED_SIGNALS) {
+    process.on(signal, sweep);
+}

package/src/process/resolve-executable.ts

@@ -25,18 +25,7 @@ const findOnPath = (command: string): string | undefined => {
     return undefined;
 };
 
-/**
- * Resolves an executable to an absolute path, searching `PATH` only for a bare command name, so
- * spawning it never re-runs a lookup against a `PATH` that may have changed.
- *
- * @param command - An executable name, or a path to one.
- * @returns The absolute path of the executable.
- * @throws When a bare command name is not found on `PATH`.
- *
- * @example
- * resolveExecutable("weston"); // "/usr/bin/weston"
- */
-function resolveExecutable(command: string): string {
+function tryResolveExecutable(command: string): string | undefined {
     if (isAbsolute(command)) {
         return command;
     }
@@ -45,7 +34,11 @@ function resolveExecutable(command: string): string {
         return resolve(command);
     }
 
-    const found = findOnPath(command);
+    return findOnPath(command);
+}
+
+function resolveExecutable(command: string): string {
+    const found = tryResolveExecutable(command);
 
     if (found === undefined) {
         throw new Error(`Cannot find the "${command}" executable on PATH`);
@@ -54,4 +47,4 @@ function resolveExecutable(command: string): string {
     return found;
 }
 
-export { resolveExecutable };
+export { resolveExecutable, tryResolveExecutable };

package/src/process/spawn-with-parent-death-signal.ts

@@ -0,0 +1,74 @@
+import { type ChildProcess, spawn, type StdioOptions } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { Socket } from "node:net";
+import { dirname, extname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { killMarkedProcesses, PROCESS_MARKER } from "./kill-marked-processes.ts";
+import { resolveExecutable } from "./resolve-executable.ts";
+
+type ParentDeathSpawnOptions = {
+    stdio?: StdioOptions;
+    env?: NodeJS.ProcessEnv;
+};
+
+type GuardState = {
+    child?: ChildProcess | undefined;
+};
+
+const MODULE_PATH = fileURLToPath(import.meta.url);
+const GUARD_PATH = join(dirname(MODULE_PATH), `process-guard${extname(MODULE_PATH)}`);
+const RUN_ID = randomBytes(8).toString("hex");
+const RUN_PREFIX = `${PROCESS_MARKER}=${RUN_ID}/`;
+const guard: GuardState = {};
+
+const releaseGuard = (child: ChildProcess): void => {
+    child.unref();
+    const { stdin } = child;
+
+    if (stdin instanceof Socket) {
+        stdin.unref();
+    }
+};
+
+const startGuard = (): void => {
+    if (guard.child) {
+        return;
+    }
+
+    const child = spawn(process.execPath, [GUARD_PATH, RUN_PREFIX], {
+        detached: true,
+        stdio: ["pipe", "ignore", "ignore"],
+    });
+
+    child.on("error", () => {
+        guard.child = undefined;
+    });
+
+    guard.child = child;
+    releaseGuard(child);
+};
+
+function spawnWithParentDeathSignal(
+    command: string,
+    args: string[],
+    options: ParentDeathSpawnOptions = {},
+): ChildProcess {
+    const executable = resolveExecutable(command);
+    const setpriv = resolveExecutable("setpriv");
+    const jobValue = `${RUN_ID}/${randomBytes(4).toString("hex")}`;
+    startGuard();
+
+    const child = spawn(setpriv, ["--pdeathsig", "SIGKILL", executable, ...args], {
+        detached: true,
+        stdio: options.stdio ?? "ignore",
+        env: { ...(options.env ?? process.env), [PROCESS_MARKER]: jobValue },
+    });
+
+    child.on("exit", () => {
+        killMarkedProcesses(`${PROCESS_MARKER}=${jobValue}`);
+    });
+
+    return child;
+}
+
+export { spawnWithParentDeathSignal };

package/src/set/drain.ts

@@ -1,11 +1,3 @@
-/**
- * Iterates every item currently in `set`, then clears it. Use it to drain a set of pending work
- * accumulated since the last drain.
- *
- * @template T - The set item type.
- * @param set - The set to drain and clear.
- * @param visit - Called with each item before the set is cleared.
- */
 const drain = <T>(set: Set<T>, visit: (item: T) => void): void => {
     for (const item of set) {
         visit(item);

package/src/set/index.ts

@@ -1 +1 @@
-export { drain } from "./drain.js";
+export { drain } from "./drain.ts";

package/src/source/index.ts

@@ -1,3 +1,3 @@
-export { sanitizeIdentifier } from "./sanitize-identifier.js";
-export { sourceStringLiteral } from "./source-string-literal.js";
-export { toCamelIdentifier } from "./to-camel-identifier.js";
+export { sanitizeIdentifier } from "./sanitize-identifier.ts";
+export { sourceStringLiteral } from "./source-string-literal.ts";
+export { toCamelIdentifier } from "./to-camel-identifier.ts";

package/src/source/sanitize-identifier.ts

@@ -48,17 +48,6 @@ const RESERVED: Set<string> = new Set([
     "yield",
 ]);
 
-/**
- * Returns the name unchanged, or with a trailing underscore when it collides with a reserved word,
- * so it is safe to emit as a JavaScript identifier.
- *
- * @param name - The candidate identifier.
- * @returns The name, suffixed with `_` when it is a reserved word.
- *
- * @example
- * sanitizeIdentifier("iconName"); // "iconName"
- * sanitizeIdentifier("class"); // "class_"
- */
 function sanitizeIdentifier(name: string): string {
     return RESERVED.has(name) ? `${name}_` : name;
 }

package/src/source/source-string-literal.ts

@@ -10,16 +10,6 @@ const SOURCE_ESCAPES: Record<string, string> = {
 
 const UNSAFE_SOURCE_CHARS = new RegExp(`[${Object.keys(SOURCE_ESCAPES).join("")}]`, "g");
 
-/**
- * Encodes a string as a JavaScript string literal, additionally escaping characters that are unsafe
- * to embed in generated source (angle brackets and the line and paragraph separators).
- *
- * @param value - The string to encode.
- * @returns The quoted, source-safe string literal.
- *
- * @example
- * sourceStringLiteral("hello"); // '"hello"'
- */
 function sourceStringLiteral(value: string): string {
     return JSON.stringify(value).replaceAll(UNSAFE_SOURCE_CHARS, (char) => SOURCE_ESCAPES[char] ?? char);
 }

package/src/source/to-camel-identifier.ts

@@ -1,16 +1,6 @@
-import { camelCase } from "../string/camel-case.js";
-import { sanitizeIdentifier } from "./sanitize-identifier.js";
+import { camelCase } from "../string/camel-case.ts";
+import { sanitizeIdentifier } from "./sanitize-identifier.ts";
 
-/**
- * Converts a name to camel case and sanitizes it into a valid JavaScript identifier.
- *
- * @param name - The name to convert.
- * @returns The camel-cased, reserved-word-safe identifier.
- *
- * @example
- * toCamelIdentifier("icon_name"); // "iconName"
- * toCamelIdentifier("class"); // "class_"
- */
 function toCamelIdentifier(name: string): string {
     return sanitizeIdentifier(camelCase(name));
 }

package/src/string/camel-case.ts

@@ -1,20 +1,6 @@
-import { upperFirst } from "./upper-first.js";
-import { mapWordSegments } from "./word-segments.js";
+import { upperFirst } from "./upper-first.ts";
+import { mapWordSegments } from "./word-segments.ts";
 
-/**
- * Converts an underscore- or hyphen-delimited string to camel case.
- *
- * Unlike a general-purpose converter, this splits only on `_` and `-` and keeps the first segment
- * verbatim, so GObject acronyms are preserved (`camelCase("GLArea")` stays `"GLArea"`).
- *
- * @param str - The string to convert.
- * @returns The camel-cased string.
- *
- * @example
- * camelCase("icon_name"); // "iconName"
- * camelCase("start-widget"); // "startWidget"
- * camelCase("Box"); // "Box"
- */
 function camelCase(str: string): string {
     return mapWordSegments(str, (part, index) => (index === 0 ? part : upperFirst(part)));
 }

package/src/string/index.ts

@@ -1,5 +1,5 @@
-export { camelCase } from "./camel-case.js";
-export { kebabCase } from "./kebab-case.js";
-export { lowerFirst } from "./lower-first.js";
-export { pascalCase } from "./pascal-case.js";
-export { upperFirst } from "./upper-first.js";
+export { camelCase } from "./camel-case.ts";
+export { kebabCase } from "./kebab-case.ts";
+export { lowerFirst } from "./lower-first.ts";
+export { pascalCase } from "./pascal-case.ts";
+export { upperFirst } from "./upper-first.ts";

package/src/string/kebab-case.ts

@@ -1,14 +1,3 @@
-/**
- * Converts a camelCase or PascalCase string to kebab case by lower-casing uppercase letters and
- * inserting hyphens before interior ones.
- *
- * @param str - The string to convert.
- * @returns The kebab-cased string.
- *
- * @example
- * kebabCase("iconName"); // "icon-name"
- * kebabCase("Title"); // "title"
- */
 function kebabCase(str: string): string {
     return str.replaceAll(/[A-Z]/g, (char, index: number) =>
         index === 0 ? char.toLowerCase() : `-${char.toLowerCase()}`,

package/src/string/lower-first.ts

@@ -1,13 +1,3 @@
-/**
- * Converts the first character of a string to lower case.
- *
- * @param str - The string to transform.
- * @returns The string with its first character lower-cased.
- *
- * @example
- * lowerFirst("Fred"); // "fred"
- * lowerFirst("FRED"); // "fRED"
- */
 function lowerFirst(str: string): string {
     return str.charAt(0).toLowerCase() + str.slice(1);
 }

package/src/string/pascal-case.ts

@@ -1,19 +1,6 @@
-import { upperFirst } from "./upper-first.js";
-import { mapWordSegments } from "./word-segments.js";
+import { upperFirst } from "./upper-first.ts";
+import { mapWordSegments } from "./word-segments.ts";
 
-/**
- * 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: string): string {
     return mapWordSegments(str, upperFirst);
 }

package/src/string/upper-first.ts

@@ -1,13 +1,3 @@
-/**
- * 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: string): string {
     return str.charAt(0).toUpperCase() + str.slice(1);
 }

package/src/util/index.ts

@@ -1 +1 @@
-export { packageVersion } from "./package-version.js";
+export { packageVersion } from "./package-version.ts";

package/src/util/package-version.ts

@@ -1,16 +1,7 @@
 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: string): string {
-    return (createRequire(importMetaUrl)("../package.json") as { version: string }).version;
+function packageVersion(importMetaUrl: string, specifier: string): string {
+    return (createRequire(importMetaUrl)(specifier) as { version: string }).version;
 }
 
 export { packageVersion };

package/dist/function/call-method.d.ts

@@ -1,3 +0,0 @@
-declare function callMethod(target: object, method: string, args: unknown[]): unknown;
-export { callMethod };
-//# sourceMappingURL=call-method.d.ts.map

package/dist/function/call-method.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"call-method.d.ts","sourceRoot":"","sources":["../../src/function/call-method.ts"],"names":[],"mappings":"AAeA,iBAAS,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAI5E;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/function/call-method.js

@@ -1,19 +0,0 @@
-/**
- * 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) => typeof value === "function";
-function callMethod(target, method, args) {
-    const fn = Reflect.get(target, method);
-    return isCallable(fn) ? Reflect.apply(fn, target, args) : undefined;
-}
-export { callMethod };
-//# sourceMappingURL=call-method.js.map

package/dist/function/call-method.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"call-method.js","sourceRoot":"","sources":["../../src/function/call-method.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,GAAG,CAAC,KAAc,EAA0D,EAAE,CAC1F,OAAO,KAAK,KAAK,UAAU,CAAC;AAEhC,SAAS,UAAU,CAAC,MAAc,EAAE,MAAc,EAAE,IAAe;IAC/D,MAAM,EAAE,GAAY,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEhD,OAAO,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACxE,CAAC;AAED,OAAO,EAAE,UAAU,EAAE,CAAC","sourcesContent":["/**\n * Calls the named method on `target` with the given arguments, returning `undefined` when the\n * property is missing or not callable.\n *\n * @param target - The object to read the method from and bind as `this`.\n * @param method - The name of the method to look up.\n * @param args - The arguments passed to the method.\n * @returns The method's return value, or `undefined` when it is not a function.\n *\n * @example\n * callMethod(console, \"log\", [\"hi\"]); // logs \"hi\"; returns undefined\n */\nconst isCallable = (value: unknown): value is (this: object, ...args: unknown[]) => unknown =>\n    typeof value === \"function\";\n\nfunction callMethod(target: object, method: string, args: unknown[]): unknown {\n    const fn: unknown = Reflect.get(target, method);\n\n    return isCallable(fn) ? Reflect.apply(fn, target, args) : undefined;\n}\n\nexport { callMethod };\n"]}

package/dist/function/index.d.ts

@@ -1,2 +0,0 @@
-export { callMethod } from "./call-method.js";
-//# sourceMappingURL=index.d.ts.map

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

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

package/dist/function/index.js

@@ -1,2 +0,0 @@
-export { callMethod } from "./call-method.js";
-//# sourceMappingURL=index.js.map

package/dist/function/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/function/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC","sourcesContent":["export { callMethod } from \"./call-method.js\";\n"]}