teamplay 0.5.0-alpha.13 → 0.5.0-alpha.14

package/dist/orm/Compat/hooksCompat.js

@@ -247,7 +247,7 @@ function isExtraQuery(query) {
 const BATCH_SUB_OPTIONS = Object.freeze({
     async: false,
     batch: true,
-    compatAttemptCleanup: true,
+    renderAttemptCleanup: true,
     // Batch hooks are a hard suspense barrier. Deferred params can skip the barrier
     // on route transitions and cause immediate reads from stale/empty local nodes.
     defer: false
@@ -259,7 +259,7 @@ function normalizeSyncSubOptions(options) {
     return {
         ...(options || {}),
         async: false,
-        compatAttemptCleanup: true,
+        renderAttemptCleanup: true,
         // Compat sync hooks are strict by design: no deferred snapshots between route/tab switches.
         defer: false
     };

package/dist/react/renderAttemptDestroyer.d.ts

@@ -1,13 +1,13 @@
 type DestroyAttempt = () => unknown | Promise<unknown>;
 declare class RenderAttemptDestroyer {
     fns: DestroyAttempt[];
-    compatAttemptCleanupArmed: boolean;
+    renderAttemptCleanupArmed: boolean;
     suspenseGateArmed: boolean;
     constructor();
-    add(fn: DestroyAttempt | undefined, { compat }?: {
-        compat?: boolean;
+    add(fn: DestroyAttempt | undefined, { renderAttemptCleanup }?: {
+        renderAttemptCleanup?: boolean;
     }): void;
-    armCompatAttemptCleanup(): void;
+    armRenderAttemptCleanup(): void;
     armSuspenseGate(): void;
     consumeThenableHandling(): {
         shouldKeepShellAlive: boolean;

package/dist/react/renderAttemptDestroyer.js

@@ -1,27 +1,27 @@
 class RenderAttemptDestroyer {
     fns;
-    compatAttemptCleanupArmed;
+    renderAttemptCleanupArmed;
     suspenseGateArmed;
     constructor() {
         this.fns = [];
-        this.compatAttemptCleanupArmed = false;
+        this.renderAttemptCleanupArmed = false;
         this.suspenseGateArmed = false;
     }
-    add(fn, { compat = false } = {}) {
+    add(fn, { renderAttemptCleanup = false } = {}) {
         if (typeof fn !== 'function')
             return;
         this.fns.push(fn);
-        if (compat)
-            this.compatAttemptCleanupArmed = true;
+        if (renderAttemptCleanup)
+            this.renderAttemptCleanupArmed = true;
     }
-    armCompatAttemptCleanup() {
-        this.compatAttemptCleanupArmed = true;
+    armRenderAttemptCleanup() {
+        this.renderAttemptCleanupArmed = true;
     }
     armSuspenseGate() {
         this.suspenseGateArmed = true;
     }
     consumeThenableHandling() {
-        const shouldRunAttemptCleanup = this.compatAttemptCleanupArmed && this.fns.length > 0;
+        const shouldRunAttemptCleanup = this.renderAttemptCleanupArmed && this.fns.length > 0;
         const shouldKeepShellAlive = this.suspenseGateArmed || shouldRunAttemptCleanup;
         let destroyAttempt;
         if (shouldRunAttemptCleanup) {
@@ -39,7 +39,7 @@ class RenderAttemptDestroyer {
     }
     reset() {
         this.fns.length = 0;
-        this.compatAttemptCleanupArmed = false;
+        this.renderAttemptCleanupArmed = false;
         this.suspenseGateArmed = false;
     }
 }

package/dist/react/useSub.d.ts

@@ -7,8 +7,8 @@ export interface UseSubOptions {
     defer?: boolean | number;
     /** Batch Suspense promises across multiple subscriptions in one render attempt. */
     batch?: boolean;
-    /** Enable compatibility cleanup for legacy observer render attempts. */
-    compatAttemptCleanup?: boolean;
+    /** Enable cleanup for observer render attempts when a subscription suspends. */
+    renderAttemptCleanup?: boolean;
 }
 /**
  * Subscribe to a document signal in React async mode.
@@ -112,8 +112,8 @@ export default function useSub<TDocument, TDocumentModel extends SignalModelCons
  * @param options Subscription behavior options.
  */
 export default function useSub<TOutput = unknown, TCollection extends string = string>(signal: AggregationFunction<TOutput, TCollection>, params?: AggregationParams, options?: UseSubOptions): SubResult<AggregationFunction<TOutput, TCollection>, AggregationParams | undefined>;
-export declare function useSubDeferred(signal: unknown, params?: unknown, { async, defer, batch, compatAttemptCleanup }?: UseSubOptions): unknown;
-export declare function useSubClassic(signal: unknown, params?: unknown, { async, batch, compatAttemptCleanup }?: UseSubOptions): unknown;
+export declare function useSubDeferred(signal: unknown, params?: unknown, { async, defer, batch, renderAttemptCleanup }?: UseSubOptions): unknown;
+export declare function useSubClassic(signal: unknown, params?: unknown, { async, batch, renderAttemptCleanup }?: UseSubOptions): unknown;
 export declare function setTestThrottling(ms: number): void;
 export declare function resetTestThrottling(): void;
 export declare function setUseDeferredValue(value: boolean): void;

package/dist/react/useSub.js

@@ -27,12 +27,12 @@ function runUseSub(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 } = {}) {
+export function useSubDeferred(signal, params, { async = false, defer, batch = false, renderAttemptCleanup = false } = {}) {
     const $signalRef = useRef();
     const componentId = useId();
     const scheduleUpdate = useScheduleUpdate();
     const observerDefer = useDefer();
-    if (compatAttemptCleanup)
+    if (renderAttemptCleanup)
         markCompatComponent(componentId);
     if (batch)
         promiseBatcher.activate();
@@ -52,8 +52,8 @@ export function useSubDeferred(signal, params, { async = false, defer, batch = f
             // On resubscribe we keep rendering previous signal and refresh in background.
             if (!hasPreviousSignal) {
                 promiseBatcher.add(promise);
-                if (compatAttemptCleanup)
-                    registerCompatAttemptCleanup(signal, params);
+                if (renderAttemptCleanup)
+                    registerRenderAttemptCleanup(signal, params);
             }
             else {
                 scheduleUpdate(promise);
@@ -71,8 +71,8 @@ export function useSubDeferred(signal, params, { async = false, defer, batch = f
             scheduleUpdate(promise);
             return $signalRef.current;
         }
-        if (compatAttemptCleanup)
-            registerCompatAttemptCleanup(signal, params);
+        if (renderAttemptCleanup)
+            registerRenderAttemptCleanup(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
     }
@@ -85,12 +85,12 @@ export function useSubDeferred(signal, params, { async = false, defer, batch = f
 }
 // classic version which initially throws promise for Suspense
 // 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 } = {}) {
+export function useSubClassic(signal, params, { async = false, batch = false, renderAttemptCleanup = false } = {}) {
     const id = executionContextTracker.newHookId();
     const componentId = useId();
     const cache = useCache(undefined);
     const scheduleUpdate = useScheduleUpdate();
-    if (compatAttemptCleanup)
+    if (renderAttemptCleanup)
         markCompatComponent(componentId);
     if (batch)
         promiseBatcher.activate();
@@ -104,8 +104,8 @@ export function useSubClassic(signal, params, { async = false, batch = false, co
             // On resubscribe we keep rendering previous signal and refresh in background.
             if (!hasPreviousSignal) {
                 promiseBatcher.add(promise);
-                if (compatAttemptCleanup)
-                    registerCompatAttemptCleanup(signal, params);
+                if (renderAttemptCleanup)
+                    registerRenderAttemptCleanup(signal, params);
             }
             else {
                 scheduleUpdate(promise);
@@ -126,8 +126,8 @@ export function useSubClassic(signal, params, { async = false, batch = false, co
                 scheduleUpdate(promise);
                 return;
             }
-            if (compatAttemptCleanup)
-                registerCompatAttemptCleanup(signal, params);
+            if (renderAttemptCleanup)
+                registerRenderAttemptCleanup(signal, params);
             // in regular mode we throw the promise to be caught by Suspense
             // this way we guarantee that the signal with all the data
             // will always be there when component is rendered
@@ -180,10 +180,10 @@ function isThenable(value) {
         (typeof value === 'object' || typeof value === 'function') &&
         typeof value.then === 'function';
 }
-function registerCompatAttemptCleanup(_signal, _params) {
-    // Compat hooks don't build per-hook init objects like Racer.
+function registerRenderAttemptCleanup(_signal, _params) {
+    // Legacy hooks don't build per-hook init objects like Racer.
     // We still need a marker so trapRender can defer observer-shell cleanup
     // only when a real attempt cleanup exists.
     // This path must not arm suspense-gate keep-alive by itself.
-    renderAttemptDestroyer.armCompatAttemptCleanup();
+    renderAttemptDestroyer.armRenderAttemptCleanup();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.5.0-alpha.13",
+  "version": "0.5.0-alpha.14",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "./dist/index.js",
@@ -134,5 +134,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "3b067b76508f175ddc12bff294f76682796185f8"
+  "gitHead": "84185ddad8cdbac3d2dfcc48cff3588e5ab99630"
 }