@gtkx/utils 0.21.0 → 1.0.0-rc.1

package/dist/reflect.js

@@ -0,0 +1,14 @@
+/**
+ * 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 method name to look up.
+ * @param args Arguments passed to the method.
+ * @returns The method's return value, or `undefined` when it is not a function.
+ */
+export const callMethod = (target, method, args) => {
+    const fn = Reflect.get(target, method);
+    return typeof fn === "function" ? Reflect.apply(fn, target, args) : undefined;
+};
+//# sourceMappingURL=reflect.js.map

package/dist/reflect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflect.js","sourceRoot":"","sources":["../src/reflect.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,MAAc,EAAE,MAAc,EAAE,IAAe,EAAW,EAAE;IACnF,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,OAAO,OAAO,EAAE,KAAK,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAClF,CAAC,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 method name to look up.\n * @param args Arguments passed to the method.\n * @returns The method's return value, or `undefined` when it is not a function.\n */\nexport const callMethod = (target: object, method: string, args: unknown[]): unknown => {\n    const fn = Reflect.get(target, method);\n    return typeof fn === \"function\" ? Reflect.apply(fn, target, args) : undefined;\n};\n"]}

package/dist/source.d.ts

@@ -1,34 +1,21 @@
 /**
- * Helpers for shaping values into safe JavaScript/TypeScript source fragments:
- * a reserved-word-safe identifier and a source-safe string literal. Both are
- * pure and runtime-agnostic, intended for code generators that emit TypeScript.
+ * 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.
  */
+export declare const sanitizeIdentifier: (name: string) => string;
 /**
- * Rewrites a candidate name into a JavaScript identifier safe to use at
- * variable, parameter, or property position.
- *
- * The input is expected to already use valid identifier characters (for
- * example the output of a case-conversion helper); the only transformation
- * applied is appending an underscore when `name` collides with a reserved
- * word or global identifier, so `toIdentifier("class")` is `"class_"` and
- * `toIdentifier("iconName")` is `"iconName"`.
+ * Converts a name to camelCase and sanitizes it into a valid JavaScript identifier.
  *
- * @param name - The candidate identifier.
- * @returns A reserved-word-safe identifier.
+ * @param name The name to convert.
  */
-export declare const toIdentifier: (name: string) => string;
+export declare const toCamelIdentifier: (name: string) => string;
 /**
- * Quotes a string for safe embedding as a literal in generated TypeScript
- * source.
- *
- * Builds a double-quoted literal with `JSON.stringify`, then escapes the
- * characters that are valid inside a JSON string yet unsafe inside JavaScript
- * source: the angle brackets that could otherwise break out of an enclosing
- * `</script>` and the U+2028/U+2029 line separators that prematurely terminate
- * a string literal. The escaped form parses back to the original value.
+ * 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 embed.
- * @returns A source-safe double-quoted string literal.
+ * @param value The string to encode.
  */
-export declare const quote: (value: string) => string;
+export declare const sourceStringLiteral: (value: string) => string;
 //# sourceMappingURL=source.d.ts.map

package/dist/source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../src/source.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAqDH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,KAAG,MAAkD,CAAC;AAmB/F;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,KAAG,MAA8E,CAAC"}
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../src/source.ts"],"names":[],"mappings":"AAoDA;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,SAAU,MAAM,KAAG,MAAkD,CAAC;AAErG;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,SAAU,MAAM,KAAG,MAA+C,CAAC;AAWjG;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,UAAW,MAAM,KAAG,MAC0C,CAAC"}

package/dist/source.js

