feat: add flatCase and trainCase

README.md

@@ -69,6 +69,24 @@ snakeCase("foo-barBaz");
 // foo_bar_baz
 ```
 
+### `flatCase`
+
+Splits string and joins by flatcase convention:
+
+```ts
+flatCase("foo-barBaz");
+// foobarbaz
+```
+
+### `trainCase`
+
+Split string and joins by Train-Case (a.k.a. HTTP-Header-Case) convention:
+
+```ts
+trainCase("FooBARb");
+// Foo-Ba-Rb
+```
+
 ### `upperFirst(str)`
 
 Converts first character to upper case:

src/index.ts

@@ -5,6 +5,8 @@ import type {
   SnakeCase,
   SplitByCase,
   CaseOptions,
+  TrainCase,
+  FlatCase,
 } from "./types";
 
 const NUMBER_CHAR_RE = /\d/;
@@ -144,4 +146,32 @@ export function snakeCase<T extends string | readonly string[]>(str?: T) {
   return kebabCase(str || "", "_") as SnakeCase<T>;
 }
 
+export function flatCase(): "";
+export function flatCase<T extends string | readonly string[]>(
+  str: T,
+): FlatCase<T>;
+export function flatCase<T extends string | readonly string[]>(str?: T) {
+  return kebabCase(str || "", "") as FlatCase<T>;
+}
+
+export function trainCase(): "";
+export function trainCase<T extends string | readonly string[]>(
+  str: T,
+): TrainCase<T>;
+export function trainCase<T extends string | readonly string[]>(str?: T) {
+  return str
+    ? ((
+        (Array.isArray(str) ? str : splitByCase(str as string)) as Array<string>
+      )
+        // eslint-disable-next-line unicorn/no-array-reduce -- map and filter would require iterating twice
+        .reduce((acc, p) => {
+          acc +=
+            acc.length > 0
+              ? p && `-${upperFirst(p.toLowerCase())}`
+              : p && upperFirst(p.toLowerCase());
+          return acc;
+        }, "") as TrainCase<T>)
+    : "";
+}
+
 export * from "./types";

src/types.ts

@@ -146,3 +146,20 @@ export type SnakeCase<T extends string | readonly string[]> = JoinByCase<
   T,
   "_"
 >;
+
+export type TrainCase<T> = string extends T
+  ? string
+  : string[] extends T
+    ? string
+    : T extends string
+      ? SplitByCase<T> extends readonly string[]
+        ? CapitalizedWords<SplitByCase<T>, "-">
+        : never
+      : T extends readonly string[]
+        ? CapitalizedWords<T, "-">
+        : never;
+
+export type FlatCase<
+  T extends string | readonly string[],
+  Joiner extends string = "",
+> = JoinByCase<T, Joiner>;

test/scule.test.ts

@@ -7,6 +7,8 @@ import {
   upperFirst,
   lowerFirst,
   snakeCase,
+  trainCase,
+  flatCase,
 } from "../src";
 
 describe("splitByCase", () => {
@@ -103,3 +105,32 @@ describe("lowerFirst", () => {
     expect(lowerFirst(input)).toMatchObject(expected);
   });
 });
+
+describe("trainCase", () => {
+  test.each([
+    ["", ""],
+    ["f", "F"],
+    ["foo", "Foo"],
+    ["foo-bAr", "Foo-B-Ar"],
+    ["FooBARb", "Foo-Ba-Rb"],
+    ["foo_bar-baz/qux", "Foo-Bar-Baz-Qux"],
+    ["FOO_BAR", "Foo-Bar"],
+    ["foo--bar-Baz", "Foo-Bar-Baz"],
+  ])("%s => %s", (input, expected) => {
+    expect(trainCase(input)).toMatchObject(expected);
+  });
+});
+
+describe("flatCase", () => {
+  test.each([
+    ["", ""],
+    ["foo", "foo"],
+    ["foo-bAr", "foobar"],
+    ["FooBARb", "foobarb"],
+    ["foo_bar-baz/qux", "foobarbazqux"],
+    ["FOO_BAR", "foobar"],
+    ["foo--bar-Baz", "foobarbaz"],
+  ])("%s => %s", (input, expected) => {
+    expect(flatCase(input)).toMatchObject(expected);
+  });
+});