fix(current): fix current() type and castMutable() APIs

src/current.ts

@@ -1,4 +1,4 @@
-import { DraftType, ProxyDraft } from './interface';
+import { type Draft, DraftType, type ProxyDraft } from './interface';
 import {
   forEach,
   get,
@@ -70,8 +70,8 @@ function getCurrent(target: any) {
       type === DraftType.Map
         ? new Map(target)
         : type === DraftType.Set
-        ? Array.from(proxyDraft!.setMap!.values()!)
-        : shallowCopy(target, proxyDraft?.options);
+          ? Array.from(proxyDraft!.setMap!.values()!)
+          : shallowCopy(target, proxyDraft?.options);
   }
 
   if (proxyDraft) {
@@ -117,7 +117,10 @@ function getCurrent(target: any) {
  * );
  * ```
  */
-export function current<T extends object>(target: T): T {
+export function current<T extends object>(target: Draft<T>): T;
+/** @deprecated You should call current only on `Draft<T>` types. */
+export function current<T extends object>(target: T): T;
+export function current<T extends object>(target: T | Draft<T>): T {
   if (!isDraft(target)) {
     throw new Error(`current() is only used for Draft, parameter: ${target}`);
   }

src/index.ts

@@ -9,7 +9,7 @@ export { isDraft } from './utils/draft';
 export { isDraftable } from './utils/draft';
 export { markSimpleObject } from './utils/marker';
 
-export { castDraft, castImmutable } from './utils/cast';
+export { castDraft, castImmutable, castMutable } from './utils/cast';
 export type {
   Immutable,
   Draft,

src/utils/cast.ts

@@ -13,3 +13,10 @@ export function castDraft<T>(value: T): Draft<T> {
 export function castImmutable<T>(value: T): Immutable<T> {
   return value as any;
 }
+
+/**
+ * Cast a value to an Mutable type value.
+ */
+export function castMutable<T>(draft: Draft<T>): T {
+  return draft as any;
+}

test/current.test.ts

@@ -306,3 +306,13 @@ test('nested create() - Avoid deep copies', () => {
     });
   });
 });
+
+
+test('#61 - type issue: current of Draft<T> type should return T type', () => {
+  function test<T extends { x: { y: ReadonlySet<string> } }>(base: T): T {
+    const [draft] = create(base);
+    const currentValue0 = current(draft); // Type Draft<T> is assignable to type T
+    const currentValue1: T = current(base); // T is assignable to type T
+    return currentValue0;
+  }
+});

test/immer-non-support.test.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable no-inner-declarations */
 /* eslint-disable symbol-description */
 /* eslint-disable no-unused-expressions */
@@ -15,6 +16,8 @@ import {
   applyPatches,
   setUseStrictShallowCopy,
   current as immerCurrent,
+  createDraft,
+  finishDraft,
 } from 'immer';
 import { create, apply, current } from '../src';
 
@@ -589,3 +592,28 @@ test('#47 Avoid deep copies', () => {
     });
   }
 });
+
+test('#61 - type issue: current of Draft<T> type should return T type', () => {
+  {
+    function test<T extends { x: { y: ReadonlySet<string> } }>(base: T): T {
+      const draft = createDraft(base);
+      // @ts-ignore
+      const currentValue: T = immerCurrent(draft); // !!! Type Draft<T> is not assignable to type T
+      // @ts-expect-error
+      return finishDraft(draft);
+    }
+    expect(test({ x: { y: new Set(['a', 'b']) } })).toEqual({
+      x: { y: new Set(['a', 'b']) },
+    });
+  }
+  {
+    function test<T extends { x: { y: ReadonlySet<string> } }>(base: T): T {
+      const [draft, f] = create(base);
+      const currentValue: T = current(draft);
+      return f();
+    }
+    expect(test({ x: { y: new Set(['a', 'b']) } })).toEqual({
+      x: { y: new Set(['a', 'b']) },
+    });
+  }
+});

test/index.test.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable prefer-template */
 /* eslint-disable no-unused-expressions */
 /* eslint-disable arrow-body-style */
@@ -14,6 +15,7 @@ import {
   markSimpleObject,
   rawReturn,
   makeCreator,
+  castMutable,
 } from '../src';
 import { PROXY_DRAFT } from '../src/constant';
 
@@ -4083,3 +4085,21 @@ test('#59 - Failure to apply inverse patchset(Map)', () => {
   const reverted2 = apply(myObj, patchset);
   expect(reverted2).toEqual(newState);
 });
+
+test('#61 - type issue: current of Draft<T> type should return T type', () => {
+  function test<T extends { x: { y: ReadonlySet<string> } }>(base: T): T {
+    const [draft, f] = create(base);
+    const mutableValue: T = castMutable(draft);
+    const currentValue: T = current(draft);
+    expect(() => {
+      // @ts-expect-error
+      const value = current({ x: { y: new Set(['a', 'b']) } } as T);
+    }).toThrowErrorMatchingInlineSnapshot(
+      `"current() is only used for Draft, parameter: [object Object]"`
+    );
+    return f();
+  }
+  expect(test({ x: { y: new Set(['a', 'b']) } })).toEqual({
+    x: { y: new Set(['a', 'b']) },
+  });
+});