@jahands/dagger-helpers 0.7.3 → 0.7.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jahands/dagger-helpers",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "private": false,
   "description": "dagger.io helpers for my own projects - not meant for public use",
   "keywords": [
@@ -32,7 +32,8 @@
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "devDependencies": {
     "@types/node": "22.15.27",
@@ -40,12 +41,12 @@
     "ts-pattern": "5.8.0",
     "typescript": "5.8.2",
     "vitest": "3.2.4",
-    "@repo/typescript-config": "0.3.8",
-    "@repo/eslint-config": "0.2.2",
-    "@repo/tools": "0.12.1"
+    "@repo/eslint-config": "0.2.3",
+    "@repo/tools": "0.12.3",
+    "@repo/typescript-config": "0.3.10"
   },
   "peerDependencies": {
-    "@dagger.io/dagger": "^0.18.4"
+    "@dagger.io/dagger": "^0.21.6"
   },
   "publishConfig": {
     "access": "public"

package/src/constants.spec.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest'
+
+import { constants } from './constants.js'
+
+describe('constants', () => {
+	describe('workersMonorepo', () => {
+		describe('ignore', () => {
+			it('contains no duplicates', () => {
+				const list = constants.workersMonorepo.ignore
+				list.sort()
+				const unique = Array.from(new Set(list))
+				expect(unique).toStrictEqual(list)
+			})
+		})
+	})
+})

package/src/constants.ts

@@ -0,0 +1,21 @@
+/** various constants for dagger modules in my repos */
+export const constants = {
+	/** constants for workers-monorepo */
+	workersMonorepo: {
+		/** default source ignore list */
+		ignore: [
+			'**/node_modules/',
+			'**/.env',
+			'**/.secret',
+			'**/.wrangler',
+			'**/.dev.vars',
+			'**/.turbo/',
+			'**/dist/',
+			'**/dist2/',
+			'**/.DS_Store',
+			'**/.astro/',
+			'**/.next/',
+			'*.env',
+		] satisfies string[],
+	},
+} as const

package/src/convert/camel-to-snake.spec.ts

@@ -0,0 +1,244 @@
+import { describe, expect, it, test } from 'vitest'
+
+import { camelToSnake, convertToSnake } from './camel-to-snake.js'
+
+// --- Tests for camelToSnake ---
+describe('camelToSnake', () => {
+	test.each([
+		// Basic camelCase
+		{ input: 'helloWorld', expected: 'HELLO_WORLD' },
+		{ input: 'someValue', expected: 'SOME_VALUE' },
+		{ input: 'userId', expected: 'USER_ID' },
+
+		// PascalCase
+		{ input: 'HelloWorld', expected: 'HELLO_WORLD' },
+		{ input: 'SomeValue', expected: 'SOME_VALUE' },
+		{ input: 'UserId', expected: 'USER_ID' },
+
+		// Acronyms
+		{ input: 'someAPIKey', expected: 'SOME_API_KEY' },
+		{ input: 'someApiKey', expected: 'SOME_API_KEY' },
+		{ input: 'getHTTPResponseCode', expected: 'GET_HTTP_RESPONSE_CODE' },
+		{ input: 'parseURL', expected: 'PARSE_URL' },
+		{ input: 'URLParser', expected: 'URL_PARSER' }, // Acronym at start
+
+		// Numbers
+		{ input: 'version10', expected: 'VERSION_10' },
+		{ input: 'version10Alpha', expected: 'VERSION_10_ALPHA' },
+		{ input: 'apiV2Client', expected: 'API_V2_CLIENT' },
+		{ input: 'releaseV10', expected: 'RELEASE_V10' },
+
+		// Single words
+		{ input: 'word', expected: 'WORD' },
+		{ input: 'token', expected: 'TOKEN' },
+		{ input: 'Word', expected: 'WORD' }, // Single PascalCase word
+		{ input: 'TOKEN', expected: 'TOKEN' }, // Already uppercase
+
+		// Already snake_case (should just uppercase)
+		{ input: 'hello_world', expected: 'HELLO_WORLD' },
+		{ input: 'some_api_key', expected: 'SOME_API_KEY' },
+
+		// Edge cases
+		{ input: '', expected: '' },
+		{ input: 'a', expected: 'A' },
+		{ input: 'A', expected: 'A' },
+		{ input: '1', expected: '1' }, // Single number
+		{ input: 'v1', expected: 'V_1' },
+		{ input: 'v', expected: 'V' },
+		// Note: Behavior for leading/trailing underscores in input is not explicitly defined,
+		// the current regexes might produce slightly unexpected results like '__FOO' -> '__FOO'.
+		// Add specific tests if that behavior needs to be strictly defined.
+	])('should convert "$input" to "$expected"', ({ input, expected }) => {
+		expect(camelToSnake(input)).toBe(expected)
+	})
+})
+
+// --- Tests for convertToSnake ---
+describe('convertToSnake', () => {
+	it('should convert keys of a basic camelCase object', () => {
+		const input = {
+			firstName: 'Jane',
+			lastName: 'Doe',
+			userId: 456,
+		}
+		const expected = {
+			FIRST_NAME: 'Jane',
+			LAST_NAME: 'Doe',
+			USER_ID: 456,
+		}
+		expect(convertToSnake(input)).toEqual(expected)
+	})
+
+	it('should convert keys of a basic PascalCase object', () => {
+		const input = {
+			FirstName: 'Jane',
+			LastName: 'Doe',
+			UserId: 456,
+		}
+		const expected = {
+			FIRST_NAME: 'Jane',
+			LAST_NAME: 'Doe',
+			USER_ID: 456,
+		}
+		expect(convertToSnake(input)).toEqual(expected)
+	})
+
+	it('should handle various value types correctly', () => {
+		const input = {
+			stringValue: 'test',
+			numberValue: 123,
+			booleanTrue: true,
+			nullValue: null,
+			undefinedValue: undefined,
+			arrayValue: [1, 'two', { nestedKey: true }], // nested keys are NOT converted
+			nestedObject: {
+				innerKey1: 'val1', // nested keys are NOT converted
+				innerKey2: false,
+			},
+		}
+		const expected = {
+			STRING_VALUE: 'test',
+			NUMBER_VALUE: 123,
+			BOOLEAN_TRUE: true,
+			NULL_VALUE: null,
+			UNDEFINED_VALUE: undefined,
+			ARRAY_VALUE: [1, 'two', { nestedKey: true }],
+			NESTED_OBJECT: {
+				innerKey1: 'val1',
+				innerKey2: false,
+			},
+		}
+		expect(convertToSnake(input)).toEqual(expected)
+	})
+
+	it('should return an empty object for an empty input object', () => {
+		const input = {}
+		const expected = {}
+		expect(convertToSnake(input)).toEqual(expected)
+	})
+
+	it('should handle keys with acronyms and numbers', () => {
+		const input = {
+			apiKey: 'abc',
+			httpStatusCode: 200,
+			version2Data: { id: 1 },
+			releaseV10: true,
+		}
+		const expected = {
+			API_KEY: 'abc',
+			HTTP_STATUS_CODE: 200,
+			VERSION_2_DATA: { id: 1 },
+			RELEASE_V10: true,
+		}
+		expect(convertToSnake(input)).toEqual(expected)
+	})
+
+	it('should handle keys that are already snake_case (lowercase or uppercase)', () => {
+		const input = {
+			already_snake: 'value1',
+			ALREADY_SNAKE: 'value2',
+			mixed_CASE_key: 'value3',
+		}
+		// const expected = {
+		// 	ALREADY_SNAKE: 'value1', // Becomes uppercase
+		// 	ALREADY_SNAKE: 'value2', // Stays uppercase
+		// 	MIXED_CASE_KEY: 'value3', // Becomes uppercase
+		// }
+		// Note: If input has keys that map to the same output key (like above), the last one wins.
+		// Test the final state:
+		const result = convertToSnake(input)
+		expect(result['ALREADY_SNAKE']).toBe('value2') // The second one overwrites the first
+		expect(result['MIXED_CASE_KEY']).toBe('value3')
+		expect(Object.keys(result).length).toBe(2) // Only two distinct keys remain
+	})
+
+	it('should not include properties from the prototype chain', () => {
+		const proto = { protoKey: 'protoValue' }
+		const input = Object.create(proto)
+		input.ownKey = 'ownValue'
+		input.anotherOwn = 'another'
+
+		const expected = {
+			OWN_KEY: 'ownValue',
+			ANOTHER_OWN: 'another',
+		}
+		const result = convertToSnake(input)
+		expect(result).toEqual(expected)
+		expect(result.PROTO_KEY).toBeUndefined() // Ensure proto property isn't present
+	})
+
+	it('should return a correctly typed object with specific SNAKE_CASE keys (compile-time check)', () => {
+		// Input object with various casing and types
+		const input = {
+			simpleKey: 'value1',
+			userID: 101,
+			dataPointValue: 99.9,
+			isActiveFlag: true,
+			addressDetails: { streetName: 'Maple Ave', zipCode: '90210' },
+			version2API: 'https://example.com/v2',
+			httpStatusCode: 200,
+		} as const // Use 'as const' for precise literal type inference
+
+		// Call the function - TypeScript infers the specific return type
+		const result = convertToSnake(input)
+
+		// --- Compile-Time Type Verification ---
+
+		// 1. Accessing correctly inferred keys works and has the correct type
+		const simple: 'value1' = result.SIMPLE_KEY
+		const user: 101 = result.USER_ID
+		const data: 99.9 = result.DATA_POINT_VALUE
+		const active: true = result.IS_ACTIVE_FLAG
+		const addr: { readonly streetName: 'Maple Ave'; readonly zipCode: '90210' } =
+			result.ADDRESS_DETAILS
+		const v2: 'https://example.com/v2' = result.VERSION_2_API
+		const status: 200 = result.HTTP_STATUS_CODE
+
+		// 2. Attempting to access original camelCase keys now causes a TS error
+		// @ts-expect-error Property 'simpleKey' does not exist on type '{...}'
+		const invalidAccess1 = result.simpleKey
+		// @ts-expect-error Property 'userID' does not exist on type '{...}'
+		const invalidAccess2 = result.userID
+		// @ts-expect-error Property 'addressDetails' does not exist on type '{...}'
+		const invalidAccess3 = result.addressDetails
+
+		// 3. Attempting to access a non-existent key also causes a TS error
+		// @ts-expect-error Property 'NON_EXISTENT_KEY' does not exist on type '{...}'
+		const invalidAccess4 = result.NON_EXISTENT_KEY
+
+		// 4. Assigning to an incorrect type causes a TS error
+		// @ts-expect-error Type '101' is not assignable to type 'string'.
+		const _wrongType: string = result.USER_ID
+
+		// --- Runtime Value Verification (Complementary) ---
+		// Ensure the actual values match the compile-time expectations
+		expect(simple).toBe('value1')
+		expect(user).toBe(101)
+		expect(data).toBe(99.9)
+		expect(active).toBe(true)
+		expect(addr.streetName).toBe('Maple Ave')
+		expect(v2).toBe('https://example.com/v2')
+		expect(status).toBe(200)
+
+		// Check the exact set of keys produced at runtime
+		expect(Object.keys(result).sort()).toStrictEqual(
+			[
+				'ADDRESS_DETAILS',
+				'DATA_POINT_VALUE',
+				'HTTP_STATUS_CODE',
+				'IS_ACTIVE_FLAG',
+				'SIMPLE_KEY',
+				'USER_ID',
+				'VERSION_2_API',
+			].sort()
+		)
+
+		// Runtime check that the invalid accesses actually yield undefined
+		expect(invalidAccess1).toBeUndefined()
+		expect(invalidAccess2).toBeUndefined()
+		expect(invalidAccess3).toBeUndefined()
+		expect(invalidAccess4).toBeUndefined()
+		// `wrongType` assignment doesn't affect runtime value of result.USER_ID
+		expect(result.USER_ID).toBe(101)
+	})
+})

package/src/convert/camel-to-snake.ts

@@ -0,0 +1,135 @@
+// Helper to check if a character is lowercase A-Z
+type IsLower<C extends string> =
+	Lowercase<C> extends Uppercase<C> ? false : C extends Lowercase<C> ? true : false
+// Helper to check if a character is uppercase A-Z
+type IsUpper<C extends string> =
+	Lowercase<C> extends Uppercase<C> ? false : C extends Uppercase<C> ? true : false
+// Helper to check if a character is a digit 0-9
+type IsDigit<C extends string> = C extends `${number}` ? true : false
+
+// Recursive inner helper for CamelToSnakeCase
+// PrevChar tracks the *previous* character from the original string
+type CamelToSnakeInner<S extends string, PrevChar extends string = ''> =
+	// Base case: If the input string S is empty, return an empty string.
+	S extends ''
+		? ''
+		: // Recursive step: If S has content...
+			S extends `${infer First}${infer Rest}`
+			? // --- Logic based on the 'First' character ---
+
+				// 1. Is 'First' an uppercase letter?
+				IsUpper<First> extends true
+				? // 1a. Was 'PrevChar' lowercase or a digit? (Requires underscore)
+					IsLower<PrevChar> extends true
+					? `_${Uppercase<First>}${CamelToSnakeInner<Rest, First>}`
+					: IsDigit<PrevChar> extends true
+						? `_${Uppercase<First>}${CamelToSnakeInner<Rest, First>}`
+						: // 1b. 'PrevChar' was uppercase, symbol, or start. Check for acronym ending.
+							Rest extends `${infer NextChar}${string}` // Look ahead
+							? IsLower<NextChar> extends true // Is the *next* char lowercase?
+								? `_${Uppercase<First>}${CamelToSnakeInner<Rest, First>}` // Yes (e.g., API_Key)
+								: `${Uppercase<First>}${CamelToSnakeInner<Rest, First>}` // No (e.g., HTTP)
+							: // 'First' is the last character or followed by non-lowercase.
+								`${Uppercase<First>}${CamelToSnakeInner<Rest, First>}`
+				: // 2. Is 'First' a digit? (Only checked if not uppercase)
+					IsDigit<First> extends true
+					? // 2a. Was 'PrevChar' a lowercase letter? (Requires underscore)
+						IsLower<PrevChar> extends true
+						? `_${First}${CamelToSnakeInner<Rest, First>}`
+						: // 'PrevChar' was not lowercase (digit, uppercase, symbol, start)
+							`${First}${CamelToSnakeInner<Rest, First>}`
+					: // 3. 'First' must be a lowercase letter or a symbol.
+						//    (Symbols are handled like lowercase here - no underscore needed before them)
+						`${Uppercase<First>}${CamelToSnakeInner<Rest, First>}` // Uppercase letter, append symbol directly
+			: // This case should technically not be reachable if S is not '', but included for completeness.
+				''
+
+/**
+ * Type helper to convert a camelCase/PascalCase string literal type
+ * to an UPPER_SNAKE_CASE string literal type. Handles common cases
+ * including transitions from lower to upper, letters to digits, and basic acronyms.
+ *
+ * Examples:
+ *   'userId' -> 'USER_ID'
+ *   'userName' -> 'USER_NAME'
+ *   'isActive' -> 'IS_ACTIVE'
+ *   'APIKey' -> 'API_KEY'
+ *   'version10' -> 'VERSION_10'
+ *   'apiV2Client' -> 'API_V2_CLIENT'
+ */
+type CamelToSnakeCase<S extends string> = S extends `${infer First}${infer Rest}`
+	? // Uppercase the very first character, then process the rest using the inner helper
+		`${Uppercase<First>}${CamelToSnakeInner<Rest, First>}`
+	: // Handle single character or empty string
+		Uppercase<S>
+
+/**
+ * Converts a camelCase or PascalCase string to UPPER_SNAKE_CASE.
+ * Handles acronyms and numbers within the string.
+ *
+ * **Examples:**
+ * ```
+ *   'helloWorld' -> 'HELLO_WORLD'
+ *   'HelloWorld' -> 'HELLO_WORLD'
+ *   'someAPIKey' -> 'SOME_API_KEY'
+ *   'getHttpResponseCode' -> 'GET_HTTP_RESPONSE_CODE'
+ *   'version10' -> 'VERSION_10' // Fixed
+ *   'version10Alpha' -> 'VERSION_10_ALPHA' // Fixed
+ *   'apiV2Client' -> 'API_V2_CLIENT'
+ *   'releaseV10' -> 'RELEASE_V10'
+ *   'version2Data' -> 'VERSION_2_DATA' // Fixed
+ *   'word' -> 'WORD'
+ *```
+ * @param str The input string in camelCase or PascalCase format.
+ * @returns The converted string in UPPER_SNAKE_CASE format.
+ */
+export function camelToSnake(str: string): string {
+	if (!str) {
+		return ''
+	}
+
+	// The sequence matters:
+	const result = str
+		// 1. Add _ before an uppercase letter that is followed by a lowercase letter,
+		//    but only if the uppercase letter is not the start of the string and
+		//    is preceded by another uppercase letter (handles acronyms like APIKey -> API_Key).
+		.replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+		// 2. Add _ before an uppercase letter that is preceded by a lowercase letter or a digit.
+		//    (handles helloWorld -> hello_World, version10Update -> version10_Update, apiV2Client -> api_V2Client)
+		.replace(/([a-z\d])([A-Z])/g, '$1_$2')
+		// 3. Add _ between a lowercase letter and a number.
+		//    (handles version10 -> version_10, but NOT V10 -> V_10 because V is uppercase)
+		.replace(/([a-z])(\d)/g, '$1_$2')
+
+	// Convert the entire result to uppercase
+	return result.toUpperCase()
+}
+
+/**
+ * Converts an object's keys from camelCase/PascalCase to UPPER_SNAKE_CASE.
+ * Provides compile-time type safety for the converted keys based on common patterns.
+ *
+ * @template T The type of the input object.
+ * @param input The object with camelCase/PascalCase keys.
+ * @returns A new object with the same values but UPPER_SNAKE_CASE keys,
+ *          with an inferred type reflecting the key transformation.
+ */
+export function convertToSnake<T extends Record<string, any>>(
+	input: T
+	// Apply the mapped type with key remapping using the type helper
+): { [K in keyof T as CamelToSnakeCase<K & string>]: T[K] } {
+	const output: any = {} // Initialize as 'any' or '{}'
+
+	for (const key in input) {
+		if (Object.prototype.hasOwnProperty.call(input, key)) {
+			const snakeCaseKey = camelToSnake(key) // Runtime conversion
+			output[snakeCaseKey] = input[key]
+		}
+	}
+
+	// Type assertion: We trust the runtime `camelToSnake` logic produces keys
+	// matching the structure defined by the `CamelToSnakeCase` type helper.
+	// This is needed because TS can't perfectly verify the runtime logic
+	// against the complex type-level logic for all possible inputs.
+	return output as { [K in keyof T as CamelToSnakeCase<K & string>]: T[K] }
+}

package/src/convert/snake-to-camel.spec.ts

@@ -0,0 +1,221 @@
+import { describe, expect, it, test } from 'vitest'
+
+import { convertToCamel, snakeToCamel } from './snake-to-camel.js'
+
+// --- Tests for snakeToCamel ---
+describe('snakeToCamel', () => {
+	// Test cases using test.each for various formats
+	test.each([
+		// Basic cases
+		{ input: 'HELLO_WORLD', expected: 'helloWorld' },
+		{ input: 'SOME_API_KEY', expected: 'someApiKey' },
+		{ input: 'USER_ID', expected: 'userId' },
+		{ input: 'REQUEST_URL_PATH', expected: 'requestUrlPath' },
+
+		// All caps single word
+		{ input: 'WORD', expected: 'word' },
+		{ input: 'TOKEN', expected: 'token' },
+
+		// Lowercase single word (should ideally remain lowercase, current logic lowercases first char)
+		{ input: 'word', expected: 'word' },
+		{ input: 'token', expected: 'token' },
+
+		// Already camelCase (should ideally remain camelCase, current logic lowercases first char)
+		{ input: 'helloWorld', expected: 'helloWorld' },
+		{ input: 'someApiKey', expected: 'someApiKey' },
+
+		// PascalCase (should convert to camelCase)
+		{ input: 'HelloWorld', expected: 'helloWorld' },
+		{ input: 'SomeApiKey', expected: 'someApiKey' },
+
+		// Leading underscores
+		{ input: '_LEADING_UNDERSCORE', expected: 'leadingUnderscore' },
+		{ input: '__DOUBLE_LEADING', expected: 'doubleLeading' },
+		{ input: '_word', expected: 'word' }, // Single word with leading underscore
+
+		// Trailing underscores
+		{ input: 'TRAILING_UNDERSCORE_', expected: 'trailingUnderscore' },
+		{ input: 'DOUBLE_TRAILING__', expected: 'doubleTrailing' },
+		{ input: 'word_', expected: 'word' }, // Single word with trailing underscore
+
+		// Consecutive underscores
+		{ input: 'DOUBLE__UNDERSCORE', expected: 'doubleUnderscore' },
+		{ input: 'TRIPLE___UNDERSCORE', expected: 'tripleUnderscore' },
+		{ input: 'LEADING___MIDDLE__TRAILING_', expected: 'leadingMiddleTrailing' },
+
+		// Mixed case input parts
+		{ input: 'Mixed_Case_Input', expected: 'mixedCaseInput' },
+		{ input: 'another_Mixed_CASE', expected: 'anotherMixedCase' },
+
+		// Keys with numbers
+		{ input: 'KEY_123', expected: 'key123' },
+		{ input: 'VERSION_1_0', expected: 'version10' },
+		{ input: 'API_V2_KEY', expected: 'apiV2Key' },
+		{ input: '123_STARTING_NUMBER', expected: '123StartingNumber' }, // Starts with number
+
+		// Edge cases
+		{ input: '', expected: '' }, // Empty string
+		{ input: '_', expected: '' }, // Single underscore
+		{ input: '__', expected: '' }, // Double underscore
+		{ input: '___', expected: '' }, // Triple underscore
+		{ input: '_A_', expected: 'a' }, // Underscores around single letter
+		{ input: 'A', expected: 'a' }, // Single uppercase letter
+		{ input: 'a', expected: 'a' }, // Single lowercase letter
+		{ input: '1', expected: '1' }, // Single number as string
+		{ input: '123', expected: '123' }, // Multiple numbers as string
+	])('should convert "$input" to "$expected"', ({ input, expected }) => {
+		expect(snakeToCamel(input)).toBe(expected)
+	})
+})
+
+// --- Tests for convertToCamel ---
+describe('convertToCamel', () => {
+	it('should convert keys of a basic object', () => {
+		const input = {
+			FIRST_NAME: 'John',
+			LAST_NAME: 'Doe',
+			USER_ID: 123,
+		}
+		const expected = {
+			firstName: 'John',
+			lastName: 'Doe',
+			userId: 123,
+		}
+		const result = convertToCamel(input)
+		expect(result).toStrictEqual(expected)
+		// Type check (compile time): result should have the correct inferred type
+		expect(result.firstName).toBe('John')
+		expect(result.userId).toBe(123)
+		// expect(result.FIRST_NAME).toBeUndefined(); // This would be a TS error
+	})
+
+	it('should handle various value types correctly', () => {
+		const input = {
+			STRING_VALUE: 'hello',
+			NUMBER_VALUE: 42,
+			BOOLEAN_TRUE: true,
+			BOOLEAN_FALSE: false,
+			NULL_VALUE: null,
+			UNDEFINED_VALUE: undefined,
+			ARRAY_VALUE: [1, 'two', { NESTED_KEY: true }],
+			NESTED_OBJECT: {
+				INNER_KEY_1: 'value1',
+				INNER_KEY_2: 99,
+			},
+		}
+		const expected = {
+			stringValue: 'hello',
+			numberValue: 42,
+			booleanTrue: true,
+			booleanFalse: false,
+			nullValue: null,
+			undefinedValue: undefined,
+			arrayValue: [1, 'two', { NESTED_KEY: true }], // Note: nested object keys are NOT converted
+			nestedObject: {
+				INNER_KEY_1: 'value1', // Note: nested object keys are NOT converted
+				INNER_KEY_2: 99,
+			},
+		}
+		const result = convertToCamel(input)
+		expect(result).toStrictEqual(expected)
+		// Check specific inferred types/values
+		expect(result.arrayValue).toEqual([1, 'two', { NESTED_KEY: true }])
+		expect(result.nestedObject.INNER_KEY_1).toBe('value1')
+		expect(result.nullValue).toBeNull()
+		expect(result.undefinedValue).toBeUndefined()
+	})
+
+	it('should return an empty object for an empty input object', () => {
+		const input = {}
+		const expected = {}
+		expect(convertToCamel(input)).toStrictEqual(expected)
+	})
+
+	it('should handle keys with leading/trailing/multiple underscores', () => {
+		const input = {
+			_LEADING_KEY: 'val1',
+			TRAILING_KEY_: 'val2',
+			DOUBLE__KEY: 'val3',
+			__BOTH__: 'val4',
+		}
+		const expected = {
+			leadingKey: 'val1',
+			trailingKey: 'val2',
+			doubleKey: 'val3',
+			both: 'val4',
+		}
+		const result = convertToCamel(input)
+		expect(result).toStrictEqual(expected)
+	})
+
+	it('should handle keys that are already camelCase or mixed', () => {
+		const input = {
+			alreadyCamel: 'value1',
+			PascalCaseKey: 'value2', // Will become pascalCaseKey
+			MIXED_key_STYLE: 'value3',
+		}
+		const expected = {
+			alreadyCamel: 'value1', // Stays camelCase as no underscores
+			pascalCaseKey: 'value2', // First letter lowercased
+			mixedKeyStyle: 'value3',
+		}
+		const result = convertToCamel(input)
+		expect(result).toStrictEqual(expected)
+	})
+
+	it('should handle keys with numbers', () => {
+		const input = {
+			KEY_1: 1,
+			KEY_2_PART: 2,
+			VERSION_10X: 'v10',
+			_1_START: 'start',
+		}
+		const expected = {
+			key1: 1,
+			key2Part: 2,
+			version10x: 'v10',
+			'1Start': 'start', // Note: snakeToCamel logic produces this
+		}
+		const result = convertToCamel(input)
+		expect(result).toStrictEqual(expected)
+	})
+
+	it('should not include properties from the prototype chain', () => {
+		const proto = { PROTO_KEY: 'protoValue' }
+		const input = Object.create(proto)
+		input.OWN_KEY = 'ownValue'
+		input.ANOTHER_OWN = 'another'
+
+		const expected = {
+			ownKey: 'ownValue',
+			anotherOwn: 'another',
+		}
+		const result = convertToCamel(input)
+		expect(result).toStrictEqual(expected)
+		// Ensure proto property isn't present (even in camelCase)
+		expect((result as any).protoKey).toBeUndefined()
+	})
+
+	it('should produce a correctly typed object (compile-time check)', () => {
+		const input = {
+			API_TOKEN: 'xyz',
+			USER_COUNT: 100,
+		} as const // Use 'as const' for more precise type inference if needed
+
+		const result = convertToCamel(input)
+
+		// These lines check the type inference at compile time.
+		// If you hover over `result` or try to access invalid properties,
+		// TypeScript/your IDE should show the correct inferred type/errors.
+		const token: string = result.apiToken
+		const count: number = result.userCount
+
+		expect(token).toBe('xyz')
+		expect(count).toBe(100)
+
+		// @ts-expect-error
+		const _invalid: string = result.API_TOKEN
+		// @ts-expect-error
+		const _nonExistent: number = result.someOtherKey
+	})
+})