refactor(draft): export isDraftable()

Author: unadlib

README.md

@@ -157,7 +157,7 @@ In this basic example, the changes to the draft are 'mutative' within the draft
   > Enable autoFreeze, and return frozen state.
 
 - mark - `(target) => ('mutable'|'immutable'|function)`
-  > Set a mark to determine if the object is mutable or if an instance is an immutable, and it can also return a shallow copy function(AutoFreeze and Patches should both be disabled).
+  > Set a mark to determine if the value is mutable or if an instance is an immutable, and it can also return a shallow copy function(AutoFreeze and Patches should both be disabled).
 
 #### `create()` - Currying
 
@@ -283,6 +283,21 @@ const state = create(baseState, (draft) => {
   expect(isDraft(draft.list)).toBeTruthy();
 });
 ```
+### `isDraftable()`
+
+Check if a value is draftable
+
+```ts
+const baseState = {
+  date: new Date(),
+  list: [{ text: 'todo' }],
+};
+
+expect(isDraftable(baseState.date)).toBeFalsy();
+expect(isDraftable(baseState.list)).toBeTruthy();
+```
+
+> You can set a mark to determine if the value is draftable, and the mark function should be the same as passing in `create()` mark option.
 
 ### `safeReturn()`
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "mutative",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "A JavaScript library for efficient creation of immutable state",
   "main": "dist/index.js",
   "module": "dist/mutative.esm.js",

src/index.ts

@@ -5,6 +5,7 @@ export { current } from './current';
 export { unsafe } from './unsafe';
 export { safeReturn } from './safeReturn';
 export { isDraft } from './utils/draft';
+export { isDraftable } from './utils/draft';
 
 export { castDraft, castImmutable } from './utils/cast';
 export type { Immutable, Draft, Patches, Patch, Options } from './interface';

src/utils/draft.ts

@@ -1,4 +1,4 @@
-import { DraftType, Options, ProxyDraft } from '../interface';
+import { DraftType, Mark, ProxyDraft } from '../interface';
 import { dataTypes, PROXY_DRAFT } from '../constant';
 
 export function latest<T = any>(proxyDraft: ProxyDraft): T {
@@ -22,7 +22,10 @@ export function getValue<T extends object>(value: T): T {
   return proxyDraft ? proxyDraft.copy ?? proxyDraft.original : value;
 }
 
-export function isDraftable(value: any, options?: Options<any, any>) {
+/**
+ * Check if a value is draftable
+ */
+export function isDraftable(value: any, options?: { mark?: Mark<any, any> }) {
   if (!value || typeof value !== 'object') return false;
   let markResult: any;
   return (

test/index.test.ts

@@ -1,4 +1,4 @@
-import { create, original, current, apply } from '../src';
+import { create, original, current, apply, isDraftable, isDraft } from '../src';
 import { PROXY_DRAFT } from '../src/constant';
 
 test('check object type', () => {
@@ -2129,3 +2129,41 @@ test('check Primitive type with returning, patches, freeze and async', async ()
     ]);
   }
 });
+
+test('base isDraft()', () => {
+  const baseState = {
+    date: new Date(),
+    list: [{ text: 'todo' }],
+  };
+
+  const state = create(baseState, (draft) => {
+    expect(isDraft(draft.date)).toBeFalsy();
+    expect(isDraft(draft.list)).toBeTruthy();
+  });
+})
+
+test('base isDraftable()', () => {
+  const baseState = {
+    date: new Date(),
+    list: [{ text: 'todo' }],
+  };
+
+  expect(isDraftable(baseState.date)).toBeFalsy();
+  expect(isDraftable(baseState.list)).toBeTruthy();
+});
+
+test('base isDraftable() with option', () => {
+  const baseState = {
+    date: new Date(),
+    list: [{ text: 'todo' }],
+  };
+
+  expect(
+    isDraftable(baseState.date, {
+      mark: (target, { immutable }) => {
+        if (target instanceof Date) return immutable;
+      },
+    })
+  ).toBeTruthy();
+  expect(isDraftable(baseState.list)).toBeTruthy();
+});