teamplay 0.4.0-alpha.94 → 0.4.0-alpha.96

package/orm/Compat/queryReadiness.js

@@ -1,10 +1,12 @@
 import { getRaw } from '../dataTree.js'
 import { getConnection } from '../connection.js'
 import { isMissingShareDoc } from '../missingDoc.js'
-import { QUERIES, HASH, PARAMS, COLLECTION_NAME } from '../Query.js'
-import { AGGREGATIONS, IS_AGGREGATION } from '../Aggregation.js'
+import { QUERIES, HASH, PARAMS, COLLECTION_NAME, querySubscriptions } from '../Query.js'
+import { AGGREGATIONS, IS_AGGREGATION, aggregationSubscriptions } from '../Aggregation.js'
 import { getPrivateData, setPrivateData } from '../privateData.js'
 import { getRoot, ROOT_ID } from '../Root.js'
+import { isRootContextClosed } from '../rootContext.js'
+import { getScopedSignalHash, normalizeRootId } from '../rootScope.js'
 
 let imperativeQueryReadyTimeoutMs = 1000
 
@@ -47,7 +49,9 @@ export function isDocReady (segments) {
 export async function waitForImperativeQueryReady ($query) {
   const timeoutMs = imperativeQueryReadyTimeoutMs
   const startedAt = Date.now()
+  const ownerState = createImperativeOwnerState($query)
   while (true) {
+    if (isImperativeQueryCancelled($query, ownerState)) return
     if (isImperativeQueryReady($query)) {
       syncQueryDocsFromCollection($query)
       return
@@ -92,6 +96,28 @@ function isImperativeQueryReady ($query) {
   return true
 }
 
+function isImperativeQueryCancelled ($query, ownerState) {
+  const rootId = getRoot($query)?.[ROOT_ID]
+  if (isRootContextClosed(rootId)) return true
+  if (!ownerState?.wasTracked) return false
+  const trackedOwnerCount = ownerState.subscriptions.getTrackedOwnerCount(ownerState.ownerKey)
+  return trackedOwnerCount == null || trackedOwnerCount <= 0
+}
+
+function createImperativeOwnerState ($query) {
+  const hash = $query[HASH]
+  const rootId = normalizeRootId(getRoot($query)?.[ROOT_ID])
+  const subscriptions = ($query[IS_AGGREGATION] || isAggregationQuery($query[PARAMS]))
+    ? aggregationSubscriptions
+    : querySubscriptions
+  const ownerKey = getScopedSignalHash(rootId, hash, 'queryOwner')
+  return {
+    subscriptions,
+    ownerKey,
+    wasTracked: subscriptions.getTrackedOwnerCount(ownerKey) != null
+  }
+}
+
 function syncQueryDocsFromCollection ($query) {
   const params = $query[PARAMS]
   if ($query[IS_AGGREGATION] || isAggregationQuery(params) || isExtraQuery(params)) return

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.4.0-alpha.94",
+  "version": "0.4.0-alpha.96",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "index.js",
@@ -83,5 +83,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "28a9de4a846b5f36c31033c1c3486074cf9b86fc"
+  "gitHead": "78f33dc002740b425f3a056fad5b7e780a34219c"
 }

package/react/renderAttemptDestroyer.js

@@ -1,37 +1,46 @@
 class RenderAttemptDestroyer {
   constructor () {
     this.fns = []
-    this.compatArmed = false
+    this.compatAttemptCleanupArmed = false
+    this.suspenseGateArmed = false
   }
 
   add (fn, { compat = false } = {}) {
     if (typeof fn !== 'function') return
     this.fns.push(fn)
-    if (compat) this.compatArmed = true
+    if (compat) this.compatAttemptCleanupArmed = true
   }
 
-  armCompat () {
-    this.compatArmed = true
+  armCompatAttemptCleanup () {
+    this.compatAttemptCleanupArmed = true
   }
 
-  getDestructor () {
-    if (!this.compatArmed) {
-      this.reset()
-      return undefined
-    }
+  armSuspenseGate () {
+    this.suspenseGateArmed = true
+  }
 
-    const fns = [...this.fns]
+  consumeThenableHandling () {
+    const shouldRunAttemptCleanup = this.compatAttemptCleanupArmed && this.fns.length > 0
+    const shouldKeepShellAlive = this.suspenseGateArmed || shouldRunAttemptCleanup
+    let destroyAttempt
+    if (shouldRunAttemptCleanup) {
+      const fns = [...this.fns]
+      destroyAttempt = async () => {
+        await Promise.allSettled(fns.map(fn => fn()))
+        fns.length = 0
+      }
+    }
     this.reset()
-    return async () => {
-      if (fns.length === 0) return
-      await Promise.allSettled(fns.map(fn => fn()))
-      fns.length = 0
+    return {
+      shouldKeepShellAlive,
+      destroyAttempt
     }
   }
 
   reset () {
     this.fns.length = 0
-    this.compatArmed = false
+    this.compatAttemptCleanupArmed = false
+    this.suspenseGateArmed = false
   }
 }
 

package/react/trapRender.js

@@ -24,8 +24,11 @@ export default function trapRender ({ render, cache, destroy, componentId }) {
         destroyed = true
         throw err
       }
-      const destroyAttempt = renderAttemptDestroyer.getDestructor()
-      if (destroyAttempt) {
+      const {
+        shouldKeepShellAlive,
+        destroyAttempt
+      } = renderAttemptDestroyer.consumeThenableHandling()
+      if (shouldKeepShellAlive) {
         throw Promise.resolve(err).then(() => destroyAttempt?.())
       }
 

package/react/useSub.js

@@ -158,6 +158,7 @@ function maybeThrottle (promise) {
 function registerCompatAttemptCleanup (signal, params) {
   // Compat hooks don't build per-hook init objects like Racer.
   // We still need a marker so trapRender can defer observer-shell cleanup
-  // to Suspense resolution instead of tearing the whole shell down immediately.
-  renderAttemptDestroyer.armCompat()
+  // only when a real attempt cleanup exists.
+  // This path must not arm suspense-gate keep-alive by itself.
+  renderAttemptDestroyer.armCompatAttemptCleanup()
 }

package/react/useSuspendMemo.js

@@ -28,7 +28,7 @@ export default function useSuspendMemo (factory, deps) {
   if (entry.status === 'done') return entry.value
   if (entry.status === 'pending') {
     markCompatComponent(componentId)
-    renderAttemptDestroyer.armCompat()
+    renderAttemptDestroyer.armSuspenseGate()
     throw entry.promise
   }
 
@@ -47,7 +47,7 @@ export default function useSuspendMemo (factory, deps) {
     entry.status = 'pending'
     entry.promise = promise
     markCompatComponent(componentId)
-    renderAttemptDestroyer.armCompat()
+    renderAttemptDestroyer.armSuspenseGate()
     throw promise
   }
 }