teamplay 0.4.0-alpha.97 → 0.4.0-alpha.99

package/orm/Compat/SignalCompat.js

@@ -1,4 +1,5 @@
 import { raw, observe, unobserve } from '@nx-js/observer-util'
+import arrayDiff from 'arraydiff'
 import {
   Signal,
   GETTERS,
@@ -29,7 +30,7 @@ import {
 } from '../dataTree.js'
 import { on as onCustomEvent, removeListener as removeCustomEventListener } from './eventsCompat.js'
 import { waitForImperativeQueryReady } from './queryReadiness.js'
-import { normalizePattern, onModelEvent, removeModelListener } from './modelEvents.js'
+import { isModelEventsEnabled, normalizePattern, onModelEvent, removeModelListener } from './modelEvents.js'
 import { setRefLink, removeRefLink, getAllRefLinks } from './refRegistry.js'
 import { REF_TARGET, resolveRefSignalSafe, resolveRefSegmentsSafe } from './refFallback.js'
 import { runInBatch } from '../batchScheduler.js'
@@ -974,14 +975,14 @@ async function diffDeepCompat ($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]
+    const diff = arrayDiff(before, after, deepEqualCompat)
+    if (!diff.length) return
+    const index = getSingleArrayReplacementIndex(diff)
+    if (index != null) {
       await diffDeepCompat(getChildSignal($signal, index), before[index], after[index])
       return
     }
-    await SignalCompat.prototype.set.call($signal, after)
+    await applyArrayDiffCompat($signal, diff)
     return
   }
 
@@ -1003,14 +1004,14 @@ 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]
+    const diff = arrayDiff(before, after, deepEqualCompat)
+    if (!diff.length) return
+    const index = getSingleArrayReplacementIndex(diff)
+    if (index != null) {
       diffDeepCompatSync(getChildSignal($signal, index), before[index], after[index])
       return
     }
-    setReplacePrivateCompatSync($signal, after)
+    applyArrayDiffCompatSync($signal, diff)
     return
   }
 
@@ -1035,14 +1036,54 @@ function isDiffableObject (before, after) {
   return true
 }
 
