mobx 7.0.1 → 7.0.3

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # mobx
 
+## 7.0.3
+
+### Patch Changes
+
+-   [`6f002b8e543ca39d3ee23681e28848d7f1724fae`](https://github.com/mobxjs/mobx/commit/6f002b8e543ca39d3ee23681e28848d7f1724fae) [#4696](https://github.com/mobxjs/mobx/pull/4696) Thanks [@gesposito](https://github.com/gesposito)! - perf: add a `node` export condition that routes Node and Bun to the existing `dist/index.js` entry, which picks the prebaked development or production CJS build once at require time. `import`ing mobx in Node no longer executes the env-agnostic `dist/mobx.mjs` with per-call `NODE_ENV` checks, and mixing `import` and `require` in one Node app now yields a single mobx instance.
+
+## 7.0.2
+
+### Patch Changes
+
+-   [`ec1b708026c1578e1c1f6c7bd90be18b26f7ce85`](https://github.com/mobxjs/mobx/commit/ec1b708026c1578e1c1f6c7bd90be18b26f7ce85) [#4695](https://github.com/mobxjs/mobx/pull/4695) Thanks [@gesposito](https://github.com/gesposito)! - perf: evaluate `NODE_ENV` once at module scope in the env-agnostic esm bundles (`dist/<pkg>.esm.js` and `dist/<pkg>.mjs`) instead of at every `__DEV__` call site. `process.env` is an exotic object in Node, so each check performed a real environment lookup on hot paths; consumers that execute these files as-is (Node ESM, vitest, SSR) see roughly 10x faster observable writes in dev mode. All env-set artifacts and bundler output are unchanged.
+
+-   [`6d8b5fa6c7596d7e5b16e55e3121d81c0c5bb21a`](https://github.com/mobxjs/mobx/commit/6d8b5fa6c7596d7e5b16e55e3121d81c0c5bb21a) [#4672](https://github.com/mobxjs/mobx/pull/4672) Thanks [@chatman-media](https://github.com/chatman-media)! - Fix `ObservableSet.replace` emitting spurious `delete`/`add` events (and triggering reactions) for values that are unchanged. It now only fires `delete` for removed values and `add` for newly added ones, mirroring `ObservableMap.replace`.
+
+    Note: because `replace` no longer clears and re-adds every value, the iteration order after `replace` changes in a (subtle but observable) way. Surviving values now keep their original relative position and newly added values are appended, instead of the whole set being reordered to match the argument. For example, `set(["a", "b", "c"]).replace(["d", "b", "a"])` previously iterated as `d, b, a`, and now iterates as `a, b, d`. This is arguably the more correct behavior (unchanged values are genuinely unchanged), but if you relied on `replace` reordering the set to match its argument, you may need to adjust.
+
 ## 7.0.1
 
 ### Patch Changes

package/dist/mobx.cjs.development.js

@@ -4399,17 +4399,40 @@ class ObservableSet {
     if (isObservableSet(other)) {
       other = new Set(other);
     }
-    transaction(() => {
-      if (Array.isArray(other)) {
-        this.clear();
-        other.forEach(value => this.add(value));
-      } else if (isES6Set(other)) {
-        this.clear();
-        other.forEach(value => this.add(value));
-      } else if (other !== null && other !== undefined) {
-        die(41, other);
-      }
-    });
+    if (Array.isArray(other) || isES6Set(other)) {
+      // Only emit `delete`/`add` events (and `reportChanged`) for values that
+      // actually change, instead of clearing and re-adding everything. `add` and
+      // `delete` are already no-ops for values that are respectively already
+      // present or already absent, so we just need to avoid deleting values that
+      // are part of the replacement. See #3761.
+      transaction(() => {
+        // Collect the desired values for quick lookup. `other` is already a Set
+        // here when it was passed (or snapshotted from an observable set) as one,
+        // so reuse it rather than allocating another; arrays are wrapped (which
+        // also dedupes them).
+        const replacementValues = isES6Set(other) ? other : new Set(other);
+        // Short-circuit the trivial cases: an empty replacement is just a clear,
+        // and replacing into an empty set only needs the adds.
+        if (replacementValues.size === 0) {
+          this.clear();
+          return;
+        }
+        if (this.data_.size === 0) {
+          replacementValues.forEach(value => this.add(value));
+          return;
+        }
+        // Delete values that are not part of the replacement.
+        for (const value of this.data_.values()) {
+          if (!replacementValues.has(this.dehanceValue_(value))) {
+            this.delete(value);
+          }
+        }
+        // Add new values; values that are already present are a no-op.
+        replacementValues.forEach(value => this.add(value));
+      });
+    } else if (other !== null && other !== undefined) {
+      die(41, other);
+    }
     return this;
   }
   toJSON() {