deep-case-crafter 0.0.5 → 1.0.0

package/dist/transform/transform.d.ts

@@ -6,6 +6,15 @@ declare function transform<T, From extends StringCase, To extends StringCase>(da
     sourceCase: From;
     targetCase: To;
 }): TransformRecursive<T, From, To>;
+/**
+ * Transform data to a specified output type.
+ *
+ * Note: When using this overload, type safety is not enforced between the input, options, and output type.
+ * The 'sourceCase' option is intentionally omitted, as it is not used for type inference here.
+ */
+declare function transform<T, K>(data: T, options?: Omit<TransformOptions, 'sourceCase'> & {
+    depth?: number;
+}): K;
 declare function transform<T>(data: T, options?: TransformOptions & {
     depth?: number;
 }): unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deep-case-crafter",
-  "version": "0.0.5",
+  "version": "1.0.0",
   "description": "Transforms deeply nested object, array, Map, and Set keys between common case formats while preserving TypeScript type safety",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",

package/readme.md

@@ -139,6 +139,27 @@ console.log(result); // Set { 'userId', 'firstName' }
 
 ---
 
+## 🧑‍💻 Advanced: Explicit Output Type Overload
+
+If you want to specify the output type explicitly (for example, when you know the exact shape you want), you can use the following overload:
+
+```typescript
+const result = transform<Input, Output>(obj, { targetCase: 'camel' });
+const typedResult: Output = result; // TypeScript will enforce Output type here
+```
+
+**Note:**
+- When using this overload, you cannot pass `sourceCase` in the options. If you do, TypeScript will show an error:
+  > Object literal may only specify known properties, and 'sourceCase' does not exist in type 'Omit<TransformOptions, "sourceCase"> & { depth?: number }'.
+- This overload is useful when you want to take full control of the output type, but type safety between input, options, and output is not enforced by the library.
+- If you want to use `sourceCase` and benefit from type inference, use the standard overload:
+
+```typescript
+const result = transform(obj, { targetCase: 'camel', sourceCase: 'snake' }); // Output type is inferred
+```
+
+---
+
 ## 🚨 Key Preservation Rules
 
 - **Keys that start with special characters or numbers** are **not transformed**.