@@ -1,9 +1,4 @@
-/**
- * Helpers for shaping values into safe JavaScript/TypeScript source fragments:
- * a reserved-word-safe identifier and a source-safe string literal. Both are
- * pure and runtime-agnostic, intended for code generators that emit TypeScript.
- */
-/** Reserved words and global identifiers a generated identifier must not collide with. */
+import { toCamelCase } from "./string.js";
 const RESERVED = new Set([
     "arguments",
     "await",
@@ -54,46 +49,30 @@ const RESERVED = new Set([
     "yield",
 ]);
 /**
- * Rewrites a candidate name into a JavaScript identifier safe to use at
- * variable, parameter, or property position.
+ * 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.
  *
- * The input is expected to already use valid identifier characters (for
- * example the output of a case-conversion helper); the only transformation
- * applied is appending an underscore when `name` collides with a reserved
- * word or global identifier, so `toIdentifier("class")` is `"class_"` and
- * `toIdentifier("iconName")` is `"iconName"`.
+ * @param name The candidate identifier.
+ */
+export const sanitizeIdentifier = (name) => (RESERVED.has(name) ? `${name}_` : name);
+/**
+ * Converts a name to camelCase and sanitizes it into a valid JavaScript identifier.
  *
- * @param name - The candidate identifier.
- * @returns A reserved-word-safe identifier.
+ * @param name The name to convert.
  */
-export const toIdentifier = (name) => (RESERVED.has(name) ? `${name}_` : name);
-const UNSAFE_SOURCE_CHARS = /[<>\u2028\u2029]/g;
-const escapeSourceChar = (char) => {
-    switch (char) {
-        case "<":
-            return "\\u003C";
-        case ">":
-            return "\\u003E";
-        case "\u2028":
-            return "\\u2028";
-        case "\u2029":
-            return "\\u2029";
-        default:
-            return char;
-    }
+export const toCamelIdentifier = (name) => sanitizeIdentifier(toCamelCase(name));
+const SOURCE_ESCAPES = {
+    "<": "\\u003C",
+    ">": "\\u003E",
+    "\u2028": "\\u2028",
+    "\u2029": "\\u2029",
 };
+const UNSAFE_SOURCE_CHARS = new RegExp(`[${Object.keys(SOURCE_ESCAPES).join("")}]`, "g");
 /**
- * Quotes a string for safe embedding as a literal in generated TypeScript
- * source.
- *
- * Builds a double-quoted literal with `JSON.stringify`, then escapes the
- * characters that are valid inside a JSON string yet unsafe inside JavaScript
- * source: the angle brackets that could otherwise break out of an enclosing
- * `</script>` and the U+2028/U+2029 line separators that prematurely terminate
- * a string literal. The escaped form parses back to the original value.
+ * 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 embed.
- * @returns A source-safe double-quoted string literal.
+ * @param value The string to encode.
  */
-export const quote = (value) => JSON.stringify(value).replace(UNSAFE_SOURCE_CHARS, escapeSourceChar);
+export const sourceStringLiteral = (value) => JSON.stringify(value).replace(UNSAFE_SOURCE_CHARS, (char) => SOURCE_ESCAPES[char] ?? char);
 //# sourceMappingURL=source.js.map

package/dist/source.js.map

@@ -1 +1 @@
-{"version":3,"file":"source.js","sourceRoot":"","sources":["../src/source.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,0FAA0F;AAC1F,MAAM,QAAQ,GAAwB,IAAI,GAAG,CAAC;IAC1C,WAAW;IACX,OAAO;IACP,OAAO;IACP,MAAM;IACN,OAAO;IACP,OAAO;IACP,OAAO;IACP,UAAU;IACV,UAAU;IACV,SAAS;IACT,QAAQ;IACR,IAAI;IACJ,MAAM;IACN,MAAM;IACN,MAAM;IACN,QAAQ;IACR,SAAS;IACT,OAAO;IACP,SAAS;IACT,KAAK;IACL,UAAU;IACV,IAAI;IACJ,QAAQ;IACR,IAAI;IACJ,YAAY;IACZ,WAAW;IACX,KAAK;IACL,KAAK;IACL,MAAM;IACN,SAAS;IACT,SAAS;IACT,WAAW;IACX,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,OAAO;IACP,QAAQ;IACR,MAAM;IACN,OAAO;IACP,MAAM;IACN,KAAK;IACL,QAAQ;IACR,KAAK;IACL,MAAM;IACN,OAAO;IACP,MAAM;IACN,OAAO;CACV,CAAC,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,IAAY,EAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAE/F,MAAM,mBAAmB,GAAG,mBAAmB,CAAC;AAEhD,MAAM,gBAAgB,GAAG,CAAC,IAAY,EAAU,EAAE;IAC9C,QAAQ,IAAI,EAAE,CAAC;QACX,KAAK,GAAG;YACJ,OAAO,SAAS,CAAC;QACrB,KAAK,GAAG;YACJ,OAAO,SAAS,CAAC;QACrB,KAAK,QAAQ;YACT,OAAO,SAAS,CAAC;QACrB,KAAK,QAAQ;YACT,OAAO,SAAS,CAAC;QACrB;YACI,OAAO,IAAI,CAAC;IACpB,CAAC;AACL,CAAC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,KAAa,EAAU,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,mBAAmB,EAAE,gBAAgB,CAAC,CAAC"}
+{"version":3,"file":"source.js","sourceRoot":"","sources":["../src/source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,MAAM,QAAQ,GAAgB,IAAI,GAAG,CAAC;IAClC,WAAW;IACX,OAAO;IACP,OAAO;IACP,MAAM;IACN,OAAO;IACP,OAAO;IACP,OAAO;IACP,UAAU;IACV,UAAU;IACV,SAAS;IACT,QAAQ;IACR,IAAI;IACJ,MAAM;IACN,MAAM;IACN,MAAM;IACN,QAAQ;IACR,SAAS;IACT,OAAO;IACP,SAAS;IACT,KAAK;IACL,UAAU;IACV,IAAI;IACJ,QAAQ;IACR,IAAI;IACJ,YAAY;IACZ,WAAW;IACX,KAAK;IACL,KAAK;IACL,MAAM;IACN,SAAS;IACT,SAAS;IACT,WAAW;IACX,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,OAAO;IACP,QAAQ;IACR,MAAM;IACN,OAAO;IACP,MAAM;IACN,KAAK;IACL,QAAQ;IACR,KAAK;IACL,MAAM;IACN,OAAO;IACP,MAAM;IACN,OAAO;CACV,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,IAAY,EAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAErG;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,IAAY,EAAU,EAAE,CAAC,kBAAkB,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;AAEjG,MAAM,cAAc,GAA2B;IAC3C,GAAG,EAAE,SAAS;IACd,GAAG,EAAE,SAAS;IACd,QAAQ,EAAE,SAAS;IACnB,QAAQ,EAAE,SAAS;CACtB,CAAC;AAEF,MAAM,mBAAmB,GAAG,IAAI,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AAEzF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,KAAa,EAAU,EAAE,CACzD,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,mBAAmB,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC","sourcesContent":["import { toCamelCase } from \"./string.js\";\n\nconst RESERVED: Set<string> = new Set([\n    \"arguments\",\n    \"await\",\n    \"break\",\n    \"case\",\n    \"catch\",\n    \"class\",\n    \"const\",\n    \"continue\",\n    \"debugger\",\n    \"default\",\n    \"delete\",\n    \"do\",\n    \"else\",\n    \"enum\",\n    \"eval\",\n    \"export\",\n    \"extends\",\n    \"false\",\n    \"finally\",\n    \"for\",\n    \"function\",\n    \"if\",\n    \"import\",\n    \"in\",\n    \"instanceof\",\n    \"interface\",\n    \"let\",\n    \"new\",\n    \"null\",\n    \"package\",\n    \"private\",\n    \"protected\",\n    \"public\",\n    \"return\",\n    \"static\",\n    \"super\",\n    \"switch\",\n    \"this\",\n    \"throw\",\n    \"true\",\n    \"try\",\n    \"typeof\",\n    \"var\",\n    \"void\",\n    \"while\",\n    \"with\",\n    \"yield\",\n]);\n\n/**\n * Returns the name unchanged, or with a trailing underscore when it collides with a reserved word,\n * so it is safe to emit as a JavaScript identifier.\n *\n * @param name The candidate identifier.\n */\nexport const sanitizeIdentifier = (name: string): string => (RESERVED.has(name) ? `${name}_` : name);\n\n/**\n * Converts a name to camelCase and sanitizes it into a valid JavaScript identifier.\n *\n * @param name The name to convert.\n */\nexport const toCamelIdentifier = (name: string): string => sanitizeIdentifier(toCamelCase(name));\n\nconst SOURCE_ESCAPES: Record<string, string> = {\n    \"<\": \"\\\\u003C\",\n    \">\": \"\\\\u003E\",\n    \"\\u2028\": \"\\\\u2028\",\n    \"\\u2029\": \"\\\\u2029\",\n};\n\nconst UNSAFE_SOURCE_CHARS = new RegExp(`[${Object.keys(SOURCE_ESCAPES).join(\"\")}]`, \"g\");\n\n/**\n * Encodes a string as a JavaScript string literal, additionally escaping characters that are unsafe\n * to embed in generated source (angle brackets and the line and paragraph separators).\n *\n * @param value The string to encode.\n */\nexport const sourceStringLiteral = (value: string): string =>\n    JSON.stringify(value).replace(UNSAFE_SOURCE_CHARS, (char) => SOURCE_ESCAPES[char] ?? char);\n"]}

package/dist/string.d.ts

@@ -1,59 +1,32 @@
 /**
- * Pure, runtime-agnostic string-case helpers.
+ * Returns the string with its first character uppercased.
  *
- * The conversions translate between snake_case, kebab-case, camelCase, and
- * PascalCase. They split only on underscores and hyphens and preserve the case
- * of each segment, so they are not a substitute for a full Unicode-aware case
- * transform.
+ * @param value The string to transform.
  */
+export declare const upperFirst: (value: string) => string;
 /**
- * Uppercases the first character of `value`, leaving the remaining characters
- * untouched.
+ * Returns the string with its first character lowercased.
  *
- * The tail is preserved verbatim rather than lowercased, so
- * `toUpperFirst("fooBar")` is `"FooBar"` and `toUpperFirst("URL")` is `"URL"`. An
- * empty string returns an empty string.
- *
- * @param value - The string to transform.
- * @returns `value` with its first character uppercased.
+ * @param value The string to transform.
  */
-export declare const toUpperFirst: (value: string) => string;
+export declare const lowerFirst: (value: string) => string;
 /**
- * Converts a snake_case or kebab-case string to camelCase.
- *
- * The input is split on underscores and hyphens, dropping empty segments from
- * leading, trailing, or repeated separators. The first segment is kept
- * verbatim and every later segment is {@link toUpperFirst}-cased before joining,
- * so `toCamelCase("icon_name")` is `"iconName"` and `toCamelCase("Box")` is
- * `"Box"`. A string with no separators is returned unchanged.
+ * Converts an underscore- or hyphen-delimited string to camelCase.
  *
- * @param input - The snake_case or kebab-case identifier.
- * @returns The camelCase form of `input`.
+ * @param input The string to convert.
  */
 export declare const toCamelCase: (input: string) => string;
 /**
- * Converts a snake_case, kebab-case, or already-PascalCase string to
- * PascalCase.
+ * Converts an underscore- or hyphen-delimited string to PascalCase.
  *
- * The input is split on underscores and hyphens, dropping empty segments, and
- * every remaining segment is {@link toUpperFirst}-cased before joining, so
- * `toPascalCase("icon_name")` is `"IconName"` and `toPascalCase("Box")` is
- * `"Box"`. An empty string is returned unchanged.
- *
- * @param input - The identifier to transform.
- * @returns The PascalCase form of `input`.
+ * @param input The string to convert.
  */
 export declare const toPascalCase: (input: string) => string;
 /**
- * Converts a camelCase or PascalCase string to kebab-case.
- *
- * Each uppercase character is lowercased; every uppercase character other than
- * the first is additionally prefixed with a hyphen, so `toKebabCase("iconName")`
- * is `"icon-name"` and `toKebabCase("Title")` is `"title"`. The leading
- * character is never prefixed with a hyphen.
+ * Converts a camelCase or PascalCase string to kebab-case by lowercasing uppercase letters and
+ * inserting hyphens before interior ones.
  *
- * @param input - The camelCase or PascalCase identifier.
- * @returns The kebab-case form of `input`.
+ * @param input The string to convert.
  */
 export declare const toKebabCase: (input: string) => string;
 //# sourceMappingURL=string.d.ts.map

package/dist/string.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../src/string.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,KAAG,MAAwD,CAAC;AAEtG;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,KAAG,MAM3C,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,KAAG,MAK5C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,KAAG,MAC0E,CAAC"}
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../src/string.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,UAAU,UAAW,MAAM,KAAG,MAAwD,CAAC;AAEpG;;;;GAIG;AACH,eAAO,MAAM,UAAU,UAAW,MAAM,KAAG,MAAwD,CAAC;AAIpG;;;;GAIG;AACH,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,MAI3C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,UAAW,MAAM,KAAG,MAI5C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,MAC0E,CAAC"}

package/dist/string.js

@@ -1,73 +1,43 @@
 /**
- * Pure, runtime-agnostic string-case helpers.
+ * Returns the string with its first character uppercased.
  *
- * The conversions translate between snake_case, kebab-case, camelCase, and
- * PascalCase. They split only on underscores and hyphens and preserve the case
- * of each segment, so they are not a substitute for a full Unicode-aware case
- * transform.
+ * @param value The string to transform.
  */
+export const upperFirst = (value) => value.charAt(0).toUpperCase() + value.slice(1);
 /**
- * Uppercases the first character of `value`, leaving the remaining characters
- * untouched.
+ * Returns the string with its first character lowercased.
  *
- * The tail is preserved verbatim rather than lowercased, so
- * `toUpperFirst("fooBar")` is `"FooBar"` and `toUpperFirst("URL")` is `"URL"`. An
- * empty string returns an empty string.
- *
- * @param value - The string to transform.
- * @returns `value` with its first character uppercased.
+ * @param value The string to transform.
  */
-export const toUpperFirst = (value) => value.charAt(0).toUpperCase() + value.slice(1);
+export const lowerFirst = (value) => value.charAt(0).toLowerCase() + value.slice(1);
+const splitWords = (input) => input.split(/[_-]/g).filter((part) => part.length > 0);
 /**
- * Converts a snake_case or kebab-case string to camelCase.
- *
- * The input is split on underscores and hyphens, dropping empty segments from
- * leading, trailing, or repeated separators. The first segment is kept
- * verbatim and every later segment is {@link toUpperFirst}-cased before joining,
- * so `toCamelCase("icon_name")` is `"iconName"` and `toCamelCase("Box")` is
- * `"Box"`. A string with no separators is returned unchanged.
+ * Converts an underscore- or hyphen-delimited string to camelCase.
  *
- * @param input - The snake_case or kebab-case identifier.
- * @returns The camelCase form of `input`.
+ * @param input The string to convert.
  */
 export const toCamelCase = (input) => {
-    const parts = input.split(/[_-]/g).filter((part) => part.length > 0);
+    const parts = splitWords(input);
     if (parts.length === 0)
         return input;
-    const [first, ...rest] = parts;
-    const head = first ?? "";
-    return head + rest.map(toUpperFirst).join("");
+    return parts.map((part, index) => (index === 0 ? part : upperFirst(part))).join("");
 };
 /**
- * Converts a snake_case, kebab-case, or already-PascalCase string to
- * PascalCase.
- *
- * The input is split on underscores and hyphens, dropping empty segments, and
- * every remaining segment is {@link toUpperFirst}-cased before joining, so
- * `toPascalCase("icon_name")` is `"IconName"` and `toPascalCase("Box")` is
- * `"Box"`. An empty string is returned unchanged.
+ * Converts an underscore- or hyphen-delimited string to PascalCase.
  *
- * @param input - The identifier to transform.
- * @returns The PascalCase form of `input`.
+ * @param input The string to convert.
  */
 export const toPascalCase = (input) => {
-    if (input.length === 0)
-        return input;
-    const parts = input.split(/[_-]/g).filter((part) => part.length > 0);
+    const parts = splitWords(input);
     if (parts.length === 0)
         return input;
-    return parts.map(toUpperFirst).join("");
+    return parts.map(upperFirst).join("");
 };
 /**
- * Converts a camelCase or PascalCase string to kebab-case.
- *
- * Each uppercase character is lowercased; every uppercase character other than
- * the first is additionally prefixed with a hyphen, so `toKebabCase("iconName")`
- * is `"icon-name"` and `toKebabCase("Title")` is `"title"`. The leading
- * character is never prefixed with a hyphen.
+ * Converts a camelCase or PascalCase string to kebab-case by lowercasing uppercase letters and
+ * inserting hyphens before interior ones.
  *
- * @param input - The camelCase or PascalCase identifier.
- * @returns The kebab-case form of `input`.
+ * @param input The string to convert.
  */
 export const toKebabCase = (input) => input.replaceAll(/[A-Z]/g, (char, index) => (index === 0 ? char.toLowerCase() : `-${char.toLowerCase()}`));
 //# sourceMappingURL=string.js.map

package/dist/string.js.map

@@ -1 +1 @@
-{"version":3,"file":"string.js","sourceRoot":"","sources":["../src/string.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAa,EAAU,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAEtG;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE;IACjD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACrE,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACrC,MAAM,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,GAAG,KAAK,CAAC;IAC/B,MAAM,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;IACzB,OAAO,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AAClD,CAAC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAa,EAAU,EAAE;IAClD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACrC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACrE,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACrC,OAAO,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AAC5C,CAAC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE,CACjD,KAAK,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,KAAa,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,CAAC"}
+{"version":3,"file":"string.js","sourceRoot":"","sources":["../src/string.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,KAAa,EAAU,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAEpG;;;;GAIG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,KAAa,EAAU,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAEpG,MAAM,UAAU,GAAG,CAAC,KAAa,EAAY,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AAEvG;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE;IACjD,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;IAChC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACrC,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AACxF,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAa,EAAU,EAAE;IAClD,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;IAChC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACrC,OAAO,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AAC1C,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE,CACjD,KAAK,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,KAAa,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,CAAC","sourcesContent":["/**\n * Returns the string with its first character uppercased.\n *\n * @param value The string to transform.\n */\nexport const upperFirst = (value: string): string => value.charAt(0).toUpperCase() + value.slice(1);\n\n/**\n * Returns the string with its first character lowercased.\n *\n * @param value The string to transform.\n */\nexport const lowerFirst = (value: string): string => value.charAt(0).toLowerCase() + value.slice(1);\n\nconst splitWords = (input: string): string[] => input.split(/[_-]/g).filter((part) => part.length > 0);\n\n/**\n * Converts an underscore- or hyphen-delimited string to camelCase.\n *\n * @param input The string to convert.\n */\nexport const toCamelCase = (input: string): string => {\n    const parts = splitWords(input);\n    if (parts.length === 0) return input;\n    return parts.map((part, index) => (index === 0 ? part : upperFirst(part))).join(\"\");\n};\n\n/**\n * Converts an underscore- or hyphen-delimited string to PascalCase.\n *\n * @param input The string to convert.\n */\nexport const toPascalCase = (input: string): string => {\n    const parts = splitWords(input);\n    if (parts.length === 0) return input;\n    return parts.map(upperFirst).join(\"\");\n};\n\n/**\n * Converts a camelCase or PascalCase string to kebab-case by lowercasing uppercase letters and\n * inserting hyphens before interior ones.\n *\n * @param input The string to convert.\n */\nexport const toKebabCase = (input: string): string =>\n    input.replaceAll(/[A-Z]/g, (char, index: number) => (index === 0 ? char.toLowerCase() : `-${char.toLowerCase()}`));\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.1",
+  "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,15 @@
     "dist",
     "src"
   ],
+  "dependencies": {
+    "picocolors": "^1.1.1"
+  },
+  "engines": {
+    "node": ">=24"
+  },
   "scripts": {
-    "build": "tsc -b",
-    "test": "vitest run",
-    "typecheck": "tsc -b --emitDeclarationOnly"
+    "build": "tsc -b tsconfig.lib.json",
+    "typecheck": "tsc -b --emitDeclarationOnly",
+    "release": "tsx ../../scripts/release-package.ts"
   }
 }

package/src/class.ts

@@ -1,17 +1,36 @@
 /**
- * Structural type matching any class — abstract or concrete — whose instances
- * have type `T`.
- *
- * A class value carries a construct signature plus a `prototype`, but a bare
- * construct signature types `prototype` as `any`. The `& { prototype: T }`
- * intersection recovers the precise instance type so callers can read
- * `cls.prototype` as `T`, and the `abstract new` form accepts both abstract and
- * concrete classes, making this the widest supertype of every class value. The
- * `never[]` constructor parameters admit any class while documenting that the
- * type is used as an identity token, not to construct instances.
+ * A constructor value of any (possibly abstract) class producing instances of `T`.
  */
 export type AnyClass<T extends object = object> = (abstract new (
     ...args: never[]
 ) => T) & {
-    readonly prototype: T;
+    prototype: T;
 };
+
+/**
+ * Returns the direct superclass of `cls`, or `null` when it has no class ancestor.
+ *
+ * @param cls The class whose prototype parent to inspect.
+ */
+export function getParentClass(cls: AnyClass): AnyClass | null {
+    const parent: unknown = Object.getPrototypeOf(cls);
+    return typeof parent === "function" && parent !== Function.prototype ? (parent as AnyClass) : null;
+}
+
+/**
+ * Walks the class chain from `cls` up through its ancestors, calling `visit` on each and
+ * returning the first result that is not `undefined`.
+ *
+ * @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` if none was produced.
+ */
+export 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;
+}

package/src/collection.ts

@@ -1,103 +1,65 @@
 /**
- * Pure, runtime-agnostic collection helpers shared across GTKX packages.
- */
-
-/**
- * Returns a shallow copy of `record` with the given `keys` removed.
- *
- * Keys absent from `record` are ignored, and `record` is not mutated. The
- * result is typed as the input shape because callers treat the excluded keys
- * as runtime-only concerns absent from the static type.
+ * Returns the items with duplicates removed, keeping the first item for each distinct key.
  *
- * @typeParam T - The record shape.
- * @param record - The source object.
- * @param keys - The keys to exclude from the copy.
- * @returns A new object holding every own enumerable key of `record` except
- *   those listed in `keys`.
+ * @param items The items to deduplicate.
+ * @param key Computes the identity string used to detect duplicates.
  */
-export const omit = <T extends Record<string, unknown>>(record: T, keys: readonly string[]): T => {
-    const result: Record<string, unknown> = {};
-    for (const key of Object.keys(record)) {
-        if (!keys.includes(key)) {
-            result[key] = record[key];
-        }
+export const uniqBy = <T>(items: T[], key: (item: T) => string): T[] => {
+    const seen = new Set<string>();
+    const result: T[] = [];
+    for (const item of items) {
+        const identity = key(item);
+        if (seen.has(identity)) continue;
+        seen.add(identity);
+        result.push(item);
     }
-    return result as T;
+    return result;
 };
 
-/**
- * Compares two arrays of primitives for element-wise strict equality.
- *
- * Returns `true` when both arguments are the same reference (including both
- * being `null` or `undefined`), or when they have equal length and every
- * element is strictly equal (`===`) at the same index. A `null`/`undefined`
- * argument is equal only to another `null`/`undefined` argument.
- *
- * @typeParam T - The primitive element type.
- * @param a - The first array, or `null`/`undefined`.
- * @param b - The second array, or `null`/`undefined`.
- * @returns Whether the two arrays are shallowly equal.
- */
-export const isShallowEqual = <T extends string | number | boolean>(
-    a: readonly T[] | null | undefined,
-    b: readonly T[] | null | undefined,
-): boolean => {
-    if (a === b) return true;
-    if (!a || !b) return false;
+export const isSameArray = <T>(a: T[], b: T[]): boolean => {
     if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i]) return false;
+    for (let index = 0; index < a.length; index++) {
+        if (a[index] !== b[index]) return false;
     }
     return true;
 };
 
+const compareStrings = (a: string, b: string): number => a.localeCompare(b);
+
 /**
- * Compares two arrays of records by shallow per-element equality.
+ * Returns a new array of the given strings sorted with locale-aware comparison.
  *
- * Returns `true` when both arrays have equal length and, at every index, the
- * two records expose the same set of keys with strictly equal (`===`) values.
- * Values are compared one level deep only; nested objects are compared by
- * reference.
+ * @param values The strings to sort.
+ */
+export const sortStrings = (values: Iterable<string>): string[] => [...values].sort(compareStrings);
+
+/**
+ * Returns a new array of the given items sorted by a locale-aware comparison of their keys.
  *
- * @typeParam T - The record element type.
- * @param a - The first array of records.
- * @param b - The second array of records.
- * @returns Whether the two arrays are element-wise shallowly equal.
+ * @param items The items to sort.
+ * @param key Computes the string to sort each item by.
  */
-export const isShallowArrayEqual = <T extends Record<string, unknown>>(a: readonly T[], b: readonly T[]): boolean => {
-    if (a.length !== b.length) return false;
+export const sortStringsBy = <T>(items: Iterable<T>, key: (item: T) => string): T[] =>
+    [...items].sort((a, b) => compareStrings(key(a), key(b)));
 
-    for (let i = 0; i < a.length; i++) {
-        const itemA = a[i];
-        const itemB = b[i];
-        if (!itemA || !itemB) return false;
+/**
+ * Determines whether two records have the same keys and strictly equal values.
+ *
+ * @param a The first record, or `undefined`.
+ * @param b The second record, or `undefined`.
+ * @returns `true` when both are the same reference, or both are defined with identical own keys and values.
+ */
+export const isShallowEqual = <T extends Record<string, unknown>>(a?: T, b?: T): boolean => {
+    if (a === b) return true;
+    if (!a || !b) return false;
 
-        const keysA = Object.keys(itemA);
-        const keysB = Object.keys(itemB);
-        if (keysA.length !== keysB.length) return false;
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
 
-        for (const key of keysA) {
-            if (itemA[key] !== itemB[key]) return false;
-        }
+    for (const key of keysA) {
+        if (a[key] !== b[key]) return false;
     }
 
     return true;
 };
-
-/**
- * Builds a reverse lookup from a numeric enum's values to their member names.
- *
- * A TypeScript numeric enum's runtime object carries both name-to-value and
- * value-to-name entries; this keeps only the name-to-value direction and
- * inverts it, yielding a `Map` from each numeric value to the name that
- * declared it.
- *
- * @param enumObject - A numeric enum's runtime object.
- * @returns A map from each numeric enum value to its declared member name.
- */
-export const reverseNumericEnum = (enumObject: Record<string, string | number>): Map<number, string> =>
-    new Map<number, string>(
-        Object.entries(enumObject)
-            .filter((entry): entry is [string, number] => typeof entry[1] === "number")
-            .map(([name, value]) => [value, name]),
-    );