fix(current()): add getCurrent() and castMutable() APIs

src/current.ts

@@ -1,4 +1,4 @@
-import { DraftType, ProxyDraft } from './interface';
+import { DraftType, type Draft, type ProxyDraft } from './interface';
 import {
   forEach,
   get,
@@ -59,7 +59,7 @@ export function handleReturnValue<T extends object>(options: {
   }
 }
 
-function getCurrent(target: any) {
+function getCurrentValue(target: any) {
   const proxyDraft = getProxyDraft(target);
   if (!isDraftable(target, proxyDraft?.options)) return target;
   const type = getType(target);
@@ -90,7 +90,7 @@ function getCurrent(target: any) {
 
   forEach(currentValue, (key, value) => {
     if (proxyDraft && isEqual(get(proxyDraft.original, key), value)) return;
-    const newValue = getCurrent(value);
+    const newValue = getCurrentValue(value);
     if (newValue !== value) {
       if (currentValue === target) ensureShallowCopy();
       set(currentValue, key, newValue);
@@ -121,5 +121,30 @@ export function current<T extends object>(target: T): T {
   if (!isDraft(target)) {
     throw new Error(`current() is only used for Draft, parameter: ${target}`);
   }
-  return getCurrent(target);
+  return getCurrentValue(target);
+}
+
+/**
+ * `getCurrent(draft)` to get current state in the draft mutation function.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { create, getCurrent } from '../index';
+ *
+ * const baseState = { foo: { bar: 'str' }, arr: [] };
+ * const state = create(
+ *   baseState,
+ *   (draft) => {
+ *     draft.foo.bar = 'str2';
+ *     expect(getCurrent(draft.foo)).toEqual({ bar: 'str2' });
+ *   },
+ * );
+ * ```
+ */
+export function getCurrent<T extends object>(target: Draft<T>): T {
+  if (!isDraft(target)) {
+    throw new Error(`current() is only used for Draft, parameter: ${target}`);
+  }
+  return getCurrentValue(target);
 }

src/index.ts

@@ -2,14 +2,14 @@ export { makeCreator } from './makeCreator';
 export { create } from './create';
 export { apply } from './apply';
 export { original } from './original';
-export { current } from './current';
+export { current, getCurrent } from './current';
 export { unsafe } from './unsafe';
 export { rawReturn } from './rawReturn';
 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/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,8 +16,10 @@ import {
   applyPatches,
   setUseStrictShallowCopy,
   current as immerCurrent,
+  createDraft,
+  finishDraft,
 } from 'immer';
-import { create, apply, current } from '../src';
+import { create, apply, current, getCurrent } from '../src';
 
 enableMapSet();
 
@@ -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 = getCurrent(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,8 @@ import {
   markSimpleObject,
   rawReturn,
   makeCreator,
+  getCurrent,
+  castMutable,
 } from '../src';
 import { PROXY_DRAFT } from '../src/constant';
 
@@ -4083,3 +4086,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 = getCurrent(draft);
+    expect(() => {
+      // @ts-expect-error
+      const value = getCurrent({ 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']) },
+  });
+});