teamplay 0.5.0-alpha.2 → 0.5.0-alpha.21

package/dist/orm/types/modelManifest.d.ts

@@ -1,5 +1,6 @@
 import type { Signal as BaseSignal } from '../SignalBase.js';
 import type { CollectionSpec, JsonSchemaSpec, SignalClass } from './signal.js';
+import type { FromJsonSchema } from './jsonSchema.js';
 export interface ModelEntry<TModel extends SignalClass<any> = SignalClass<any>, TSchema = unknown> {
     default?: TModel;
     schema?: TSchema;
@@ -8,10 +9,14 @@ export interface ModelEntry<TModel extends SignalClass<any> = SignalClass<any>,
 }
 export type ModelManifest = Record<string, ModelEntry>;
 type StringKey<TValue> = Extract<keyof TValue, string>;
-type CollectionManifestKey<TKey extends string> = TKey extends '' ? never : TKey extends `${string}.${string}` ? never : TKey extends `${string}*${string}` ? never : TKey;
+type CollectionManifestKey<TKey extends string> = TKey extends '' ? never : TKey extends `_${string}` | `$${string}` ? never : TKey extends `${string}.${string}` ? never : TKey extends `${string}*${string}` ? never : TKey;
+type PrivateCollectionManifestKey<TKey extends string> = TKey extends '' ? never : TKey extends `${string}.${string}` ? never : TKey extends `${string}*${string}` ? never : TKey extends `_${string}` | `$${string}` ? TKey : never;
 type CollectionManifestKeys<TModels> = {
     [K in StringKey<TModels>]: CollectionManifestKey<K>;
 }[StringKey<TModels>];
