fix: applyPatches should mutate drafts

This mimics the behavior of applyPatches before v1.11.0

Fixes #301

__tests__/patch.js

@@ -39,6 +39,24 @@ function runPatchTest(base, producer, patches, inversePathes) {
 }
 
 describe("applyPatches", () => {
+    it("mutates the base state when it is a draft", () => {
+        produce({a: 1}, draft => {
+            const result = applyPatches(draft, [
+                {op: "replace", path: ["a"], value: 2}
+            ])
+            expect(result).toBe(draft)
+            expect(draft.a).toBe(2)
+        })
+    })
+    it("produces a copy of the base state when not a draft", () => {
+        const base = {a: 1}
+        const result = applyPatches(base, [
+            {op: "replace", path: ["a"], value: 2}
+        ])
+        expect(result).not.toBe(base)
+        expect(result.a).toBe(2)
+        expect(base.a).toBe(1)
+    })
     it('throws when `op` is not "add", "replace", nor "remove"', () => {
         expect(() => {
             const patch = {op: "copy", from: [0], path: [1]}

src/immer.js

@@ -1,6 +1,6 @@
 import * as legacyProxy from "./es5"
 import * as modernProxy from "./proxy"
-import {generatePatches} from "./patches"
+import {applyPatches, generatePatches} from "./patches"
 import {
     assign,
     each,
@@ -115,6 +115,14 @@ export class Immer {
         this.useProxies = value
         assign(this, value ? modernProxy : legacyProxy)
     }
+    applyPatches(base, patches) {
+        // Mutate the base state when a draft is passed.
+        if (isDraft(base)) {
+            return applyPatches(base, patches)
+        }
+        // Otherwise, produce a copy of the base state.
+        return this.produce(base, draft => applyPatches(draft, patches))
+    }
     /**
      * @internal
      * Finalize a draft, returning either the unmodified base state or a modified

src/index.js

@@ -1,4 +1,3 @@
-import {applyPatches as applyPatchesImpl} from "./patches"
 import {Immer} from "./immer"
 
 const immer = new Immer()
@@ -30,22 +29,22 @@ export default produce
  *
  * By default, auto-freezing is disabled in production.
  */
-export const setAutoFreeze = value => immer.setAutoFreeze(value)
+export const setAutoFreeze = immer.setAutoFreeze.bind(immer)
 
 /**
  * Pass true to use the ES2015 `Proxy` class when creating drafts, which is
  * always faster than using ES5 proxies.
  *
  * By default, feature detection is used, so calling this is rarely necessary.
  */
-export const setUseProxies = value => immer.setUseProxies(value)
+export const setUseProxies = immer.setUseProxies.bind(immer)
 
 /**
  * Apply an array of Immer patches to the first argument.
  *
  * This function is a producer, which means copy-on-write is in effect.
  */
-export const applyPatches = produce(applyPatchesImpl)
+export const applyPatches = immer.applyPatches.bind(immer)
 
 export {
     original,

src/patches.js

@@ -6,7 +6,7 @@ export function generatePatches(state, basePath, patches, inversePatches) {
         : generateObjectPatches(state, basePath, patches, inversePatches)
 }
 
-export function generateArrayPatches(state, basePath, patches, inversePatches) {
+function generateArrayPatches(state, basePath, patches, inversePatches) {
     const {base, copy, assigned} = state
     const minLength = Math.min(base.length, copy.length)