mobx-keystone 1.25.0 → 2.1.0

package/src/wrappers/asSet.ts

@@ -11,7 +11,14 @@ import {
   transaction,
   untracked,
 } from "mobx"
-import { assertIsObservableArray, assertIsSet, failure, getMobxVersion, inDevMode } from "../utils"
+import {
+  assertIsObservableArray,
+  assertIsSet,
+  failure,
+  getMobxVersion,
+  inDevMode,
+  isEqualOrBothNaN,
+} from "../utils"
 import { tag } from "../utils/tag"
 
 const observableSetBackedByObservableArray = <T>(
@@ -26,9 +33,9 @@ const observableSetBackedByObservableArray = <T>(
   const set = transaction(() =>
     untracked(() => {
       if (getMobxVersion() >= 6) {
-        return observable.set(array)
+        return observable.set(array, { deep: false })
       } else {
-        const set = observable.set()
+        const set = observable.set<T>(undefined, { deep: false })
         runInAction(() => {
           array.forEach((item) => {
             set.add(item)
@@ -98,28 +105,45 @@ const observableSetBackedByObservableArray = <T>(
   intercept(
     set,
     action((change: ISetWillChange<T>) => {
-      if (setAlreadyChanged) {
-        return null
-      }
-
       if (arrayAlreadyChanged) {
         return change
       }
 
+      if (setAlreadyChanged) {
+        return null
+      }
+
       setAlreadyChanged = true
 
       try {
         switch (change.type) {
           case "add": {
-            array.push(change.newValue)
+            if (!set.has(change.newValue)) {
+              const oldLength = array.length
+              array.push(change.newValue)
+              if (array.length === oldLength) return null
+              const storedValue = array[array.length - 1]
+              if (getMobxVersion() >= 6) {
+                change.newValue = storedValue
+              } else if (!isEqualOrBothNaN(storedValue, change.newValue)) {
+                // MobX 4/5 ignore replacement values returned by set interceptors.
+                arrayAlreadyChanged = true
+                try {
+                  set.add(storedValue)
+                } finally {
+                  arrayAlreadyChanged = false
+                }
+                return null
+              }
+            }
             break
           }
 
           case "delete": {
-            const i = array.indexOf(change.oldValue)
-            if (i >= 0) {
-              array.splice(i, 1)
-            }
+            const i = Number.isNaN(change.oldValue)
+              ? array.findIndex(Number.isNaN)
+              : array.indexOf(change.oldValue)
+            if (i >= 0 && array.splice(i, 1).length === 0) return null
             break
           }
 

package/dist/types/action/modelFlowPromiseGenerator.d.ts

@@ -1 +0,0 @@
-export declare function promiseGenerator(this: Promise<any>): any;

package/src/action/modelFlowPromiseGenerator.ts

@@ -1,127 +0,0 @@
-// biome-ignore-all lint: transpiled TypeScript ES5 helper kept verbatim; its generated shape intentionally violates style and complexity rules.
-
-/*
-function* promiseGenerator<T>(
-  this: Promise<T>
-) {
-  const ret: T = yield this
-  return ret
-}
-*/
-
-// above code but compiled by TS for ES5
-// so we don't include a dependency to regenerator runtime
-
-const __generator = function (thisArg: any, body: any) {
-  let _: any = {
-      label: 0,
-      sent: function () {
-        if (t[0] & 1) throw t[1]
-        return t[1]
-      },
-      trys: [],
-      ops: [],
-    },
-    f: any,
-    y: any,
-    t: any,
-    g: any
-  return (
-    (g = { next: verb(0), throw: verb(1), return: verb(2) }),
-    typeof Symbol === "function" &&
-      (g[Symbol.iterator] = function () {
-        return this
-      }),
-    g
-  )
-  function verb(n: any) {
-    return function (v: any) {
-      return step([n, v])
-    }
-  }
-  function step(op: any) {
-    if (f) throw new TypeError("Generator is already executing.")
-    while (_)
-      try {
-        if (
-          ((f = 1),
-          y &&
-            (t =
-              op[0] & 2
-                ? y["return"]
-                : op[0]
-                  ? y["throw"] || ((t = y["return"]) && t.call(y), 0)
-                  : y.next) &&
-            !(t = t.call(y, op[1])).done)
-        )
-          return t
-        if (((y = 0), t)) op = [op[0] & 2, t.value]
-        switch (op[0]) {
-          case 0:
-          case 1:
-            t = op
-            break
-          case 4:
-            _.label++
-            return { value: op[1], done: false }
-          case 5:
-            _.label++
-            y = op[1]
-            op = [0]
-            continue
-          case 7:
-            op = _.ops.pop()
-            _.trys.pop()
-            continue
-          default:
-            if (
-              !((t = _.trys), (t = t.length > 0 && t[t.length - 1])) &&
-              (op[0] === 6 || op[0] === 2)
-            ) {
-              _ = 0
-              continue
-            }
-            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
-              _.label = op[1]
-              break
-            }
-            if (op[0] === 6 && _.label < t[1]) {
-              _.label = t[1]
-              t = op
-              break
-            }
-            if (t && _.label < t[2]) {
-              _.label = t[2]
-              _.ops.push(op)
-              break
-            }
-            if (t[2]) _.ops.pop()
-            _.trys.pop()
-            continue
-        }
-        op = body.call(thisArg, _)
-      } catch (e) {
-        op = [6, e]
-        y = 0
-      } finally {
-        f = t = 0
-      }
-    if (op[0] & 5) throw op[1]
-    return { value: op[0] ? op[1] : void 0, done: true }
-  }
-}
-
-export function promiseGenerator(this: Promise<any>) {
-  let ret
-  return __generator(this, function (this: any, _a: any) {
-    switch (_a.label) {
-      case 0:
-        return [4 /*yield*/, this]
-      case 1:
-        ret = _a.sent()
-        return [2 /*return*/, ret]
-      default:
-        return
-    }
-  })
-}