teamplay 0.4.0 → 0.5.0-alpha.1

package/dist/orm/Compat/eventsCompat.d.ts

@@ -0,0 +1,3 @@
+export const emit: any
+export const useOn: any
+export const useEmit: any

package/dist/orm/Compat/eventsCompat.js

@@ -0,0 +1,73 @@
+import { useLayoutEffect } from 'react';
+import { isModelEventsEnabled, normalizePattern, onModelEvent, removeModelListener, __resetModelEventsForTests } from './modelEvents.js';
+const listeners = new Map();
+export function emit(eventName, ...args) {
+    const subs = listeners.get(eventName);
+    if (!subs)
+        return;
+    const snapshot = Array.from(subs);
+    for (const handler of snapshot) {
+        handler(...args);
+    }
+}
+export function on(eventName, handler) {
+    if (!listeners.has(eventName))
+        listeners.set(eventName, new Set());
+    const subs = listeners.get(eventName);
+    subs.add(handler);
+    return handler;
+}
+export function removeListener(eventName, handler) {
+    const subs = listeners.get(eventName);
+    if (!subs)
+        return;
+    subs.delete(handler);
+    if (!subs.size)
+        listeners.delete(eventName);
+}
+export function useOn(eventName, patternOrHandler, handler, deps) {
+    const isModelEvent = eventName === 'change' || eventName === 'all';
+    const isCustom = !isModelEvent || typeof patternOrHandler === 'function';
+    if (isCustom) {
+        if (typeof patternOrHandler !== 'function')
+            throw Error('useOn() expects a handler function');
+    }
+    else {
+        if (typeof handler !== 'function')
+            throw Error('useOn() expects a handler function');
+    }
+    const normalizedPattern = isCustom ? null : normalizePatternMaybe(patternOrHandler);
+    useLayoutEffect(() => {
+        if (isCustom) {
+            const listener = on(eventName, patternOrHandler);
+            return () => {
+                removeListener(eventName, listener);
+            };
+        }
+        if (normalizedPattern == null) {
+            handler(patternOrHandler);
+            return;
+        }
+        if (!isModelEventsEnabled())
+            return;
+        const listener = onModelEvent(undefined, eventName, normalizedPattern, handler);
+        return () => {
+            removeModelListener(undefined, eventName, listener);
+        };
+    }, [eventName, patternOrHandler, handler, deps, normalizedPattern, isCustom]);
+}
+export function useEmit() {
+    return emit;
+}
+export function __resetEventsForTests() {
+    listeners.clear();
+    __resetModelEventsForTests();
+}
+function normalizePatternMaybe(pattern) {
+    try {
+        return normalizePattern(pattern);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/orm/Compat/hooksCompat.d.ts

@@ -0,0 +1,33 @@
+export const useValue: any
+export const useValue$: any
+export const useModel: any
+export const useLocal: any
+export const useLocal$: any
+export const useLocalDoc: any
+export const useLocalDoc$: any
+export const useSession: any
+export const useSession$: any
+export const usePage: any
+export const usePage$: any
+export const useBatch: any
+export const useDoc: any
+export const useDoc$: any
+export const useBatchDoc: any
+export const useBatchDoc$: any
+export const useAsyncDoc: any
+export const useAsyncDoc$: any
+export const useQuery: any
+export const useQuery$: any
+export const useAsyncQuery: any
+export const useAsyncQuery$: any
+export const useBatchQuery: any
+export const useBatchQuery$: any
+export const useQueryIds: any
+export const useBatchQueryIds: any
+export const useAsyncQueryIds: any
+export const useQueryDoc: any
+export const useQueryDoc$: any
+export const useBatchQueryDoc: any
+export const useBatchQueryDoc$: any
+export const useAsyncQueryDoc: any
+export const useAsyncQueryDoc$: any

package/dist/orm/Compat/hooksCompat.js

@@ -0,0 +1,360 @@
+import { getRootSignal, GLOBAL_ROOT_ID } from "../Root.js";
+import useSub, { useAsyncSub } from "../../react/useSub.js";
+import universal$ from "../../react/universal$.js";
+import * as promiseBatcher from "../../react/promiseBatcher.js";
+import { isCompatEnv } from '../compatEnv.js';
+import { isQueryReady } from './queryReadiness.js';
+const $root = getRootSignal({ rootId: GLOBAL_ROOT_ID, rootFunction: universal$ });
+const emittedCompatWarnings = new Set();
+// Hook-compatible wrapper around $() for compatibility mode.
+export function useValue$(defaultValue) {
+    return $root(defaultValue);
+}
+// Returns [value, $signal] similar to useState, but backed by $().
+export function useValue(defaultValue) {
+    const $sig = useValue$(defaultValue);
+    return [$sig.get(), $sig];
+}
+export function useModel(path) {
+    if (arguments.length === 0 || path == null)
+        return $root;
+    if (path && typeof path.path === 'function')
+        return path;
+    if (typeof path !== 'string')
+        throw Error('useModel() expects a string path or a signal');
+    const segments = path.split('.').filter(Boolean);
+    if (segments.length === 0)
+        return $root;
+    let $cursor = $root;
+    for (const segment of segments) {
+        $cursor = $cursor[segment];
+    }
+    return $cursor;
+}
+export function useLocal$(path) {
+    const resolvedPath = resolveLocalPath(path);
+    if (!resolvedPath)
+        return $root;
+    const segments = resolvedPath.split('.').filter(Boolean);
+    let $cursor = $root;
+    for (const segment of segments) {
+        $cursor = $cursor[segment];
+    }
+    return $cursor;
+}
+export function useLocal(path) {
+    const $sig = useLocal$(path);
+    return [$sig.get(), $sig];
+}
+export function useLocalDoc$(collection, id) {
+    if (collection == null)
+        throw Error('useLocalDoc() expects a collection name');
+    if (id == null)
+        return undefined;
+    return $root[collection][id];
+}
+export function useLocalDoc(collection, id) {
+    const $doc = useLocalDoc$(collection, id);
+    if (!$doc)
+        return [undefined, undefined];
+    return [$doc.get(), $doc];
+}
+export function useSession$(path) {
+    return useLocal$(prefixLocalPath('_session', path));
+}
+export function useSession(path) {
+    return useLocal(prefixLocalPath('_session', path));
+}
+export function usePage$(path) {
+    return useLocal$(prefixLocalPath('_page', path));
+}
+export function usePage(path) {
+    return useLocal(prefixLocalPath('_page', path));
+}
+export function useBatch() {
+    const promise = promiseBatcher.getPromiseAll();
+    if (promise)
+        throw promise;
+}
+export function useDoc$(collection, id, options) {
+    const $doc = getDocSignal(collection, id, 'useDoc');
+    const normalizedOptions = normalizeSyncSubOptions(options);
+    return useSub($doc, undefined, normalizedOptions);
+}
+export function useDoc(collection, id, options) {
+    const $doc = useDoc$(collection, id, options);
+    return [$doc.get(), $doc];
+}
+export function useBatchDoc(collection, id, options) {
+    const $doc = useBatchDoc$(collection, id, options);
+    if (!$doc)
+        return [undefined, undefined];
+    return [$doc.get(), $doc];
+}
+export function useBatchDoc$(collection, id, _options) {
+    const $doc = getDocSignal(collection, id, 'useBatchDoc');
+    const options = _options ? { ..._options, ...BATCH_SUB_OPTIONS } : BATCH_SUB_OPTIONS;
+    return useSub($doc, undefined, options);
+}
+export function useAsyncDoc$(collection, id, options) {
+    const $doc = getDocSignal(collection, id, 'useAsyncDoc');
+    return useAsyncSub($doc, undefined, options);
+}
+export function useAsyncDoc(collection, id, options) {
+    const $doc = useAsyncDoc$(collection, id, options);
+    if (!$doc)
+        return [undefined, undefined];
+    return [$doc.get(), $doc];
+}
+function useSubscribedQuery(collection, query, options, hookName, subscribe) {
+    const normalizedQuery = normalizeQuery(query, hookName);
+    const $collection = getCollectionSignal(collection, query, hookName);
+    const $query = subscribe($collection, normalizedQuery, options);
+    return {
+        normalizedQuery,
+        $collection,
+        $query: getExtraQuerySignal($query, normalizedQuery)
+    };
+}
+function getExtraQuerySignal($query, normalizedQuery) {
+    if (!$query)
+        return $query;
+    return isExtraQuery(normalizedQuery) ? $query.extra : $query;
+}
+export function useQuery$(collection, query, options) {
+    const normalizedOptions = normalizeSyncSubOptions(options);
+    const { $query } = useSubscribedQuery(collection, query, normalizedOptions, 'useQuery', useSub);
+    return $query;
+}
+export function useQuery(collection, query, options) {
+    const normalizedOptions = normalizeSyncSubOptions(options);
+    const { $collection, $query } = useSubscribedQuery(collection, query, normalizedOptions, 'useQuery', useSub);
+    return [$query.get(), $collection];
+}
+export function useAsyncQuery$(collection, query, options) {
+    const { $query } = useSubscribedQuery(collection, query, options, 'useAsyncQuery', useAsyncSub);
+    return $query;
+}
+export function useAsyncQuery(collection, query, options) {
+    const { $collection, $query } = useSubscribedQuery(collection, query, options, 'useAsyncQuery', useAsyncSub);
+    if (!$query)
+        return [undefined, $collection];
+    return [$query.get(), $collection];
+}
+export function useBatchQuery$(collection, query, _options) {
+    const options = normalizeBatchSubOptions(_options);
+    const { $query } = useSubscribedQuery(collection, query, options, 'useBatchQuery', useSub);
+    return $query;
+}
+export function useBatchQuery(collection, query, _options) {
+    const options = normalizeBatchSubOptions(_options);
+    const { $collection, $query } = useSubscribedQuery(collection, query, options, 'useBatchQuery', useSub);
+    if (!$query)
+        return [undefined, $collection];
+    return [$query.get(), $collection];
+}
+export function useQueryIds(collection, ids = [], options = {}) {
+    const list = Array.isArray(ids) ? ids.slice() : [];
+    if (options?.reverse)
+        list.reverse();
+    const [docs, $collection] = useQuery(collection, { _id: { $in: list } }, options);
+    if (!docs)
+        return [docs, $collection];
+    const docsById = new Map();
+    for (const doc of docs) {
+        const id = doc?._id ?? doc?.id;
+        if (id != null)
+            docsById.set(id, doc);
+    }
+    const items = list.map(id => docsById.get(id)).filter(Boolean);
+    return [items, $collection];
+}
+export function useBatchQueryIds(collection, ids = [], options = {}) {
+    const list = Array.isArray(ids) ? ids.slice() : [];
+    if (options?.reverse)
+        list.reverse();
+    const [docs, $collection] = useBatchQuery(collection, { _id: { $in: list } }, options);
+    if (!docs)
+        return [docs, $collection];
+    const docsById = new Map();
+    for (const doc of docs) {
+        const id = doc?._id ?? doc?.id;
+        if (id != null)
+            docsById.set(id, doc);
+    }
+    const items = list.map(id => docsById.get(id)).filter(Boolean);
+    return [items, $collection];
+}
+export function useAsyncQueryIds(collection, ids = [], options = {}) {
+    const list = Array.isArray(ids) ? ids.slice() : [];
+    if (options?.reverse)
+        list.reverse();
+    const [docs, $collection] = useAsyncQuery(collection, { _id: { $in: list } }, options);
+    if (docs == null)
+        return [undefined, $collection];
+    const docsById = new Map();
+    for (const doc of docs) {
+        const id = doc?._id ?? doc?.id;
+        if (id != null)
+            docsById.set(id, doc);
+    }
+    const items = list.map(id => docsById.get(id)).filter(Boolean);
+    return [items, $collection];
+}
+export function useQueryDoc(collection, query, options) {
+    const normalized = normalizeQuery(query, 'useQueryDoc');
+    const queryDoc = {
+        ...normalized,
+        $limit: 1,
+        $sort: normalized.$sort || { createdAt: -1 }
+    };
+    const [docs, $collection] = useQuery(collection, queryDoc, options);
+    const doc = docs && docs[0];
+    const docId = doc?._id ?? doc?.id;
+    const $doc = docId != null ? $collection[docId] : undefined;
+    return [doc, $doc];
+}
+export function useQueryDoc$(collection, query, options) {
+    const [, $doc] = useQueryDoc(collection, query, options);
+    return $doc;
+}
+export function useBatchQueryDoc(collection, query, options) {
+    const normalized = normalizeQuery(query, 'useBatchQueryDoc');
+    const queryDoc = {
+        ...normalized,
+        $limit: 1,
+        $sort: normalized.$sort || { createdAt: -1 }
+    };
+    const [docs, $collection] = useBatchQuery(collection, queryDoc, options);
+    if (!docs)
+        return [undefined, undefined];
+    const doc = docs && docs[0];
+    const docId = doc?._id ?? doc?.id;
+    const $doc = docId != null ? $collection[docId] : undefined;
+    return [doc, $doc];
+}
+export function useBatchQueryDoc$(collection, query, options) {
+    const [, $doc] = useBatchQueryDoc(collection, query, options);
+    return $doc;
+}
+export function useAsyncQueryDoc(collection, query, options) {
+    const normalized = normalizeQuery(query, 'useAsyncQueryDoc');
+    const queryDoc = {
+        ...normalized,
+        $limit: 1,
+        $sort: normalized.$sort || { createdAt: -1 }
+    };
+    const [docs, $collection] = useAsyncQuery(collection, queryDoc, options);
+    if (docs == null)
+        return [undefined, undefined];
+    const doc = docs && docs[0];
+    const docId = doc?._id ?? doc?.id;
+    const $doc = docId != null ? $collection[docId] : undefined;
+    return [doc, $doc];
+}
+export function useAsyncQueryDoc$(collection, query, options) {
+    const [, $doc] = useAsyncQueryDoc(collection, query, options);
+    return $doc;
+}
+function resolveLocalPath(path) {
+    if (path && typeof path.path === 'function')
+        return path.path();
+    if (typeof path === 'string')
+        return path;
+    if (path == null)
+        return '';
+    throw Error('useLocal() expects a string path or a signal');
+}
+function prefixLocalPath(prefix, path) {
+    if (path == null || path === '')
+        return prefix;
+    let resolved = path;
+    if (path && typeof path.path === 'function')
+        resolved = path.path();
+    if (typeof resolved !== 'string')
+        throw Error(`${prefix} hook expects a string path or a signal`);
+    if (resolved.startsWith(prefix + '.'))
+        return resolved;
+    if (resolved === prefix)
+        return resolved;
+    return `${prefix}.${resolved}`;
+}
+function getDocSignal(collection, id, hookName) {
+    if (typeof collection !== 'string') {
+        throw Error(`[${hookName}] collection must be a string. Got: ${collection}`);
+    }
+    if (id == null) {
+        warnCompatOnce(`doc:${hookName}:${collection}:${id}`, `
+      [${hookName}] You are trying to subscribe to an undefined document id:
+        ${collection}.${id}
+      Falling back to '__NULL__' document to prevent critical crash.
+      You should prevent situations when the \`id\` is undefined.
+    `);
+        id = '__NULL__';
+    }
+    return $root[collection][id];
+}
+function getCollectionSignal(collection, query, hookName) {
+    if (typeof collection !== 'string') {
+        throw Error(`[${hookName}] collection must be a string. Got: ${collection}`);
+    }
+    if (query == null) {
+        warnCompatOnce(`query:${hookName}:${collection}`, `
+      [${hookName}] Query is undefined. Got:
+        ${collection}, ${query}
+      Falling back to {_id: '__NON_EXISTENT__'} query to prevent critical crash.
+      You should prevent situations when the \`query\` is undefined.
+    `);
+    }
+    return $root[collection];
+}
+function warnCompatOnce(key, message) {
+    if (emittedCompatWarnings.has(key))
+        return;
+    emittedCompatWarnings.add(key);
+    console.warn(message);
+}
+export function __resetCompatWarningsForTests() {
+    emittedCompatWarnings.clear();
+}
+function normalizeQuery(query, hookName) {
+    if (query == null)
+        return { _id: '__NON_EXISTENT__' };
+    if (typeof query !== 'object') {
+        throw Error(`[${hookName}] query must be an object. Got: ${query}`);
+    }
+    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,
+    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
+});
+function normalizeSyncSubOptions(options) {
+    if (!isCompatEnv()) {
+        return options ? { ...options, async: false } : options;
+    }
+    return {
+        ...(options || {}),
+        async: false,
+        compatAttemptCleanup: true,
+        // Compat sync hooks are strict by design: no deferred snapshots between route/tab switches.
+        defer: false
+    };
+}
+function normalizeBatchSubOptions(options) {
+    return options ? { ...options, ...BATCH_SUB_OPTIONS } : BATCH_SUB_OPTIONS;
+}
+export const __COMPAT_BATCH_READY__ = {
+    isQueryReady
+};

package/dist/orm/Compat/modelEvents.d.ts

@@ -0,0 +1,6 @@
+export function isModelEventsEnabled(): boolean;
+export function normalizePattern(pattern: any, methodName: any): string | null;
+export function onModelEvent(rootId: any, eventName: any, pattern: any, handler: any): any;
+export function removeModelListener(rootId: any, eventName: any, handler: any): void;
+export function emitModelChange(path: any, value: any, prevValue: any, meta: any): void;
+export function __resetModelEventsForTests(): void;