+type PrivateCollectionManifestKeys<TModels> = {
+    [K in StringKey<TModels>]: PrivateCollectionManifestKey<K>;
+}[StringKey<TModels>];
 type ModelPathManifestKey<TKey extends string> = TKey extends '' ? never : TKey extends `${string}*${string}` ? TKey : never;
 type ModelPathManifestKeys<TModels> = {
     [K in StringKey<TModels>]: ModelPathManifestKey<K>;
@@ -26,9 +31,15 @@ type SchemaFromEntry<TEntry> = TEntry extends {
 type CollectionSpecFromManifestEntry<TModels, TCollection extends string> = [
     SchemaFromEntry<ManifestEntry<TModels, TCollection>>
 ] extends [never] ? CollectionSpec<unknown, ModelFromEntry<ManifestEntry<TModels, TCollection>>, ModelFromEntry<ManifestEntry<TModels, `${TCollection}.*`>>> : JsonSchemaSpec<SchemaFromEntry<ManifestEntry<TModels, TCollection>>, ModelFromEntry<ManifestEntry<TModels, TCollection>>, ModelFromEntry<ManifestEntry<TModels, `${TCollection}.*`>>>;
+type PrivateCollectionValueFromManifestEntry<TModels, TCollection extends string> = [
+    SchemaFromEntry<ManifestEntry<TModels, TCollection>>
+] extends [never] ? unknown : FromJsonSchema<SchemaFromEntry<ManifestEntry<TModels, TCollection>>>;
 export type CollectionsFromManifest<TModels extends Record<string, any>> = {
     [K in CollectionManifestKeys<TModels>]: CollectionSpecFromManifestEntry<TModels, K>;
 };
+export type PrivateCollectionsFromManifest<TModels extends Record<string, any>> = {
+    [K in PrivateCollectionManifestKeys<TModels>]: PrivateCollectionValueFromManifestEntry<TModels, K>;
+};
 export type PathModelsFromManifest<TModels extends Record<string, any>> = {
     [K in ModelPathManifestKeys<TModels> as ManifestEntry<TModels, K> extends {
         default: any;

package/dist/orm/types/query.d.ts

@@ -16,14 +16,20 @@ type QueryValue<TValue> = QueryComparable<TValue> | {
     $exists?: boolean;
     $regex?: TValue extends string ? string | RegExp : never;
 };
+type QuerySortDirection = 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending';
+type QuerySort<TDocument> = {
+    [K in QueryPath<TDocument> | '_id' | 'id']?: QuerySortDirection;
+};
 export type QueryParams<TDocument> = {
     [K in QueryPath<TDocument>]?: QueryValue<QueryPathValue<TDocument, K>>;
 } & {
     _id?: QueryValue<string | number>;
     id?: QueryValue<string | number>;
 } & {
-    [K in `${string}.${string}`]?: unknown;
+    $sort?: QuerySort<TDocument>;
 } & {
     [K in `$${string}`]?: unknown;
 };
+export type ComputedQueryParamsInput<TParams extends object> = string extends keyof TParams ? TParams : never;
+export type QueryParamsInput<TDocument, TParams extends object> = TParams extends QueryParams<TDocument> ? TParams : ComputedQueryParamsInput<TParams>;
 export {};

package/dist/orm/types/signal.d.ts

@@ -1,4 +1,4 @@
-import type { TeamplayCollections, TeamplayModels, TeamplaySignalFields } from '../../index.js';
+import type { TeamplayCollections, TeamplayPrivateCollections, TeamplayPluginPrivateCollections, TeamplayModels, TeamplayPluginCollections, TeamplayPluginModels, TeamplayPluginSignalFields, TeamplaySignalFields } from '../../index.js';
 import type { Signal, GETTERS } from '../SignalBase.js';
 import type { FromJsonSchema, InferZodSchema, JsonSchema, ZodLikeSchema } from './jsonSchema.js';
 import type { AppendPath, JoinPath, PathSegment, WildcardSignalPath } from './path.js';
@@ -20,11 +20,29 @@ type SignalQueryMethodKeys = SignalArrayReaderMethodKeys | SignalArrayMutatorMet
 type BlockedArrayMutators = {
     readonly [K in SignalArrayMutatorMethodKeys]?: never;
 };
+type UnionToIntersection<TValue> = (TValue extends unknown ? (value: TValue) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
+type RegistryValues<TRegistry> = TRegistry[keyof TRegistry & string];
+type MergeRegistry<TRegistry> = [
+    RegistryValues<TRegistry>
+] extends [never] ? {} : UnionToIntersection<RegistryValues<TRegistry>>;
+type EffectiveTeamplayCollections = TeamplayCollections & MergeRegistry<TeamplayPluginCollections>;
+type EffectiveTeamplayPrivateCollections = TeamplayPrivateCollections & MergeRegistry<TeamplayPluginPrivateCollections>;
+type EffectiveTeamplayModels = TeamplayModels & MergeRegistry<TeamplayPluginModels>;
+type EffectiveTeamplaySignalFields = TeamplaySignalFields & MergeRegistry<TeamplayPluginSignalFields>;
+type RootDollarAliases = {
+    readonly session: '_session';
+    readonly page: '_page';
+    readonly render: '$render';
+    readonly system: '$system';
+};
 type SignalArrayLike<TItem> = SignalArrayReaderMethods<TItem>;
-type PathModel<TValue, TDefaultModel extends SignalClass<any>, TPath extends WildcardSignalPath> = JoinPath<TPath> extends keyof TeamplayModels ? TeamplayModels[JoinPath<TPath>] extends SignalClass<TValue> ? TeamplayModels[JoinPath<TPath>] : TeamplayModels[JoinPath<TPath>] extends SignalClass<any> ? TeamplayModels[JoinPath<TPath>] : TDefaultModel : TDefaultModel;
+type PathModel<TValue, TDefaultModel extends SignalClass<any>, TPath extends WildcardSignalPath> = JoinPath<TPath> extends keyof EffectiveTeamplayModels ? EffectiveTeamplayModels[JoinPath<TPath>] extends SignalClass<TValue> ? EffectiveTeamplayModels[JoinPath<TPath>] : EffectiveTeamplayModels[JoinPath<TPath>] extends SignalClass<any> ? EffectiveTeamplayModels[JoinPath<TPath>] : TDefaultModel : TDefaultModel;
 type ArrayItemSignal<Item, TPath extends WildcardSignalPath> = DocumentSignal<Item, typeof Signal, AppendPath<TPath, '*'>>;
 type SignalArrayMethods<TValue, TPath extends WildcardSignalPath> = NonNullable<TValue> extends ReadonlyArray<infer Item> ? SignalArrayLike<ArrayItemSignal<Item, TPath>> : Pick<Signal<TValue>, SignalArrayReaderMethodKeys>;
-type SignalFieldsForPath<TPath extends WildcardSignalPath> = JoinPath<TPath> extends keyof TeamplaySignalFields ? TeamplaySignalFields[JoinPath<TPath>] : {};
+type SignalFieldsForPath<TPath extends WildcardSignalPath> = JoinPath<TPath> extends keyof EffectiveTeamplaySignalFields ? EffectiveTeamplaySignalFields[JoinPath<TPath>] : {};
+type DocumentSignalIdMethod = {
+    getId: () => string;
+};
 export type AnySignal = Signal<any>;
 type IsAny<TValue> = 0 extends (1 & TValue) ? true : false;
 type IsUnknown<TValue> = IsAny<TValue> extends true ? false : unknown extends TValue ? true : false;
@@ -34,7 +52,7 @@ type IsUnion<TValue, TUnion = TValue> = [
 ] extends [never] ? false : TValue extends unknown ? [TUnion] extends [TValue] ? false : true : false;
 type SingleKey<TKey> = IsUnion<TKey> extends true ? never : TKey;
 export type SignalKind = 'root' | 'document' | 'collection' | 'nestedValue' | 'localArray' | 'array' | 'query' | 'aggregation' | 'collectionQuery';
-type DocumentSignalForKind<TValue, TModel extends SignalClass<any>, TPath extends WildcardSignalPath> = Omit<SignalModelInstance<TValue, PathModel<TValue, TModel, TPath>>, SignalArrayReaderMethodKeys> & SignalArrayMethods<TValue, TPath> & SignalChildren<TValue, TPath> & SignalFieldsForPath<TPath>;
+type DocumentSignalForKind<TValue, TModel extends SignalClass<any>, TPath extends WildcardSignalPath> = Omit<SignalModelInstance<TValue, PathModel<TValue, TModel, TPath>>, SignalArrayReaderMethodKeys | 'getId'> & DocumentSignalIdMethod & SignalArrayMethods<TValue, TPath> & SignalChildren<TValue, TPath> & SignalFieldsForPath<TPath>;
 type CollectionSignalForKind<TDocument, TCollectionModel extends SignalClass<any>, TDocumentModel extends SignalClass<any>, TPath extends WildcardSignalPath> = Omit<SignalModelInstance<TDocument[], PathModel<TDocument[], TCollectionModel, TPath>>, SignalCollectionMethodKeys> & SignalArrayLike<CollectionDocumentSignal<TDocument, TDocumentModel, TPath>> & BlockedArrayMutators & {
     add: (value: TDocument) => Promise<string>;
 } & CollectionDocumentIndex<CollectionDocumentSignal<TDocument, TDocumentModel, TPath>>;
@@ -43,7 +61,7 @@ type ArraySignalForKind<TDocument, TDocumentModel extends SignalClass<any>, TDoc
     readonly [index: number]: DocumentSignal<TDocument, TDocumentModel, TDocumentPath>;
 } & BlockedArrayMutators;
 type QueryMetadataSignals = {
-    readonly ids: Signal<Array<string | number>>;
+    readonly ids: Signal<string[]>;
     readonly extra: Signal<unknown>;
 };
 type QuerySignalForKind<TDocument, TDocumentModel extends SignalClass<any>, TDocumentPath extends WildcardSignalPath> = ArraySignalForKind<TDocument, TDocumentModel, TDocumentPath> & QueryMetadataSignals;
@@ -59,22 +77,22 @@ export type CollectionDocument<TSpec> = TSpec extends CollectionSpec<infer Docum
 export type CollectionDocumentModel<TSpec> = TSpec extends CollectionSpec<any, any, infer DocumentModel> ? DocumentModel : typeof Signal;
 export type CollectionQuerySignal<TDocument, TCollectionModel extends SignalClass<any>, TDocumentModel extends SignalClass<any>, TCollectionPath extends WildcardSignalPath> = CollectionSignalForKind<TDocument, TCollectionModel, TDocumentModel, TCollectionPath> & QueryMetadataSignals;
 type MatchingDocumentCollectionKeys<TValue> = IsAny<TValue> extends true ? never : {
-    [K in keyof TeamplayCollections & string]: IsEqual<NonNullable<TValue>, NonNullable<CollectionDocument<TeamplayCollections[K]>>> extends true ? K : never;
-}[keyof TeamplayCollections & string];
+    [K in keyof EffectiveTeamplayCollections & string]: IsEqual<NonNullable<TValue>, NonNullable<CollectionDocument<EffectiveTeamplayCollections[K]>>> extends true ? K : never;
+}[keyof EffectiveTeamplayCollections & string];
 type MatchingCollectionKeys<TValue> = IsAny<TValue> extends true ? never : NonNullable<TValue> extends ReadonlyArray<infer TDocument> ? MatchingDocumentCollectionKeys<TDocument> : never;
 type SingleDocumentCollectionKey<TValue> = SingleKey<MatchingDocumentCollectionKeys<TValue>>;
 type SingleCollectionKey<TValue> = SingleKey<MatchingCollectionKeys<TValue>>;
 type DocumentSignalModelForValue<TValue> = [
     SingleDocumentCollectionKey<TValue>
-] extends [never] ? typeof Signal : SingleDocumentCollectionKey<TValue> extends keyof TeamplayCollections & string ? CollectionDocumentModel<TeamplayCollections[SingleDocumentCollectionKey<TValue>]> : typeof Signal;
+] extends [never] ? typeof Signal : SingleDocumentCollectionKey<TValue> extends keyof EffectiveTeamplayCollections & string ? CollectionDocumentModel<EffectiveTeamplayCollections[SingleDocumentCollectionKey<TValue>]> : typeof Signal;
 type DocumentSignalPathForValue<TValue> = [
     SingleDocumentCollectionKey<TValue>
-] extends [never] ? readonly [] : SingleDocumentCollectionKey<TValue> extends keyof TeamplayCollections & string ? readonly [SingleDocumentCollectionKey<TValue>, '*'] : readonly [];
+] extends [never] ? readonly [] : SingleDocumentCollectionKey<TValue> extends keyof EffectiveTeamplayCollections & string ? readonly [SingleDocumentCollectionKey<TValue>, '*'] : readonly [];
 type SignalForDocumentValue<TValue> = TypedSignal<TValue, DocumentSignalModelForValue<TValue>, DocumentSignalPathForValue<TValue>>;
-type SignalForCollectionArrayValue<TCollection extends keyof TeamplayCollections & string> = CollectionSignal<CollectionDocument<TeamplayCollections[TCollection]>, TeamplayCollections[TCollection] extends CollectionSpec<any, infer CollectionModel, any> ? CollectionModel : typeof Signal, CollectionDocumentModel<TeamplayCollections[TCollection]>, readonly [TCollection]>;
+type SignalForCollectionArrayValue<TCollection extends keyof EffectiveTeamplayCollections & string> = CollectionSignal<CollectionDocument<EffectiveTeamplayCollections[TCollection]>, EffectiveTeamplayCollections[TCollection] extends CollectionSpec<any, infer CollectionModel, any> ? CollectionModel : typeof Signal, CollectionDocumentModel<EffectiveTeamplayCollections[TCollection]>, readonly [TCollection]>;
 type SignalForArrayValue<TValue> = [
     SingleCollectionKey<TValue>
-] extends [never] ? SignalForDocumentValue<TValue> : SingleCollectionKey<TValue> extends keyof TeamplayCollections & string ? SignalForCollectionArrayValue<SingleCollectionKey<TValue>> : SignalForDocumentValue<TValue>;
+] extends [never] ? SignalForDocumentValue<TValue> : SingleCollectionKey<TValue> extends keyof EffectiveTeamplayCollections & string ? SignalForCollectionArrayValue<SingleCollectionKey<TValue>> : SignalForDocumentValue<TValue>;
 export type PublicSignal<TValue = unknown> = IsAny<TValue> extends true ? TypedSignal<TValue> : NonNullable<TValue> extends ReadonlyArray<any> ? SignalForArrayValue<TValue> : SignalForDocumentValue<TValue>;
 export interface LocalSignalFactory {
     (): any;
@@ -82,12 +100,12 @@ export interface LocalSignalFactory {
     <TValue>(factory: () => TValue): TypedSignal<TValue>;
     <TValue>(value: TValue): TypedSignal<TValue>;
 }
-export type RootCollections<TCollections extends Record<string, any> = TeamplayCollections> = {
+export type RootCollections<TCollections = EffectiveTeamplayCollections> = {
     readonly [K in keyof TCollections & string]: CollectionSignalFromSpec<TCollections[K], readonly [K]>;
 } & {
     readonly [K in keyof TCollections & string as `$${K}`]: CollectionSignalFromSpec<TCollections[K], readonly [K]>;
 };
-export type RootSignal<TCollections extends Record<string, any> = TeamplayCollections> = Signal<Record<string, unknown>> & LocalSignalFactory & RootCollections<TCollections>;
+export type RootSignal<TCollections = EffectiveTeamplayCollections> = Signal<Record<string, unknown>> & LocalSignalFactory & RootCollections<TCollections> & RootPrivateCollections;
 export interface RegisteredAggregationInput<TCollection extends string = string, TOutput = unknown> {
     readonly __isAggregation: true;
     readonly collection: TCollection;
@@ -98,10 +116,10 @@ export interface TypedAggregationInput<TDocument = unknown, TDocumentModel exten
     readonly __teamplayDocument?: TDocument;
     readonly __teamplayDocumentModel?: TDocumentModel;
 }
-export type CollectionAggregationSignal<TCollection extends keyof TeamplayCollections & string> = AggregationSignal<CollectionDocument<TeamplayCollections[TCollection]>, CollectionDocumentModel<TeamplayCollections[TCollection]>, readonly [TCollection, '*']>;
+export type CollectionAggregationSignal<TCollection extends keyof EffectiveTeamplayCollections & string> = AggregationSignal<CollectionDocument<EffectiveTeamplayCollections[TCollection]>, CollectionDocumentModel<EffectiveTeamplayCollections[TCollection]>, readonly [TCollection, '*']>;
 export type TypedAggregationSignal<TDocument, TDocumentModel extends SignalClass<any>> = AggregationSignal<TDocument, TDocumentModel>;
 export type AggregationOutputSignal<TOutput> = IsAny<TOutput> extends true ? QuerySignal : NonNullable<TOutput> extends ReadonlyArray<infer TDocument> ? AggregationSignal<TDocument, DocumentSignalModelForValue<TDocument>, DocumentSignalPathForValue<TDocument>> : SignalForDocumentValue<TOutput>;
-type RegisteredAggregationSignal<TCollection extends string, TOutput> = IsUnknown<TOutput> extends true ? TCollection extends keyof TeamplayCollections & string ? CollectionAggregationSignal<TCollection> : QuerySignal : AggregationOutputSignal<TOutput>;
+type RegisteredAggregationSignal<TCollection extends string, TOutput> = IsUnknown<TOutput> extends true ? TCollection extends keyof EffectiveTeamplayCollections & string ? CollectionAggregationSignal<TCollection> : QuerySignal : AggregationOutputSignal<TOutput>;
 export type MaybePromise<TValue> = TValue | Promise<TValue>;
 export type SubResult<TSignal, TParams = undefined> = TSignal extends ClientAggregationFunction<infer TOutput, infer TCollection> ? RegisteredAggregationSignal<TCollection, TOutput> : TSignal extends AggregationFunction<infer TOutput, any> ? IsUnknown<TOutput> extends true ? QuerySignal : AggregationOutputSignal<TOutput> : TSignal extends TypedAggregationInput<infer TDocument, infer TDocumentModel> ? TypedAggregationSignal<TDocument, TDocumentModel> : TSignal extends RegisteredAggregationInput<infer TCollection, infer TOutput> ? RegisteredAggregationSignal<TCollection, TOutput> : [TParams] extends [undefined] ? TSignal extends DocumentSignal<any, any, any> ? TSignal : QuerySignal : TSignal extends CollectionSignal<infer TDocument, infer TCollectionModel, infer TDocumentModel, infer TCollectionPath> ? CollectionQuerySignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath> : QuerySignal;
 export type MaybePromiseSubResult<TSignal, TParams = undefined> = MaybePromise<SubResult<TSignal, TParams>>;
@@ -121,6 +139,17 @@ export interface CollectionSpec<TDocument = unknown, TCollectionModel extends Si
 export type JsonSchemaSpec<TSchema, TCollectionModel extends SignalClass<any> = typeof Signal, TDocumentModel extends SignalClass<any> = typeof Signal> = CollectionSpec<FromJsonSchema<TSchema>, TCollectionModel, TDocumentModel>;
 export type ZodSchemaSpec<TSchema extends ZodLikeSchema, TCollectionModel extends SignalClass<any> = typeof Signal, TDocumentModel extends SignalClass<any> = typeof Signal> = CollectionSpec<InferZodSchema<TSchema>, TCollectionModel, TDocumentModel>;
 export type CollectionSignalFromSpec<TSpec, TPath extends WildcardSignalPath = readonly []> = TSpec extends CollectionSpec<infer Document, infer CollectionModel, infer DocumentModel> ? CollectionSignal<Document, CollectionModel, DocumentModel, TPath> : TSpec extends JsonSchema ? CollectionSignal<FromJsonSchema<TSpec>, typeof Signal, typeof Signal, TPath> : CollectionSignal;
+export type PrivateSignalFromSpec<TSpec, TPath extends WildcardSignalPath = readonly []> = Omit<DocumentSignal<TSpec, typeof Signal, TPath>, 'add'>;
+type PrivateSignalForAlias<TPrivateCollections, TAlias extends keyof RootDollarAliases & string> = RootDollarAliases[TAlias] extends keyof TPrivateCollections & string ? PrivateSignalFromSpec<TPrivateCollections[RootDollarAliases[TAlias]], readonly [RootDollarAliases[TAlias]]> : never;
+export type RootPrivateCollections<TPrivateCollections = EffectiveTeamplayPrivateCollections> = {
+    readonly [K in keyof TPrivateCollections & string]: PrivateSignalFromSpec<TPrivateCollections[K], readonly [K]>;
+} & {
+    readonly [K in keyof TPrivateCollections & string as `$${K}`]: PrivateSignalFromSpec<TPrivateCollections[K], readonly [K]>;
+} & {
+    readonly [K in keyof RootDollarAliases & string as RootDollarAliases[K] extends keyof TPrivateCollections & string ? K : never]: PrivateSignalForAlias<TPrivateCollections, K>;
+} & {
+    readonly [K in keyof RootDollarAliases & string as RootDollarAliases[K] extends keyof TPrivateCollections & string ? `$${K}` : never]: PrivateSignalForAlias<TPrivateCollections, K>;
+};
 export interface SignalConstructor {
     new <TValue = unknown>(segments: PathSegment[]): TypedSignal<TValue>;
     readonly ID_FIELDS: typeof Signal.ID_FIELDS;

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/promiseBatcher.js

@@ -95,7 +95,7 @@ function warnAboutChecksDelay(checks) {
             state
         };
     });
-    console.warn('[teamplay] useBatch() is waiting for data materialization checks.', details);
+    console.warn('[teamplay] useBatchSub() is waiting for data materialization checks.', details);
 }
 function isDevMode() {
     const processLike = globalThis.process;

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

@@ -13,7 +13,7 @@ export default function trapRender({ render, cache, destroy, componentId }) {
             promiseBatcher.reset();
             const res = render(...args);
             if (isDevMode() && promiseBatcher.isActive()) {
-                throw Error('[teamplay] useBatch* hooks were used without a closing useBatch() call.');
+                throw Error('[teamplay] batch subscriptions were used without a closing useBatchSub() call or useSub(undefined, undefined, { batch: true }) call.');
             }
             return res;
         }
@@ -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, 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.
@@ -24,6 +29,15 @@ export declare function useAsyncSub<TSignal extends DocumentSignal<any, any, any
  * @param options Subscription behavior options.
  */
 export declare function useAsyncSub<TDocument, TCollectionModel extends SignalModelConstructor<TDocument[]>, TDocumentModel extends SignalModelConstructor<TDocument>, TCollectionPath extends WildcardSignalPath>(signal: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, params: QueryParams<TDocument>, options?: UseSubOptions): SubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, QueryParams<TDocument>>;
+/**
+ * Subscribe to a collection query with computed string keys in React async mode.
+ * This fallback preserves Mongo-style computed paths such as `{ [`likes.${id}`]: true }`.
+ * Literal query objects should use the stricter overload above.
+ * @param signal Collection signal to query.
+ * @param params Mongo-style query params with a widened computed key.
+ * @param options Subscription behavior options.
+ */
+export declare function useAsyncSub<TDocument, TCollectionModel extends SignalModelConstructor<TDocument[]>, TDocumentModel extends SignalModelConstructor<TDocument>, TCollectionPath extends WildcardSignalPath, TParams extends object>(signal: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, params: TParams & ComputedQueryParamsInput<TParams>, options?: UseSubOptions): SubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, TParams>;
 /**
  * Subscribe to a registered collection aggregation in React async mode.
  * @param signal Aggregation header generated by StartupJS model loading.
@@ -52,6 +66,82 @@ 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>;
+/**
+ * Close a batch subscription barrier opened by previous `useBatchSub()` calls in this render.
+ */
+export declare function useBatchSub(): void;
+/**
+ * Subscribe to a document signal in React batch mode.
+ * @param signal Document signal to subscribe to.
+ * @param params Must be omitted for document subscriptions.
+ * @param options Subscription behavior options.
+ */
+export declare function useBatchSub<TSignal extends DocumentSignal<any, any, any>>(signal: TSignal, options?: UseSubOptions): SubResult<TSignal>;
+/**
+ * Subscribe to a document signal in React batch mode.
+ * @param signal Document signal to subscribe to.
+ * @param params Must be omitted for document subscriptions.
+ * @param options Subscription behavior options.
+ */
+export declare function useBatchSub<TSignal extends DocumentSignal<any, any, any>>(signal: TSignal, params?: undefined, options?: UseSubOptions): SubResult<TSignal>;
+/**
+ * Subscribe to a collection query in React batch mode.
+ * @param signal Collection signal to query.
+ * @param params Mongo-style query params, including filters and `$sort`.
+ * @param options Subscription behavior options.
+ */
+export declare function useBatchSub<TDocument, TCollectionModel extends SignalModelConstructor<TDocument[]>, TDocumentModel extends SignalModelConstructor<TDocument>, TCollectionPath extends WildcardSignalPath>(signal: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, params: QueryParams<TDocument>, options?: UseSubOptions): SubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, QueryParams<TDocument>>;
+/**
+ * Subscribe to a collection query with computed string keys in React batch mode.
+ * This fallback preserves Mongo-style computed paths such as `{ [`likes.${id}`]: true }`.
+ * Literal query objects should use the stricter overload above.
+ * @param signal Collection signal to query.
+ * @param params Mongo-style query params with a widened computed key.
+ * @param options Subscription behavior options.
+ */
+export declare function useBatchSub<TDocument, TCollectionModel extends SignalModelConstructor<TDocument[]>, TDocumentModel extends SignalModelConstructor<TDocument>, TCollectionPath extends WildcardSignalPath, TParams extends object>(signal: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, params: TParams & ComputedQueryParamsInput<TParams>, options?: UseSubOptions): SubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, TParams>;
+/**
+ * Subscribe to a registered collection aggregation in React batch mode.
+ * @param signal Aggregation header generated by StartupJS model loading.
+ * @param params Parameters passed to the aggregation.
+ * @param options Subscription behavior options.
+ */
+export declare function useBatchSub<TCollection extends string, TOutput = unknown>(signal: RegisteredAggregationInput<TCollection, TOutput>, params?: AggregationParams, options?: UseSubOptions): SubResult<RegisteredAggregationInput<TCollection, TOutput>>;
+/**
+ * Subscribe to a client aggregation in React batch mode.
+ * @param signal Aggregation function created with `aggregation(collection, fn)`.
+ * @param params Parameters passed to the aggregation.
+ * @param options Subscription behavior options.
+ */
+export declare function useBatchSub<TOutput, TCollection extends string>(signal: ClientAggregationFunction<TOutput, TCollection>, params?: AggregationParams, options?: UseSubOptions): SubResult<ClientAggregationFunction<TOutput, TCollection>>;
+/**
+ * Subscribe to an aggregation with explicit output typing in React batch mode.
+ * @param signal Typed aggregation input.
+ * @param params Parameters passed to the aggregation.
+ * @param options Subscription behavior options.
+ */
+export declare function useBatchSub<TDocument, TDocumentModel extends SignalModelConstructor<TDocument>>(signal: TypedAggregationInput<TDocument, TDocumentModel>, params?: AggregationParams, options?: UseSubOptions): TypedAggregationSignal<TDocument, TDocumentModel>;
+/**
+ * Subscribe to an unregistered aggregation in React batch mode.
+ * @param signal Aggregation function.
+ * @param params Parameters passed to the aggregation.
+ * @param options Subscription behavior options.
+ */
+export declare function useBatchSub<TOutput = unknown, TCollection extends string = string>(signal: AggregationFunction<TOutput, TCollection>, params?: AggregationParams, options?: UseSubOptions): SubResult<AggregationFunction<TOutput, TCollection>, AggregationParams | undefined>;
+/**
+ * Close a batch subscription barrier opened by previous `useSub(..., { batch: true })`
+ * calls in this render.
+ */
+export default function useSub(signal: undefined, params: undefined, options: UseSubOptions & {
+    batch: true;
+}): void;
+/**
+ * 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.
@@ -66,6 +156,15 @@ export default function useSub<TSignal extends DocumentSignal<any, any, any>>(si
  * @param options Subscription behavior options.
  */
 export default function useSub<TDocument, TCollectionModel extends SignalModelConstructor<TDocument[]>, TDocumentModel extends SignalModelConstructor<TDocument>, TCollectionPath extends WildcardSignalPath>(signal: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, params: QueryParams<TDocument>, options?: UseSubOptions): SubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, QueryParams<TDocument>>;
+/**
+ * Subscribe to a collection query with computed string keys in React.
+ * This fallback preserves Mongo-style computed paths such as `{ [`likes.${id}`]: true }`.
+ * Literal query objects should use the stricter overload above.
+ * @param signal Collection signal to query.
+ * @param params Mongo-style query params with a widened computed key.
+ * @param options Subscription behavior options.
+ */
+export default function useSub<TDocument, TCollectionModel extends SignalModelConstructor<TDocument[]>, TDocumentModel extends SignalModelConstructor<TDocument>, TCollectionPath extends WildcardSignalPath, TParams extends object>(signal: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, params: TParams & ComputedQueryParamsInput<TParams>, options?: UseSubOptions): SubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, TParams>;
 /**
  * Subscribe to a registered collection aggregation in React.
  * @param signal Aggregation header generated by StartupJS model loading.
@@ -94,8 +193,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;