teamplay 0.4.0-alpha.57 → 0.4.0-alpha.59

package/orm/Compat/hooksCompat.js

@@ -119,10 +119,11 @@ export function useAsyncDoc (collection, id, options) {
 }
 
 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, normalizeQuery(query, 'useQuery'), normalizedOptions)
-  return $query
+  const $query = useSub($collection, normalizedQuery, normalizedOptions)
+  return isExtraQuery(normalizedQuery) ? $query.extra : $query
 }
 
 export function useQuery (collection, query, options) {
@@ -133,9 +134,11 @@ export function useQuery (collection, query, options) {
 }
 
 export function useAsyncQuery$ (collection, query, options) {
+  const normalizedQuery = normalizeQuery(query, 'useAsyncQuery')
   const $collection = getCollectionSignal(collection, query, 'useAsyncQuery')
-  const $query = useAsyncSub($collection, normalizeQuery(query, 'useAsyncQuery'), options)
-  return $query
+  const $query = useAsyncSub($collection, normalizedQuery, options)
+  if (!$query) return $query
+  return isExtraQuery(normalizedQuery) ? $query.extra : $query
 }
 
 export function useAsyncQuery (collection, query, options) {
@@ -150,7 +153,9 @@ export function useBatchQuery$ (collection, query, _options) {
   const $collection = getCollectionSignal(collection, query, 'useBatchQuery')
   registerBatchQueryReadinessCheck(collection, normalizedQuery)
   const options = _options ? { ..._options, ...BATCH_SUB_OPTIONS } : BATCH_SUB_OPTIONS
-  return useSub($collection, normalizedQuery, options)
+  const $query = useSub($collection, normalizedQuery, options)
+  if (!$query) return $query
+  return isExtraQuery(normalizedQuery) ? $query.extra : $query
 }
 
 export function useBatchQuery (collection, query, options) {
@@ -317,6 +322,15 @@ function normalizeQuery (query, hookName) {
   return query
 }
 
+function isExtraQuery (query) {
+  if (!query || typeof query !== 'object') return false
+  return !!(
+    query.$count ||
+    query.$queryName ||
+    query.$aggregationName
+  )
+}
+
 const BATCH_SUB_OPTIONS = Object.freeze({
   async: false,
   batch: true,
@@ -378,11 +392,20 @@ function registerBatchQueryReadinessCheck (collection, query) {
   const extraSegments = [QUERIES, hash, 'extra']
   const aggregationSegments = [AGGREGATIONS, hash]
   const isAggregate = Array.isArray(query.$aggregate)
+  const hasExtraResult = isExtraQuery(query)
   promiseBatcher.addCheck({
     key: `query:${hash}`,
-    type: 'query',
-    details: { collection, hash, query, isAggregate },
-    isReady: () => isQueryReady(collection, idsSegments, docsSegments, extraSegments, aggregationSegments, isAggregate),
+    type: hasExtraResult ? 'queryExtra' : 'query',
+    details: { collection, hash, query, isAggregate, hasExtraResult },
+    isReady: () => isQueryReady(
+      collection,
+      idsSegments,
+      docsSegments,
+      extraSegments,
+      aggregationSegments,
+      isAggregate,
+      hasExtraResult
+    ),
     getState: () => {
       const ids = getRaw(idsSegments)
       const docs = getRaw(docsSegments)
@@ -404,7 +427,18 @@ function registerBatchQueryReadinessCheck (collection, query) {
   })
 }
 
-function isQueryReady (collection, idsSegments, docsSegments, extraSegments, aggregationSegments, isAggregate) {
+function isQueryReady (
+  collection,
+  idsSegments,
+  docsSegments,
+  extraSegments,
+  aggregationSegments,
+  isAggregate,
+  hasExtraResult
+) {
+  if (hasExtraResult) {
+    return getRaw(extraSegments) !== undefined
+  }
   if (isAggregate) {
     const docs = getRaw(docsSegments)
     if (Array.isArray(docs)) return true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.4.0-alpha.57",
+  "version": "0.4.0-alpha.59",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "index.js",
@@ -83,5 +83,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "701b0938bed619d75fefd080814987de92451638"
+  "gitHead": "c981ac82c249772524a9ccd5ccb4f6d437af4e4c"
 }

package/react/compatComponentRegistry.js

@@ -0,0 +1,20 @@
+const compatComponentIds = new Set()
+
+export function markCompatComponent (componentId) {
+  if (!componentId) return
+  compatComponentIds.add(componentId)
+}
+
+export function unmarkCompatComponent (componentId) {
+  if (!componentId) return
+  compatComponentIds.delete(componentId)
+}
+
+export function isCompatComponent (componentId) {
+  if (!componentId) return false
+  return compatComponentIds.has(componentId)
+}
+
+export function __resetCompatComponentRegistryForTests () {
+  compatComponentIds.clear()
+}

package/react/convertToObserver.js

@@ -7,6 +7,7 @@ import executionContextTracker from './executionContextTracker.js'
 import { pipeComponentMeta, useUnmount, useId, useTriggerUpdate } from './helpers.js'
 import trapRender from './trapRender.js'
 import { scheduleReaction } from '../orm/batchScheduler.js'
+import { isCompatComponent, unmarkCompatComponent } from './compatComponentRegistry.js'
 
 const DEFAULT_THROTTLE_TIMEOUT = 100
 
@@ -33,15 +34,29 @@ export default function convertToObserver (BaseComponent, {
     const reactionRef = useRef()
     const destroyRef = useRef()
     if (!reactionRef.current) {
+      let hasDeferredUpdateAfterExecutionContext = false
       let update = () => {
         // It's important to block updates caused by rendering itself
         // (when the sync rendering is in progress).
-        if (!executionContextTracker.isActive()) triggerUpdate()
+        if (!executionContextTracker.isActive()) {
+          hasDeferredUpdateAfterExecutionContext = false
+          triggerUpdate()
+        } else if (isCompatComponent(componentId)) {
+          if (hasDeferredUpdateAfterExecutionContext) return
+          hasDeferredUpdateAfterExecutionContext = true
+          queueMicrotask(() => {
+            if (!hasDeferredUpdateAfterExecutionContext) return
+            if (executionContextTracker.isActive()) return
+            hasDeferredUpdateAfterExecutionContext = false
+            update()
+          })
+        }
       }
       if (throttle) update = _throttle(update, throttle)
       destroyRef.current = (where) => {
         if (!reactionRef.current) throw Error(`NO REACTION REF - ${where}`)
         destroyRef.current = undefined
+        unmarkCompatComponent(componentId)
         unobserve(reactionRef.current)
         reactionRef.current = undefined
         destroyCache(where)
@@ -60,6 +75,7 @@ export default function convertToObserver (BaseComponent, {
 
     // clean up observer on unmount
     useUnmount(() => {
+      unmarkCompatComponent(componentId)
       destroyRef.current?.('useUnmount()')
     })
 

package/react/useSub.js

@@ -1,9 +1,10 @@
 import { useRef, useDeferredValue } from 'react'
 import sub from '../orm/sub.js'
-import { useScheduleUpdate, useCache, useDefer } from './helpers.js'
+import { useScheduleUpdate, useCache, useDefer, useId } from './helpers.js'
 import executionContextTracker from './executionContextTracker.js'
 import * as promiseBatcher from './promiseBatcher.js'
 import renderAttemptDestroyer from './renderAttemptDestroyer.js'
+import { markCompatComponent } from './compatComponentRegistry.js'
 
 let TEST_THROTTLING = false
 
@@ -28,8 +29,10 @@ export default function useSub (signal, params, options) {
 // version of sub() which works as a react hook and throws promise for Suspense
 export function useSubDeferred (signal, params, { async = false, defer, batch = false, compatAttemptCleanup = false } = {}) {
   const $signalRef = useRef() // eslint-disable-line react-hooks/rules-of-hooks
+  const componentId = useId()
   const scheduleUpdate = useScheduleUpdate()
   const observerDefer = useDefer()
+  if (compatAttemptCleanup) markCompatComponent(componentId)
   if (batch) promiseBatcher.activate()
   defer ??= observerDefer ?? DEFAULT_DEFER
   if (defer) {
@@ -72,9 +75,11 @@ export function useSubDeferred (signal, params, { async = false, defer, batch =
 // but if we get a promise second time, we return the last signal and wait for promise to resolve
 export function useSubClassic (signal, params, { async = false, batch = false, compatAttemptCleanup = false } = {}) {
   const id = executionContextTracker.newHookId()
+  const componentId = useId()
   const cache = useCache()
   const activePromiseRef = useRef()
   const scheduleUpdate = useScheduleUpdate()
+  if (compatAttemptCleanup) markCompatComponent(componentId)
   if (batch) promiseBatcher.activate()
   const promiseOrSignal = params != null ? sub(signal, params) : sub(signal)
   // 1. if it's a promise, throw it so that Suspense can catch it and wait for subscription to finish