-function getChangedArrayIndexes (before, after) {
-  if (!Array.isArray(before) || !Array.isArray(after)) return []
-  const maxLength = Math.max(before.length, after.length)
-  const changed = []
-  for (let i = 0; i < maxLength; i++) {
-    if (!deepEqualCompat(before[i], after[i])) changed.push(i)
+function getSingleArrayReplacementIndex (diff) {
+  if (!Array.isArray(diff) || diff.length !== 2) return null
+  const first = diff[0]
+  const second = diff[1]
+  if (
+    first instanceof arrayDiff.RemoveDiff &&
+    second instanceof arrayDiff.InsertDiff &&
+    first.index === second.index &&
+    first.howMany === 1 &&
+    second.values.length === 1
+  ) {
+    return first.index
+  }
+  return null
+}
+
+async function applyArrayDiffCompat ($signal, diff) {
+  for (const item of diff) {
+    if (item instanceof arrayDiff.InsertDiff) {
+      await arrayInsertOnSignal($signal, item.index, item.values)
+      continue
+    }
+    if (item instanceof arrayDiff.RemoveDiff) {
+      await arrayRemoveOnSignal($signal, item.index, item.howMany)
+      continue
+    }
+    if (item instanceof arrayDiff.MoveDiff) {
+      await arrayMoveOnSignal($signal, item.from, item.to, item.howMany)
+    }
+  }
+}
+
+function applyArrayDiffCompatSync ($signal, diff) {
+  const segments = ensureArrayTarget($signal)
+  const rootId = getOwningRootId($signal)
+  for (const item of diff) {
+    if (item instanceof arrayDiff.InsertDiff) {
+      arrayInsertPrivateData(rootId, segments, item.index, item.values)
+      continue
+    }
+    if (item instanceof arrayDiff.RemoveDiff) {
+      arrayRemovePrivateData(rootId, segments, item.index, item.howMany)
+      continue
+    }
+    if (item instanceof arrayDiff.MoveDiff) {
+      arrayMovePrivateData(rootId, segments, item.from, item.to, item.howMany)
+    }
   }
-  return changed
 }
 
 function getChildSignal ($parent, key) {
@@ -1061,7 +1102,9 @@ function setReplacePrivateCompatSync ($signal, value) {
     value = normalizeIdFields(value, idFields, segments[1])
   }
   setReplacePrivateData(getOwningRootId($signal), segments, value)
-  if (isSilentContextActive()) mirrorRefMutationFromTarget(segments, value)
+  if (shouldMirrorPrivateRefMutationLocally()) {
+    mirrorRefMutationFromTarget(segments, value)
+  }
 }
 
 function delPrivateCompatSync ($signal, options) {
@@ -1123,7 +1166,9 @@ async function setReplaceOnSignal ($signal, value) {
   }
   if (isPrivateMutationForbidden()) throw Error(ERRORS.publicOnly)
   const result = setReplacePrivateData(getOwningRootId($signal), segments, value)
-  if (isSilentContextActive()) mirrorRefMutationFromTarget(segments, value)
+  if (shouldMirrorPrivateRefMutationLocally()) {
+    mirrorRefMutationFromTarget(segments, value)
+  }
   return result
 }
 
@@ -1271,6 +1316,11 @@ function shouldMirrorPublicRefMutationLocally (segments) {
   return !docSubscriptions.hasRuntime(transportHash)
 }
 
+function shouldMirrorPrivateRefMutationLocally () {
+  if (isSilentContextActive()) return true
+  return !isModelEventsEnabled()
+}
+
 function shallowCopy (value) {
   const rawValue = raw(value)
   if (Array.isArray(rawValue)) return rawValue.slice()

package/orm/Compat/startStopCompat.js

@@ -24,6 +24,7 @@ export function compatStartOnRoot ($root, targetPath, ...depsAndGetter) {
   const existing = store.get(targetKey)
   if (existing) existing.stop()
 
+  let lastSourceSnapshot = UNSET
   const reaction = observe(() => {
     const resolvedDeps = []
     for (const dep of deps) {
@@ -38,13 +39,22 @@ export function compatStartOnRoot ($root, targetPath, ...depsAndGetter) {
       if (isThenable(err)) return
       throw err
     }
-    const detachedValue = detachStartValue(nextValue)
+    const sourceSnapshot = detachStartValue(nextValue)
+    if (lastSourceSnapshot !== UNSET && deepEqualStartValue(lastSourceSnapshot, sourceSnapshot)) {
+      return
+    }
+    lastSourceSnapshot = sourceSnapshot
+    const detachedValue = detachStartValue(sourceSnapshot)
     // 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)
+    if (maybePromise?.then) {
+      maybePromise
+        .then(() => {})
+        .catch(ignorePromiseRejection)
+    }
   }, { scheduler: scheduleReaction })
   store.set(targetKey, { stop: () => unobserve(reaction) })
   return $target
@@ -134,6 +144,8 @@ function isThenable (value) {
   return !!value && typeof value.then === 'function'
 }
 
+const UNSET = Symbol('compat start unset')
+
 function detachStartValue (value) {
   const rawValue = raw(value)
   if (!rawValue || typeof rawValue !== 'object') return rawValue
@@ -166,3 +178,30 @@ function racerDeepCopy (value) {
   }
   return value
 }
+
+function deepEqualStartValue (left, right) {
+  if (left === right) return true
+  if (Number.isNaN(left) && Number.isNaN(right)) return true
+  if (left instanceof Date || right instanceof Date) {
+    return left instanceof Date && right instanceof Date && left.getTime() === right.getTime()
+  }
+  if (!left || !right || typeof left !== 'object' || typeof right !== 'object') return false
+
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right)) return false
+    if (left.length !== right.length) return false
+    for (let i = 0; i < left.length; i++) {
+      if (!deepEqualStartValue(left[i], right[i])) return false
+    }
+    return true
+  }
+
+  const leftKeys = Object.keys(left)
+  const rightKeys = Object.keys(right)
+  if (leftKeys.length !== rightKeys.length) return false
+  for (const key of leftKeys) {
+    if (!Object.prototype.hasOwnProperty.call(right, key)) return false
+    if (!deepEqualStartValue(left[key], right[key])) return false
+  }
+  return true
+}

package/orm/Doc.js

@@ -35,6 +35,34 @@ function getOwningRootId ($doc) {
   return rootId
 }
 
+function deepEqualDocData (left, right) {
+  if (left === right) return true
+  if (left == null || right == null) return left === right
+
+  const leftIsArray = Array.isArray(left)
+  if (leftIsArray || Array.isArray(right)) {
+    if (!leftIsArray || !Array.isArray(right)) return false
+    if (left.length !== right.length) return false
+    for (let i = 0; i < left.length; i++) {
+      if (!deepEqualDocData(left[i], right[i])) return false
+    }
+    return true
+  }
+
+  if (typeof left !== 'object' || typeof right !== 'object') return false
+
+  const leftKeys = Object.keys(left)
+  const rightKeys = Object.keys(right)
+  if (leftKeys.length !== rightKeys.length) return false
+
+  for (const key of leftKeys) {
+    if (!Object.prototype.hasOwnProperty.call(right, key)) return false
+    if (!deepEqualDocData(left[key], right[key])) return false
+  }
+
+  return true
+}
+
 class Doc {
   initialized
 
@@ -162,6 +190,12 @@ class Doc {
     if (isPlainObject(doc.data)) injectIdFields(doc.data, idFields, this.docId)
     const path = [this.collection, this.docId]
     const data = isObservable(doc.data) ? raw(doc.data) : doc.data
+    const current = _getRaw(path)
+    if (deepEqualDocData(current, data)) {
+      if (current != null && current !== raw(doc.data)) doc.data = current
+      if (!isObservable(doc.data)) doc.data = observable(doc.data)
+      return
+    }
     _set(path, data)
     const synced = _getRaw(path)
     if (synced != null && synced !== raw(doc.data)) doc.data = synced

package/orm/dataTree.js

@@ -73,7 +73,7 @@ export function set (segments, value, tree = dataTree, eventContext) {
   const shouldEmit = shouldEmitModelEvents(tree, eventContext)
   const prevValue = shouldEmit ? get(segments, getTreeRaw(tree)) : undefined
   let dataNode = writableTree
-  let dataNodeRaw = raw(writableTree)
+  let dataNodeRaw = getTreeRaw(writableTree)
   for (let i = 0; i < segments.length - 1; i++) {
     const segment = segments[i]
     const nextSegment = segments[i + 1]
@@ -84,34 +84,15 @@ export function set (segments, value, tree = dataTree, eventContext) {
       else dataNode[segment] = {}
     }
     dataNode = dataNode[segment]
-    dataNodeRaw = raw(dataNode)
+    dataNodeRaw = getTreeRaw(dataNode)
   }
   const key = segments[segments.length - 1]
-  // handle adding out of bounds empty element to the array
-  if (value == null && Array.isArray(dataNodeRaw) && key >= dataNodeRaw.length) {
-    // inject new undefined elements to the end of the array
-    dataNode.splice(dataNodeRaw.length, key - dataNodeRaw.length + 1,
-      ...Array(key - dataNodeRaw.length + 1).fill(undefined))
-    return
-  }
-  // handle when the value didn't change
-  if (value === dataNodeRaw[key]) return
-  // handle setting undefined value
-  if (value == null) {
-    if (Array.isArray(dataNodeRaw)) {
-      // if parent is an array -- we set array element to undefined
-      // IMPORTANT: JSON serialization will replace `undefined` with `null`
-      //            so if the data will go to the server, it will be serialized as `null`.
-      //            And when it comes back from the server it will be still `null`.
-      //            This can lead to confusion since when you set `undefined` the value
-      //            might end up becoming `null` for seemingly no reason (like in this case).
-      dataNode[key] = undefined
-    } else {
-      // if parent is an object -- we completely delete the property.
-      // Deleting the property is better for the JSON serialization
-      // since JSON does not have `undefined` values and replaces them with `null`.
-      delete dataNode[key]
-    }
+  const keyExists = hasOwnDataKey(dataNodeRaw, key)
+  // Preserve racer local semantics: assigning undefined creates/keeps the slot/key
+  // instead of deleting it, and sparse array writes keep holes intact.
+  if (keyExists && value === dataNodeRaw[key]) return
+  if (value == null || typeof value !== 'object') {
+    dataNode[key] = value
     emitModelEvent(segments, prevValue, { op: 'set' }, tree, eventContext)
     return
   }
@@ -124,6 +105,12 @@ export function set (segments, value, tree = dataTree, eventContext) {
   emitModelEvent(segments, prevValue, { op: 'set' }, tree, eventContext)
 }
 
+function hasOwnDataKey (node, key) {
+  if (node == null) return false
+  if (Array.isArray(node)) return key in node
+  return Object.prototype.hasOwnProperty.call(node, key)
+}
+
 // Like set(), but always assigns the value without equality checks or delete-on-null behavior
 export function setReplace (segments, value, tree = dataTree, eventContext) {
   const writableTree = getWritableTree(tree)
@@ -253,7 +240,7 @@ export async function setPublicDoc (segments, value, deleteValue = false) {
     if (deleteValue) {
       del(segments.slice(2), newDoc)
     } else {
-      set(segments.slice(2), value, newDoc)
+      set(segments.slice(2), normalizeUndefined(value), newDoc)
     }
     const diff = jsonDiff(oldDoc, newDoc, diffMatchPatch)
     return new Promise((resolve, reject) => {
@@ -326,6 +313,13 @@ export async function setPublicDocReplace (segments, value) {
   }
 
   const relativePath = segments.slice(2)
+  // json0 direct replace ops require every ancestor container to already exist.
+  // Racer-like compat set, however, materializes missing/primitive parents while
+  // descending into the path. Fall back to the older diff-based path when the
+  // direct op would target a non-existent/non-object ancestor.
+  if (!canApplyDirectReplaceOp(docState.snapshot || {}, relativePath)) {
+    return setPublicDoc(segments, value)
+  }
   const previous = getRaw(segments)
   const normalizedPrevious = normalizeUndefined(
     relativePath.length === 0 ? stripIdFields(previous, idFields) : previous
@@ -342,7 +336,13 @@ export async function setPublicDocReplace (segments, value) {
   return new Promise((resolve, reject) => {
     doc.submitOp(op, err => {
       if (err) return reject(err)
-      ensureLocalDocSyncedWithShareDoc({ collection, docId, doc, idFields })
+      syncLocalDocAfterPublicWrite({
+        collection,
+        docId,
+        doc,
+        idFields,
+        relativePath
+      })
       resolve()
     })
   })
@@ -440,10 +440,47 @@ function ensureLocalDocSyncedWithShareDoc ({
   setReplace([collection, docId], shared)
 }
 
+function syncLocalDocAfterPublicWrite ({
+  collection,
+  docId,
+  doc,
+  idFields,
+  relativePath = []
+}) {
+  if (!Array.isArray(relativePath) || relativePath.length === 0) {
+    ensureLocalDocSyncedWithShareDoc({ collection, docId, doc, idFields })
+    return
+  }
+  if (isMissingShareDoc(doc)) return
+  if (doc?.data == null) return
+  const shared = raw(doc.data)
+  const nextValue = get(relativePath, shared)
+  setReplace([collection, docId, ...relativePath], clonePublicLocalSyncValue(nextValue))
+}
+
+function clonePublicLocalSyncValue (value) {
+  const rawValue = raw(value)
+  if (rawValue == null || typeof rawValue !== 'object') return rawValue
+  if (typeof globalThis.structuredClone === 'function') {
+    return globalThis.structuredClone(rawValue)
+  }
+  return JSON.parse(JSON.stringify(rawValue))
+}
+
 function normalizeUndefined (value) {
   return value === undefined ? null : value
 }
 
+function canApplyDirectReplaceOp (docSnapshot, relativePath) {
+  if (relativePath.length === 0) return true
+  let node = docSnapshot
+  for (let i = 0; i < relativePath.length - 1; i++) {
+    if (node == null || typeof node !== 'object') return false
+    node = node[relativePath[i]]
+  }
+  return node != null && typeof node === 'object'
+}
+
 function normalizeValueForOp (value) {
   let result = raw(value)
   if (result != null && typeof result === 'object') result = JSON.parse(JSON.stringify(result))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.4.0-alpha.97",
+  "version": "0.4.0-alpha.99",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "index.js",
@@ -83,5 +83,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "633e39dc754332bcd3d95ddc4cfb3522f0bfd694"
+  "gitHead": "22d0358b80fa29754147b4318975b26fff3eae5a"
 }

package/react/useSub.js

@@ -44,8 +44,8 @@ export function useSubDeferred (signal, params, { async = false, defer, batch =
   // 1. if it's a promise, throw it so that Suspense can catch it and wait for subscription to finish
   if (promiseOrSignal.then) {
     const promise = maybeThrottle(promiseOrSignal)
+    const hasPreviousSignal = !!$signalRef.current
     if (batch) {
-      const hasPreviousSignal = !!$signalRef.current
       // Batch suspense must block only on initial load.
       // On resubscribe we keep rendering previous signal and refresh in background.
       if (!hasPreviousSignal) {
@@ -61,6 +61,11 @@ export function useSubDeferred (signal, params, { async = false, defer, batch =
       scheduleUpdate(promise)
       return
     }
+    // Keep previous snapshot during update re-subscribe and refresh in background.
+    if (hasPreviousSignal) {
+      scheduleUpdate(promise)
+      return $signalRef.current
+    }
     if (compatAttemptCleanup) registerCompatAttemptCleanup(signal, params)
     throw promise
   // 2. if it's a signal, we save it into ref to make sure it's not garbage collected while component exists