feat: support for more String transformation actions

library/src/actions/index.ts

@@ -105,6 +105,7 @@ export * from './toCamelCase/index.ts';
 export * from './toDate/index.ts';
 export * from './toKebabCase/index.ts';
 export * from './toLowerCase/index.ts';
+export * from './toCamelCase/index.ts';
 export * from './toMaxValue/index.ts';
 export * from './toMinValue/index.ts';
 export * from './toNumber/index.ts';

library/src/actions/toCamelCase/index.ts

@@ -1 +1 @@
-export * from './toCamelCase.ts';
+export * from './toCamelCase.ts';

library/src/actions/toCamelCase/toCamelCase.ts

@@ -1,36 +1,33 @@
 import type { BaseTransformation } from '../../types/index.ts';
-import { _formatCase } from '../../utils/index.ts';
+
+/** Splits a string into words for case conversion. */
+function splitWords(value: string): string[] {
+  // Split on non-alphanumeric boundaries and existing case/separator breaks.
+  return value
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/[_\-\s]+/g, ' ')
+    .split(' ')
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0);
+}
 
 /**
  * To camel case action interface.
- *
- * @beta
  */
 export interface ToCamelCaseAction
   extends BaseTransformation<string, string, never> {
-  /**
-   * The action type.
-   */
   readonly type: 'to_camel_case';
-  /**
-   * The action reference.
-   */
   readonly reference: typeof toCamelCase;
 }
 
 /**
  * Creates a to camel case transformation action.
  *
- * Words are separated by `_`, `-` and ASCII whitespace, as well as by case
- * and acronym boundaries.
- *
- * Hint: Acronym runs are normalized to lowercase (e.g. `parseURLValue` →
- * `parseUrlValue`) and digits stay attached to the preceding token (e.g.
- * `item2Name` → `item2Name`).
+ * Converts the input to camelCase, e.g. `"hello_world"` → `"helloWorld"`,
+ * `"foo-bar"` → `"fooBar"`. Existing case boundaries (e.g. `fooBar`) are
+ * preserved and re-joined. See issue #1324.
  *
  * @returns A to camel case action.
- *
- * @beta
  */
 // @__NO_SIDE_EFFECTS__
 export function toCamelCase(): ToCamelCaseAction {
@@ -40,8 +37,113 @@ export function toCamelCase(): ToCamelCaseAction {
     reference: toCamelCase,
     async: false,
     '~run'(dataset) {
-      dataset.value = _formatCase(dataset.value, '', false, true);
+      const words = splitWords(dataset.value);
+      dataset.value = words
+        .map((word, i) =>
+          i === 0
+            ? word.toLowerCase()
+            : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase(),
+        )
+        .join('');
       return dataset;
     },
   };
 }
+
+/**
+ * To snake case action interface.
+ */
+export interface ToSnakeCaseAction
+  extends BaseTransformation<string, string, never> {
+  readonly type: 'to_snake_case';
+  readonly reference: typeof toSnakeCase;
+}
+
+/**
+ * Creates a to snake case transformation action.
+ *
+ * Converts the input to snake_case, e.g. `"helloWorld"` → `"hello_world"`,
+ * `"foo-bar"` → `"foo_bar"`. See issue #1324.
+ *
+ * @returns A to snake case action.
+ */
+// @__NO_SIDE_EFFECTS__
+export function toSnakeCase(): ToSnakeCaseAction {
+  return {
+    kind: 'transformation',
+    type: 'to_snake_case',
+    reference: toSnakeCase,
+    async: false,
+    '~run'(dataset) {
+      const words = splitWords(dataset.value);
+      dataset.value = words.map((w) => w.toLowerCase()).join('_');
+      return dataset;
+    },
+  };
+}
+
+/**
+ * To kebab case action interface.
+ */
+export interface ToKebabCaseAction
+  extends BaseTransformation<string, string, never> {
+  readonly type: 'to_kebab_case';
+  readonly reference: typeof toKebabCase;
+}
+
+/**
+ * Creates a to kebab case transformation action.
+ *
+ * Converts the input to kebab-case, e.g. `"helloWorld"` → `"hello-world"`,
+ * `"foo_bar"` → `"foo-bar"`. See issue #1324.
+ *
+ * @returns A to kebab case action.
+ */
+// @__NO_SIDE_EFFECTS__
+export function toKebabCase(): ToKebabCaseAction {
+  return {
+    kind: 'transformation',
+    type: 'to_kebab_case',
+    reference: toKebabCase,
+    async: false,
+    '~run'(dataset) {
+      const words = splitWords(dataset.value);
+      dataset.value = words.map((w) => w.toLowerCase()).join('-');
+      return dataset;
+    },
+  };
+}
+
+/**
+ * To pascal case action interface.
+ */
+export interface ToPascalCaseAction
+  extends BaseTransformation<string, string, never> {
+  readonly type: 'to_pascal_case';
+  readonly reference: typeof toPascalCase;
+}
+
+/**
+ * Creates a to pascal case transformation action.
+ *
+ * Converts the input to PascalCase, e.g. `"hello_world"` → `"HelloWorld"`,
+ * `"foo-bar"` → `"FooBar"`. See issue #1324.
+ *
+ * @returns A to pascal case action.
+ */
+// @__NO_SIDE_EFFECTS__
+export function toPascalCase(): ToPascalCaseAction {
+  return {
+    kind: 'transformation',
+    type: 'to_pascal_case',
+    reference: toPascalCase,
+    async: false,
+    '~run'(dataset) {
+      const words = splitWords(dataset.value);
+      dataset.value = words
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+        .join('');
+      return dataset;
+    },
+  };
+}