teamplay 0.4.0-alpha.98 → 0.4.0

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,
@@ -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) {

package/orm/Compat/hooksCompat.js

@@ -115,48 +115,54 @@ export function useAsyncDoc (collection, id, options) {
   return [$doc.get(), $doc]
 }
 
+function useSubscribedQuery (collection, query, options, hookName, subscribe) {
+  const normalizedQuery = normalizeQuery(query, hookName)
+  const $collection = getCollectionSignal(collection, query, hookName)
+  const $query = subscribe($collection, normalizedQuery, options)
+  return {
+    normalizedQuery,
+    $collection,
+    $query: getExtraQuerySignal($query, normalizedQuery)
+  }
+}
+
+function getExtraQuerySignal ($query, normalizedQuery) {
+  if (!$query) return $query
+  return isExtraQuery(normalizedQuery) ? $query.extra : $query
+}
+
 export function useQuery$ (collection, query, options) {
-  const normalizedQuery = normalizeQuery(query, 'useQuery')
-  const $collection = getCollectionSignal(collection, query, 'useQuery')
   const normalizedOptions = normalizeSyncSubOptions(options)
-  const $query = useSub($collection, normalizedQuery, normalizedOptions)
-  return isExtraQuery(normalizedQuery) ? $query.extra : $query
+  const { $query } = useSubscribedQuery(collection, query, normalizedOptions, 'useQuery', useSub)
+  return $query
 }
 
 export function useQuery (collection, query, options) {
-  const $collection = getCollectionSignal(collection, query, 'useQuery')
   const normalizedOptions = normalizeSyncSubOptions(options)
-  const $query = useSub($collection, normalizeQuery(query, 'useQuery'), normalizedOptions)
+  const { $collection, $query } = useSubscribedQuery(collection, query, normalizedOptions, 'useQuery', useSub)
   return [$query.get(), $collection]
 }
 
 export function useAsyncQuery$ (collection, query, options) {
-  const normalizedQuery = normalizeQuery(query, 'useAsyncQuery')
-  const $collection = getCollectionSignal(collection, query, 'useAsyncQuery')
-  const $query = useAsyncSub($collection, normalizedQuery, options)
-  if (!$query) return $query
-  return isExtraQuery(normalizedQuery) ? $query.extra : $query
+  const { $query } = useSubscribedQuery(collection, query, options, 'useAsyncQuery', useAsyncSub)
+  return $query
 }
 
 export function useAsyncQuery (collection, query, options) {
-  const $collection = getCollectionSignal(collection, query, 'useAsyncQuery')
-  const $query = useAsyncSub($collection, normalizeQuery(query, 'useAsyncQuery'), options)
+  const { $collection, $query } = useSubscribedQuery(collection, query, options, 'useAsyncQuery', useAsyncSub)
   if (!$query) return [undefined, $collection]
   return [$query.get(), $collection]
 }
 
 export function useBatchQuery$ (collection, query, _options) {
-  const normalizedQuery = normalizeQuery(query, 'useBatchQuery')
-  const $collection = getCollectionSignal(collection, query, 'useBatchQuery')
-  const options = _options ? { ..._options, ...BATCH_SUB_OPTIONS } : BATCH_SUB_OPTIONS
-  const $query = useSub($collection, normalizedQuery, options)
-  if (!$query) return $query
-  return isExtraQuery(normalizedQuery) ? $query.extra : $query
+  const options = normalizeBatchSubOptions(_options)
+  const { $query } = useSubscribedQuery(collection, query, options, 'useBatchQuery', useSub)
+  return $query
 }
 
-export function useBatchQuery (collection, query, options) {
-  const $collection = getCollectionSignal(collection, query, 'useBatchQuery')
-  const $query = useBatchQuery$(collection, query, options)
+export function useBatchQuery (collection, query, _options) {
+  const options = normalizeBatchSubOptions(_options)
+  const { $collection, $query } = useSubscribedQuery(collection, query, options, 'useBatchQuery', useSub)
   if (!$query) return [undefined, $collection]
   return [$query.get(), $collection]
 }
@@ -359,6 +365,10 @@ function normalizeSyncSubOptions (options) {
   }
 }
 
+function normalizeBatchSubOptions (options) {
+  return options ? { ...options, ...BATCH_SUB_OPTIONS } : BATCH_SUB_OPTIONS
+}
+
 export const __COMPAT_BATCH_READY__ = {
   isQueryReady
 }

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) => {
@@ -349,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()
     })
   })
@@ -447,6 +440,33 @@ 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
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.4.0-alpha.98",
+  "version": "0.4.0",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "index.js",
@@ -35,12 +35,12 @@
   "dependencies": {
     "@nx-js/observer-util": "^4.1.3",
     "@startupjs/sharedb-mingo-memory": "^4.0.0-2",
-    "@teamplay/backend": "^0.4.0-alpha.9",
-    "@teamplay/cache": "^0.4.0-alpha.9",
-    "@teamplay/channel": "^0.4.0-alpha.9",
-    "@teamplay/debug": "^0.4.0-alpha.9",
-    "@teamplay/schema": "^0.4.0-alpha.9",
-    "@teamplay/utils": "^0.4.0-alpha.9",
+    "@teamplay/backend": "^0.4.0",
+    "@teamplay/cache": "^0.4.0",
+    "@teamplay/channel": "^0.4.0",
+    "@teamplay/debug": "^0.4.0",
+    "@teamplay/schema": "^0.4.0",
+    "@teamplay/utils": "^0.4.0",
     "diff-match-patch": "^1.0.5",
     "events": "^3.3.0",
     "json0-ot-diff": "^1.1.2",
@@ -83,5 +83,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "ae4e0e6ee39e395fa9eb48a2099cc1d5b2a4630d"
+  "gitHead": "c944a34b27e2dbbe5c81b1c39739caa012212e3f"
 }