fix(utils): refactor tests

Author: BioPhoton

packages/utils/src/lib/case-conversion.type.test.ts

@@ -0,0 +1,63 @@
+import { assertType, describe, expectTypeOf, it } from 'vitest';
+import type { CamelCaseToKebabCase, KebabCaseToCamelCase } from './types.js';
+
+/* eslint-disable vitest/expect-expect */
+describe('CamelCaseToKebabCase', () => {
+  // ✅ CamelCase → kebab-case Type Tests
+
+  it('CamelCaseToKebabCase works correctly', () => {
+    expectTypeOf<
+      CamelCaseToKebabCase<'myTestString'>
+    >().toEqualTypeOf<'my-test-string'>();
+    expectTypeOf<
+      CamelCaseToKebabCase<'APIResponse'>
+    >().toEqualTypeOf<'a-p-i-response'>();
+    expectTypeOf<
+      CamelCaseToKebabCase<'myXMLParser'>
+    >().toEqualTypeOf<'my-x-m-l-parser'>();
+    expectTypeOf<
+      CamelCaseToKebabCase<'singleWord'>
+    >().toEqualTypeOf<'single-word'>();
+
+    // @ts-expect-error Ensures that non-camelCase strings do not pass
+    assertType<CamelCaseToKebabCase<'hello_world'>>();
+
+    // @ts-expect-error Numbers should not be transformed
+    assertType<CamelCaseToKebabCase<'version2Release'>>();
+  });
+
+  // ✅ kebab-case → CamelCase Type Tests
+  it('KebabCaseToCamelCase works correctly', () => {
+    expectTypeOf<
+      KebabCaseToCamelCase<'my-test-string'>
+    >().toEqualTypeOf<'myTestString'>();
+    expectTypeOf<
+      KebabCaseToCamelCase<'a-p-i-response'>
+    >().toEqualTypeOf<'aPIResponse'>();
+    expectTypeOf<
+      KebabCaseToCamelCase<'my-x-m-l-parser'>
+    >().toEqualTypeOf<'myXMLParser'>();
+    expectTypeOf<
+      KebabCaseToCamelCase<'single-word'>
+    >().toEqualTypeOf<'singleWord'>();
+
+    // @ts-expect-error Ensures that non-kebab-case inputs are not accepted
+    assertType<KebabCaseToCamelCase<'my Test String'>>();
+
+    // @ts-expect-error Numbers should not be transformed
+    assertType<KebabCaseToCamelCase<'version-2-release'>>();
+  });
+
+  // ✅ Edge Cases
+  it('Edge cases for case conversions', () => {
+    expectTypeOf<CamelCaseToKebabCase<''>>().toEqualTypeOf<''>();
+    expectTypeOf<KebabCaseToCamelCase<''>>().toEqualTypeOf<''>();
+
+    // @ts-expect-error Ensures no spaces allowed in input
+    assertType<CamelCaseToKebabCase<'this is not camelCase'>>();
+
+    // @ts-expect-error Ensures no mixed case with dashes
+    assertType<KebabCaseToCamelCase<'this-Is-Wrong'>>();
+  });
+});
+/* eslint-enable vitest/expect-expect */

packages/utils/src/lib/case-conversions.ts

@@ -16,17 +16,15 @@ export function kebabCaseToCamelCase<T extends string>(
 
 /**
  * Converts a camelCase string to kebab-case.
- * @param string - The camelCase string to convert.
+ * @param input - The camelCase string to convert.
  * @returns The kebab-case string.
  */
 export function camelCaseToKebabCase<T extends string>(
-  string: T,
+  input: T,
 ): CamelCaseToKebabCase<T> {
-  return string
-    .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2') // Split between uppercase followed by uppercase+lowercase
-    .replace(/([a-z])([A-Z])/g, '$1-$2') // Split between lowercase followed by uppercase
-    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2') // Additional split for consecutive uppercase
-    .replace(/[\s_]+/g, '-') // Replace spaces and underscores with hyphens
+  return input
+    .replace(/([a-z])([A-Z])/g, '$1-$2') // Insert dash before uppercase letters
+    .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2') // Handle consecutive uppercase letters
     .toLowerCase() as CamelCaseToKebabCase<T>;
 }
 

packages/utils/src/lib/case-conversions.unit.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import {
   camelCaseToKebabCase,
   capitalize,
@@ -50,30 +50,28 @@ describe('kebabCaseToCamelCase', () => {
 });
 
 describe('camelCaseToKebabCase', () => {
-  it('should convert simple camelCase to kebab-case', () => {
-    expect(camelCaseToKebabCase('helloWorld')).toBe('hello-world');
+  it('should convert camelCase to kebab-case', () => {
+    expect(camelCaseToKebabCase('myTestString')).toBe('my-test-string');
   });
 
-  it('should handle multiple capital letters', () => {
-    expect(camelCaseToKebabCase('thisIsALongString')).toBe(
-      'this-is-a-long-string',
-    );
+  it('should handle acronyms properly', () => {
+    expect(camelCaseToKebabCase('APIResponse')).toBe('api-response');
   });
 
-  it('should handle consecutive capital letters', () => {
+  it('should handle consecutive uppercase letters correctly', () => {
     expect(camelCaseToKebabCase('myXMLParser')).toBe('my-xml-parser');
   });
 
-  it('should handle spaces and underscores', () => {
-    expect(camelCaseToKebabCase('hello_world test')).toBe('hello-world-test');
+  it('should handle single-word camelCase', () => {
+    expect(camelCaseToKebabCase('singleWord')).toBe('single-word');
   });
 
-  it('should handle single word', () => {
-    expect(camelCaseToKebabCase('hello')).toBe('hello');
+  it('should not modify already kebab-case strings', () => {
+    expect(camelCaseToKebabCase('already-kebab')).toBe('already-kebab');
   });
 
-  it('should handle empty string', () => {
-    expect(camelCaseToKebabCase('')).toBe('');
+  it('should not modify non-camelCase inputs', () => {
+    expect(camelCaseToKebabCase('not_camelCase')).toBe('not_camel-case');
   });
 });