Merge branch 'ref/komoji'

* ref/komoji:
  komoji

Author: pyramation

packages/komoji/README.md

@@ -60,6 +60,42 @@ toCamelCase('__private_field', true);  // privateField
 toCamelCase('123-invalid', true);      // invalid
 ```
 
+### Transform to snake_case
+
+```typescript
+import { toSnakeCase } from 'komoji';
+
+toSnakeCase('helloWorld');        // hello_world
+toSnakeCase('UserName');          // user_name
+toSnakeCase('api-response-data'); // api_response_data
+toSnakeCase('myComponentV2');     // my_component_v2
+toSnakeCase('HTTPSConnection');   // https_connection
+```
+
+### Transform to kebab-case
+
+```typescript
+import { toKebabCase } from 'komoji';
+
+toKebabCase('helloWorld');        // hello-world
+toKebabCase('UserName');          // user-name
+toKebabCase('api_response_data'); // api-response-data
+toKebabCase('myComponentV2');     // my-component-v2
+toKebabCase('HTTPSConnection');   // https-connection
+```
+
+### Transform to CONSTANT_CASE
+
+```typescript
+import { toConstantCase } from 'komoji';
+
+toConstantCase('helloWorld');        // HELLO_WORLD
+toConstantCase('UserName');          // USER_NAME
+toConstantCase('api-response-data'); // API_RESPONSE_DATA
+toConstantCase('myComponentV2');     // MY_COMPONENT_V2
+toConstantCase('HTTPSConnection');   // HTTPS_CONNECTION
+```
+
 ### Validate Identifiers
 
 ```typescript
@@ -79,25 +115,41 @@ isValidIdentifierCamelized('-invalid'); // false (starts with hyphen)
 
 ## API
 
-### `toPascalCase(str: string): string`
+### Case Transformation Functions
+
+#### `toPascalCase(str: string): string`
 
 Converts a string to PascalCase by capitalizing the first letter of each word and removing separators.
 
 **Supported separators:** hyphens (`-`), underscores (`_`), spaces (` `)
 
-### `toCamelCase(key: string, stripLeadingNonAlphabetChars?: boolean): string`
+#### `toCamelCase(key: string, stripLeadingNonAlphabetChars?: boolean): string`
 
 Converts a string to camelCase with an optional flag to strip leading non-alphabetic characters.
 
 **Parameters:**
 - `key` - The string to transform
 - `stripLeadingNonAlphabetChars` - Remove leading non-alphabetic characters (default: `false`)
 
-### `isValidIdentifier(key: string): boolean`
+#### `toSnakeCase(str: string): string`
+
+Converts a string to snake_case. Handles camelCase, PascalCase, kebab-case, and space-separated strings. Properly inserts underscores between words and before numbers.
+
+#### `toKebabCase(str: string): string`
+
+Converts a string to kebab-case. Handles camelCase, PascalCase, snake_case, and space-separated strings. Properly inserts hyphens between words and before numbers.
+
+#### `toConstantCase(str: string): string`
+
+Converts a string to CONSTANT_CASE (also known as SCREAMING_SNAKE_CASE). Perfect for environment variables and constants. Handles all common case formats and properly separates words and numbers.
+
+### Validation Functions
+
+#### `isValidIdentifier(key: string): boolean`
 
 Checks if a string is a valid JavaScript identifier (follows standard naming rules).
 
-### `isValidIdentifierCamelized(key: string): boolean`
+#### `isValidIdentifierCamelized(key: string): boolean`
 
 Checks if a string can be transformed into a valid JavaScript identifier (allows internal hyphens that will be removed during camelization).
 

packages/komoji/__tests__/casing.test.ts

@@ -3,6 +3,9 @@ import {
   isValidIdentifierCamelized,
   toCamelCase,
   toPascalCase,
+  toSnakeCase,
+  toKebabCase,
+  toConstantCase,
 } from '../src';
 
 it('should convert strings to PascalCase', () => {
@@ -95,3 +98,145 @@ describe('toCamelCase', () => {
     expect(toCamelCase('hello___world--great')).toBe('helloWorldGreat');
   });
 });
