teamplay 0.5.0-alpha.13 → 0.5.0-alpha.15

package/dist/orm/Compat/hooksCompat.js

@@ -247,7 +247,6 @@ function isExtraQuery(query) {
 const BATCH_SUB_OPTIONS = Object.freeze({
     async: false,
     batch: true,
-    compatAttemptCleanup: 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 +258,6 @@ function normalizeSyncSubOptions(options) {
     return {
         ...(options || {}),
         async: false,
-        compatAttemptCleanup: true,
         // Compat sync hooks are strict by design: no deferred snapshots between route/tab switches.
         defer: false
     };

package/dist/react/convertToObserver.js

@@ -7,7 +7,6 @@ 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;
 export default function convertToObserver(BaseComponent, { forwardRef, cache: enableCache = true, throttle, ...options } = {}) {
     throttle = normalizeThrottle(throttle);
@@ -33,7 +32,7 @@ export default function convertToObserver(BaseComponent, { forwardRef, cache: en
                     hasDeferredUpdateAfterExecutionContext = false;
                     triggerUpdate();
                 }
-                else if (isCompatComponent(componentId)) {
+                else {
                     if (hasDeferredUpdateAfterExecutionContext)
                         return;
                     hasDeferredUpdateAfterExecutionContext = true;
@@ -53,7 +52,6 @@ export default function convertToObserver(BaseComponent, { forwardRef, cache: en
                 if (!reactionRef.current)
                     throw Error(`NO REACTION REF - ${where}`);
                 destroyRef.current = undefined;
-                unmarkCompatComponent(componentId);
                 unobserve(reactionRef.current);
                 reactionRef.current = undefined;
                 destroyCache(where);
@@ -71,7 +69,6 @@ export default function convertToObserver(BaseComponent, { forwardRef, cache: en
         }
         // clean up observer on unmount
         useUnmount(() => {
-            unmarkCompatComponent(componentId);
             destroyRef.current?.('useUnmount()');
         });
         return reactionRef.current(...args);

package/dist/react/renderAttemptDestroyer.d.ts

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

package/dist/react/renderAttemptDestroyer.js

@@ -1,45 +1,19 @@
 class RenderAttemptDestroyer {
-    fns;
-    compatAttemptCleanupArmed;
     suspenseGateArmed;
     constructor() {
-        this.fns = [];
-        this.compatAttemptCleanupArmed = false;
         this.suspenseGateArmed = false;
     }
-    add(fn, { compat = false } = {}) {
-        if (typeof fn !== 'function')
-            return;
-        this.fns.push(fn);
-        if (compat)
-            this.compatAttemptCleanupArmed = true;
-    }
-    armCompatAttemptCleanup() {
-        this.compatAttemptCleanupArmed = true;
-    }
     armSuspenseGate() {
         this.suspenseGateArmed = true;
     }
     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;
-            };
-        }
+        const shouldKeepShellAlive = this.suspenseGateArmed;
         this.reset();
         return {
-            shouldKeepShellAlive,
-            destroyAttempt
+            shouldKeepShellAlive
         };
     }
     reset() {
-        this.fns.length = 0;
-        this.compatAttemptCleanupArmed = false;
         this.suspenseGateArmed = false;
     }
 }

package/dist/react/trapRender.js

@@ -24,9 +24,9 @@ export default function trapRender({ render, cache, destroy, componentId }) {
                 destroyed = true;
                 throw err;
             }
-            const { shouldKeepShellAlive, destroyAttempt } = renderAttemptDestroyer.consumeThenableHandling();
+            const { shouldKeepShellAlive } = renderAttemptDestroyer.consumeThenableHandling();
             if (shouldKeepShellAlive) {
-                throw Promise.resolve(err).then(() => destroyAttempt?.());
+                throw Promise.resolve(err);
             }
             // TODO: this might only be needed only if promise is thrown
             //       (check if useUnmount in convertToObserver is called if a regular error is thrown)

package/dist/react/useSub.d.ts

@@ -1,5 +1,5 @@
 import type { AggregationFunction, AggregationParams, ClientAggregationFunction } from '@teamplay/utils/aggregation';
-import type { CollectionSignal, ComputedQueryParamsInput, DocumentSignal, QueryParams, RegisteredAggregationInput, SignalModelConstructor, SubResult, TypedAggregationInput, TypedAggregationSignal, WildcardSignalPath } from '../orm/Signal.js';
+import { type CollectionSignal, type ComputedQueryParamsInput, type DocumentSignal, type QueryParams, type RegisteredAggregationInput, type SignalModelConstructor, type SubResult, type TypedAggregationInput, type TypedAggregationSignal, type WildcardSignalPath } from '../orm/Signal.js';
 export interface UseSubOptions {
     /** Return `undefined` while loading instead of throwing a Suspense promise. */
     async?: boolean;
@@ -7,9 +7,14 @@ 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;
 }
+/**
+ * Subscribe to a document signal in React async mode.
+ * @param signal Document signal to subscribe to.
+ * @param params Must be omitted for document subscriptions.
+ * @param options Subscription behavior options.
+ */
+export declare function useAsyncSub<TSignal extends DocumentSignal<any, any, any>>(signal: TSignal, options?: UseSubOptions): SubResult<TSignal>;
 /**
  * Subscribe to a document signal in React async mode.
  * @param signal Document signal to subscribe to.
@@ -61,6 +66,13 @@ export declare function useAsyncSub<TDocument, TDocumentModel extends SignalMode
  * @param options Subscription behavior options.
  */
 export declare function useAsyncSub<TOutput = unknown, TCollection extends string = string>(signal: AggregationFunction<TOutput, TCollection>, params?: AggregationParams, options?: UseSubOptions): SubResult<AggregationFunction<TOutput, TCollection>, AggregationParams | undefined>;
+/**
+ * Subscribe to a document signal in React.
+ * @param signal Document signal to subscribe to.
+ * @param params Must be omitted for document subscriptions.
+ * @param options Subscription behavior options.
+ */
+export default function useSub<TSignal extends DocumentSignal<any, any, any>>(signal: TSignal, options?: UseSubOptions): SubResult<TSignal>;
 /**
  * Subscribe to a document signal in React.
  * @param signal Document signal to subscribe to.
@@ -112,8 +124,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 }?: UseSubOptions): unknown;
+export declare function useSubClassic(signal: unknown, params?: unknown, { async, batch }?: 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

@@ -1,11 +1,11 @@
 import { useRef, useDeferredValue } from 'react';
 import sub from "../orm/sub.js";
-import { useScheduleUpdate, useCache, useDefer, useId } from "./helpers.js";
+import { useScheduleUpdate, useCache, useDefer } from "./helpers.js";
 import executionContextTracker from "./executionContextTracker.js";
 import * as promiseBatcher from "./promiseBatcher.js";
-import renderAttemptDestroyer from "./renderAttemptDestroyer.js";
-import { markCompatComponent } from "./compatComponentRegistry.js";
+import { isPublicDocumentSignal } from "../orm/Signal.js";
 const runtimeSub = sub;
+const USE_SUB_OPTION_KEYS = new Set(['async', 'defer', 'batch']);
 let TEST_THROTTLING = false;
 // experimental feature to leverage useDeferredValue() to handle re-subscriptions.
 // Currently it does lead to issues with extra rerenders and requires further investigation
@@ -13,10 +13,27 @@ let USE_DEFERRED_VALUE = true;
 // by default we want to defer stuff if possible instead of throwing promises
 let DEFAULT_DEFER = true;
 export function useAsyncSub(signal, params, options) {
-    return runUseSub(signal, params, { ...options, async: true });
+    const normalized = normalizeUseSubArgs(signal, params, options);
+    return runUseSub(normalized.signal, normalized.params, { ...normalized.options, async: true });
 }
 export default function useSub(signal, params, options) {
-    return runUseSub(signal, params, options);
+    const normalized = normalizeUseSubArgs(signal, params, options);
+    return runUseSub(normalized.signal, normalized.params, normalized.options);
+}
+function normalizeUseSubArgs(signal, params, options) {
+    if (options === undefined && params !== undefined && isPublicDocumentSignal(signal) && isUseSubOptions(params)) {
+        return {
+            signal,
+            params: undefined,
+            options: params
+        };
+    }
+    return { signal, params, options };
+}
+function isUseSubOptions(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    return Object.keys(value).every(key => USE_SUB_OPTION_KEYS.has(key));
 }
 function runUseSub(signal, params, options) {
     if (USE_DEFERRED_VALUE) {
@@ -27,13 +44,10 @@ 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 } = {}) {
     const $signalRef = useRef();
-    const componentId = useId();
     const scheduleUpdate = useScheduleUpdate();
     const observerDefer = useDefer();
-    if (compatAttemptCleanup)
-        markCompatComponent(componentId);
     if (batch)
         promiseBatcher.activate();
     defer ??= observerDefer ?? DEFAULT_DEFER;
@@ -52,8 +66,6 @@ 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);
             }
             else {
                 scheduleUpdate(promise);
@@ -71,8 +83,6 @@ export function useSubDeferred(signal, params, { async = false, defer, batch = f
             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
     }
@@ -85,13 +95,10 @@ 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 } = {}) {
     const id = executionContextTracker.newHookId();
-    const componentId = useId();
     const cache = useCache(undefined);
     const scheduleUpdate = useScheduleUpdate();
-    if (compatAttemptCleanup)
-        markCompatComponent(componentId);
     if (batch)
         promiseBatcher.activate();
     const promiseOrSignal = params != null ? runtimeSub(signal, params) : runtimeSub(signal);
@@ -104,8 +111,6 @@ 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);
             }
             else {
                 scheduleUpdate(promise);
@@ -126,8 +131,6 @@ export function useSubClassic(signal, params, { async = false, batch = false, co
                 scheduleUpdate(promise);
                 return;
             }
-            if (compatAttemptCleanup)
-                registerCompatAttemptCleanup(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 +183,3 @@ 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.
-    // 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();
-}

package/dist/react/useSuspendMemo.js

@@ -1,13 +1,11 @@
 import executionContextTracker from "./executionContextTracker.js";
-import { useCache, useId } from "./helpers.js";
-import { markCompatComponent } from "./compatComponentRegistry.js";
+import { useCache } from "./helpers.js";
 import renderAttemptDestroyer from "./renderAttemptDestroyer.js";
 const IN_FLIGHT_BY_KEY = new Map();
 export default function useSuspendMemo(factory, deps) {
     if (typeof factory !== 'function')
         throw Error('useSuspendMemo() expects a factory function');
     deps = normalizeDeps(deps);
-    const componentId = useId();
     const cache = useCache(undefined);
     const hookId = executionContextTracker.newHookId();
     const cacheKey = `suspendMemo:${hookId}`;
@@ -24,7 +22,6 @@ export default function useSuspendMemo(factory, deps) {
     if (entry.status === 'done')
         return entry.value;
     if (entry.status === 'pending') {
-        markCompatComponent(componentId);
         renderAttemptDestroyer.armSuspenseGate();
         throw entry.promise;
     }
@@ -45,7 +42,6 @@ export default function useSuspendMemo(factory, deps) {
         });
         entry.status = 'pending';
         entry.promise = promise;
-        markCompatComponent(componentId);
         renderAttemptDestroyer.armSuspenseGate();
         throw promise;
     }

package/package.json

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

package/dist/react/compatComponentRegistry.d.ts

@@ -1,4 +0,0 @@
-export declare function markCompatComponent(componentId: string | undefined): void;
-export declare function unmarkCompatComponent(componentId: string | undefined): void;
-export declare function isCompatComponent(componentId: string | undefined): boolean;
-export declare function __resetCompatComponentRegistryForTests(): void;

package/dist/react/compatComponentRegistry.js

@@ -1,19 +0,0 @@
-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();
-}