teamplay 0.4.0-alpha.74 → 0.4.0-alpha.76

package/orm/Compat/SignalCompat.js

@@ -15,6 +15,7 @@ import { IS_QUERY, getQuerySignal, querySubscriptions } from '../Query.js'
 import { IS_AGGREGATION, aggregationSubscriptions, getAggregationSignal } from '../Aggregation.js'
 import { getIdFieldsForSegments, isIdFieldPath, normalizeIdFields, isPlainObject } from '../idFields.js'
 import {
+  del as _del,
   setReplace as _setReplace,
   incrementPublic as _incrementPublic,
   arrayPush as _arrayPush,
@@ -916,8 +917,15 @@ function isMissingPublicDocDeleteError ($signal, error) {
 
 async function setDiffDeepOnSignal ($target, value) {
   if ($target[SEGMENTS].length === 0) throw Error('Can\'t set the root signal data')
-  const before = $target.get()
-  await diffDeepCompat($target, before, value)
+  // Use peek() here. compat start() writes via setDiffDeep inside an observer and must not
+  // subscribe to its own target, otherwise later local edits on child signals cause start()
+  // to rerun and overwrite them from source.
+  const before = $target.peek()
+  if (isPublicCollection($target[SEGMENTS][0])) {
+    await diffDeepCompat($target, before, value)
+    return
+  }
+  diffDeepCompatSync($target, before, value)
 }
 
 async function diffDeepCompat ($signal, before, after) {
@@ -949,6 +957,35 @@ async function diffDeepCompat ($signal, before, after) {
   await SignalCompat.prototype.set.call($signal, after)
 }
 
+function diffDeepCompatSync ($signal, before, after) {
+  if (before === after) return
+
+  if (Array.isArray(before) && Array.isArray(after)) {
+    if (deepEqualCompat(before, after)) return
+    const changedIndexes = getChangedArrayIndexes(before, after)
+    if (before.length === after.length && changedIndexes.length === 1) {
+      const index = changedIndexes[0]
+      diffDeepCompatSync(getChildSignal($signal, index), before[index], after[index])
+      return
+    }
+    setReplacePrivateCompatSync($signal, after)
+    return
+  }
+
+  if (isDiffableObject(before, after)) {
+    for (const key of Object.keys(before)) {
+      if (Object.prototype.hasOwnProperty.call(after, key)) continue
+      delPrivateCompatSync(getChildSignal($signal, key))
+    }
+    for (const key of Object.keys(after)) {
+      diffDeepCompatSync(getChildSignal($signal, key), before[key], after[key])
+    }
+    return
+  }
+
+  setReplacePrivateCompatSync($signal, after)
+}
+
 function isDiffableObject (before, after) {
   if (!isPlainObject(before) || !isPlainObject(after)) return false
   if (isReactLike(before) || isReactLike(after)) return false
@@ -972,6 +1009,26 @@ function getChildSignal ($parent, key) {
   return $child
 }
 
+function setReplacePrivateCompatSync ($signal, value) {
+  const segments = $signal[SEGMENTS]
+  if (segments.length === 0) throw Error('Can\'t set the root signal data')
+  const idFields = getIdFieldsForSegments(segments)
+  if (isIdFieldPath(segments, idFields)) return
+  if (segments.length === 2) {
+    value = normalizeIdFields(value, idFields, segments[1])
+  }
+  _setReplace(segments, value)
+  mirrorRefMutationFromTarget(segments, value)
+}
+
+function delPrivateCompatSync ($signal) {
+  const segments = $signal[SEGMENTS]
+  if (segments.length === 0) throw Error('Can\'t delete the root signal data')
+  const idFields = getIdFieldsForSegments(segments)
+  if (isIdFieldPath(segments, idFields)) return
+  _del(segments)
+}
+
 function deepEqualCompat (left, right) {
   if (left === right) return true
   if (left == null || right == null) return false

package/orm/Compat/startStopCompat.js

@@ -38,7 +38,12 @@ export function compatStartOnRoot ($root, targetPath, ...depsAndGetter) {
       if (isThenable(err)) return
       throw err
     }
-    const maybePromise = $target.set(detachStartValue(nextValue))
+    const detachedValue = detachStartValue(nextValue)
+    // Keep the detached snapshot to avoid aliasing source and target.
+    // Old racer start() writes through diffDeep by default. In compat mode we must preserve
+    // that behavior, but also avoid reading the target reactively inside start(), otherwise
+    // start() subscribes to its own output and local child edits get immediately overwritten.
+    const maybePromise = $target.setDiffDeep(detachedValue)
     if (maybePromise?.catch) maybePromise.catch(ignorePromiseRejection)
   }, { scheduler: scheduleReaction })
   store.set(targetKey, { stop: () => unobserve(reaction) })

package/orm/dataTree.js

@@ -517,6 +517,14 @@ export async function incrementPublic (segments, byNumber) {
     hydrateCompatDocData: true
   })
   if (!docState.exists) throw Error(ERRORS.nonExistingDoc(segments))
+  const current = getRaw(segments)
+  if (current == null) {
+    // Align with Racer's RemoteDoc.increment(): if the document exists but the
+    // target path is missing/null, initialize the path with the increment value
+    // instead of emitting a numeric-add op against a non-existing path.
+    await setPublicDoc(segments, byNumber)
+    return
+  }
   const relativePath = segments.slice(2)
   const op = [{ p: relativePath, na: byNumber }]
   return new Promise((resolve, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.4.0-alpha.74",
+  "version": "0.4.0-alpha.76",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "index.js",
@@ -83,5 +83,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "52e6aafb0dc6fba829f54375997a5880f4a32d6c"
+  "gitHead": "954f4352b0641286b46c015a152175929eb979bc"
 }