+
+describe('toSnakeCase', () => {
+  test('converts camelCase to snake_case', () => {
+    expect(toSnakeCase('helloWorld')).toBe('hello_world');
+  });
+
+  test('converts PascalCase to snake_case', () => {
+    expect(toSnakeCase('HelloWorld')).toBe('hello_world');
+  });
+
+  test('converts kebab-case to snake_case', () => {
+    expect(toSnakeCase('hello-world')).toBe('hello_world');
+  });
+
+  test('converts space separated to snake_case', () => {
+    expect(toSnakeCase('hello world')).toBe('hello_world');
+  });
+
+  test('handles mixed case with numbers', () => {
+    expect(toSnakeCase('version2APIKey')).toBe('version_2_api_key');
+  });
+
+  test('handles already snake_case strings', () => {
+    expect(toSnakeCase('hello_world')).toBe('hello_world');
+  });
+
+  test('handles multiple separators together', () => {
+    expect(toSnakeCase('hello___world--great')).toBe('hello_world_great');
+  });
+
+  test('handles empty string', () => {
+    expect(toSnakeCase('')).toBe('');
+  });
+
+  test('removes leading and trailing underscores', () => {
+    expect(toSnakeCase('_hello_world_')).toBe('hello_world');
+  });
+
+  test('handles single word', () => {
+    expect(toSnakeCase('hello')).toBe('hello');
+  });
+
+  test('handles consecutive capitals', () => {
+    expect(toSnakeCase('HTTPSConnection')).toBe('https_connection');
+  });
+});
+
+describe('toKebabCase', () => {
+  test('converts camelCase to kebab-case', () => {
+    expect(toKebabCase('helloWorld')).toBe('hello-world');
+  });
+
+  test('converts PascalCase to kebab-case', () => {
+    expect(toKebabCase('HelloWorld')).toBe('hello-world');
+  });
+
+  test('converts snake_case to kebab-case', () => {
+    expect(toKebabCase('hello_world')).toBe('hello-world');
+  });
+
+  test('converts space separated to kebab-case', () => {
+    expect(toKebabCase('hello world')).toBe('hello-world');
+  });
+
+  test('handles mixed case with numbers', () => {
+    expect(toKebabCase('version2APIKey')).toBe('version-2-api-key');
+  });
+
+  test('handles already kebab-case strings', () => {
+    expect(toKebabCase('hello-world')).toBe('hello-world');
+  });
+
+  test('handles multiple separators together', () => {
+    expect(toKebabCase('hello___world--great')).toBe('hello-world-great');
+  });
+
+  test('handles empty string', () => {
+    expect(toKebabCase('')).toBe('');
+  });
+
+  test('removes leading and trailing hyphens', () => {
+    expect(toKebabCase('-hello-world-')).toBe('hello-world');
+  });
+
+  test('handles single word', () => {
+    expect(toKebabCase('hello')).toBe('hello');
+  });
+
+  test('handles consecutive capitals', () => {
+    expect(toKebabCase('HTTPSConnection')).toBe('https-connection');
+  });
+});
+
+describe('toConstantCase', () => {
+  test('converts camelCase to CONSTANT_CASE', () => {
+    expect(toConstantCase('helloWorld')).toBe('HELLO_WORLD');
+  });
+
+  test('converts PascalCase to CONSTANT_CASE', () => {
+    expect(toConstantCase('HelloWorld')).toBe('HELLO_WORLD');
+  });
+
+  test('converts kebab-case to CONSTANT_CASE', () => {
+    expect(toConstantCase('hello-world')).toBe('HELLO_WORLD');
+  });
+
+  test('converts snake_case to CONSTANT_CASE', () => {
+    expect(toConstantCase('hello_world')).toBe('HELLO_WORLD');
+  });
+
+  test('converts space separated to CONSTANT_CASE', () => {
+    expect(toConstantCase('hello world')).toBe('HELLO_WORLD');
+  });
+
+  test('handles mixed case with numbers', () => {
+    expect(toConstantCase('version2APIKey')).toBe('VERSION_2_API_KEY');
+  });
+
+  test('handles already CONSTANT_CASE strings', () => {
+    expect(toConstantCase('HELLO_WORLD')).toBe('HELLO_WORLD');
+  });
+
+  test('handles multiple separators together', () => {
+    expect(toConstantCase('hello___world--great')).toBe('HELLO_WORLD_GREAT');
+  });
+
+  test('handles empty string', () => {
+    expect(toConstantCase('')).toBe('');
+  });
+
+  test('removes leading and trailing underscores', () => {
+    expect(toConstantCase('_hello_world_')).toBe('HELLO_WORLD');
+  });
+
+  test('handles single word', () => {
+    expect(toConstantCase('hello')).toBe('HELLO');
+  });
+
+  test('handles consecutive capitals', () => {
+    expect(toConstantCase('HTTPSConnection')).toBe('HTTPS_CONNECTION');
+  });
+});

packages/komoji/src/index.ts

@@ -34,3 +34,57 @@ export function isValidIdentifierCamelized(key: string) {
     !/^-/.test(key)
   );
 }
+
+export function toSnakeCase(str: string) {
+  return str
+    // Insert an underscore before the last capital in a sequence of capitals followed by a lowercase letter
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+    // Insert an underscore between lower and upper case letters
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    // Insert an underscore between letters and numbers
+    .replace(/([a-zA-Z])(\d)/g, '$1_$2')
+    .replace(/(\d)([a-zA-Z])/g, '$1_$2')
+    // Replace spaces, hyphens, and existing underscores with single underscore
+    .replace(/[\s-]+/g, '_')
+    // Remove multiple consecutive underscores
+    .replace(/_+/g, '_')
+    // Remove leading/trailing underscores and convert to lowercase
+    .replace(/^_+|_+$/g, '')
+    .toLowerCase();
+}
+
+export function toKebabCase(str: string) {
+  return str
+    // Insert a hyphen before the last capital in a sequence of capitals followed by a lowercase letter
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+    // Insert a hyphen between lower and upper case letters
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    // Insert a hyphen between letters and numbers
+    .replace(/([a-zA-Z])(\d)/g, '$1-$2')
+    .replace(/(\d)([a-zA-Z])/g, '$1-$2')
+    // Replace spaces, underscores, and existing hyphens with single hyphen
+    .replace(/[\s_]+/g, '-')
+    // Remove multiple consecutive hyphens
+    .replace(/-+/g, '-')
+    // Remove leading/trailing hyphens and convert to lowercase
+    .replace(/^-+|-+$/g, '')
+    .toLowerCase();
+}
+
+export function toConstantCase(str: string) {
+  return str
+    // Insert an underscore before the last capital in a sequence of capitals followed by a lowercase letter
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+    // Insert an underscore between lower and upper case letters
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    // Insert an underscore between letters and numbers
+    .replace(/([a-zA-Z])(\d)/g, '$1_$2')
+    .replace(/(\d)([a-zA-Z])/g, '$1_$2')
+    // Replace spaces, hyphens, and existing underscores with single underscore
+    .replace(/[\s-]+/g, '_')
+    // Remove multiple consecutive underscores
+    .replace(/_+/g, '_')
+    // Remove leading/trailing underscores and convert to uppercase
+    .replace(/^_+|_+$/g, '')
+    .toUpperCase();
+}