teamplay 0.4.0 → 0.5.0-alpha.1

package/dist/orm/Compat/startStopCompat.js

@@ -0,0 +1,217 @@
+import { observe, raw, unobserve } from '@nx-js/observer-util';
+import { getRoot } from "../Root.js";
+import { scheduleReaction } from '../batchScheduler.js';
+const START_REACTIONS = Symbol('compat start reactions');
+const SKIP_TICK = Symbol('compat start skip tick');
+export function compatStartOnRoot($root, targetPath, ...depsAndGetter) {
+    if (!isRootSignal($root))
+        throw Error('Signal.start() is only available on root signal');
+    if (typeof targetPath !== 'string')
+        throw Error('Signal.start() expects targetPath to be a string');
+    if (depsAndGetter.length < 1) {
+        throw Error('Signal.start() expects targetPath, dependencies, and a getter function');
+    }
+    const getter = depsAndGetter[depsAndGetter.length - 1];
+    if (typeof getter !== 'function') {
+        throw Error('Signal.start() expects the last argument to be a getter function');
+    }
+    const deps = depsAndGetter.slice(0, -1);
+    const targetSegments = parsePathSegments(targetPath);
+    const $target = resolveSignal($root, targetSegments);
+    const targetKey = $target.path();
+    const store = getStartStore($root);
+    const existing = store.get(targetKey);
+    if (existing)
+        existing.stop();
+    let lastSourceSnapshot = UNSET;
+    const reaction = observe(() => {
+        const resolvedDeps = [];
+        for (const dep of deps) {
+            const resolved = resolveStartDep(dep, $root);
+            if (resolved === SKIP_TICK)
+                return;
+            resolvedDeps.push(resolved);
+        }
+        let nextValue;
+        try {
+            nextValue = getter(...resolvedDeps);
+        }
+        catch (err) {
+            if (isThenable(err))
+                return;
+            throw err;
+        }
+        const sourceSnapshot = detachStartValue(nextValue);
+        if (lastSourceSnapshot !== UNSET && deepEqualStartValue(lastSourceSnapshot, sourceSnapshot)) {
+            return;
+        }
+        lastSourceSnapshot = sourceSnapshot;
+        const detachedValue = detachStartValue(sourceSnapshot);
+        // Keep the detached snapshot to avoid aliasing source and target.
+        // Old racer start() writes through diffDeep by default. In compat mode we must preserve
+        // that behavior, but also avoid reading the target reactively inside start(), otherwise
+        // start() subscribes to its own output and local child edits get immediately overwritten.
+        const maybePromise = $target.setDiffDeep(detachedValue);
+        if (maybePromise?.then) {
+            maybePromise
+                .then(() => { })
+                .catch(ignorePromiseRejection);
+        }
+    }, { scheduler: scheduleReaction });
+    store.set(targetKey, { stop: () => unobserve(reaction) });
+    return $target;
+}
+export function compatStopOnRoot($root, targetPath) {
+    if (!isRootSignal($root))
+        throw Error('Signal.stop() is only available on root signal');
+    if (typeof targetPath !== 'string')
+        throw Error('Signal.stop() expects targetPath to be a string');
+    const targetSegments = parsePathSegments(targetPath);
+    const $target = resolveSignal($root, targetSegments);
+    const targetKey = $target.path();
+    const store = getStartStore($root);
+    const existing = store.get(targetKey);
+    if (!existing)
+        return;
+    existing.stop();
+    store.delete(targetKey);
+}
+export function joinScopePath(scopePath, relativePath) {
+    if (typeof scopePath !== 'string')
+        scopePath = '';
+    const segments = [];
+    if (scopePath)
+        segments.push(...parsePathSegments(scopePath));
+    if (relativePath)
+        segments.push(...parsePathSegments(relativePath));
+    return segments.join('.');
+}
+function getStartStore($root) {
+    $root[START_REACTIONS] ??= new Map();
+    return $root[START_REACTIONS];
+}
+function resolveStartDep(dep, $root) {
+    try {
+        if (isSignalLike(dep))
+            return getStartDepValue(dep);
+        if (typeof dep === 'string')
+            return getStartDepValue(resolveSignal($root, parsePathSegments(dep)));
+        return dep;
+    }
+    catch (err) {
+        if (isThenable(err))
+            return SKIP_TICK;
+        throw err;
+    }
+}
+function getStartDepValue($signal) {
+    return readReactiveSnapshot($signal.get());
+}
+function readReactiveSnapshot(value) {
+    if (!value || typeof value !== 'object')
+        return value;
+    if (value instanceof Date)
+        return new Date(value);
+    if (Array.isArray(value)) {
+        const array = [];
+        for (let i = 0; i < value.length; i++) {
+            array[i] = readReactiveSnapshot(value[i]);
+        }
+        return array;
+    }
+    const object = new value.constructor();
+    for (const key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+            object[key] = readReactiveSnapshot(value[key]);
+        }
+    }
+    return object;
+}
+function isSignalLike(value) {
+    return value && typeof value.path === 'function' && typeof value.get === 'function';
+}
+function parsePathSegments(path) {
+    return path.split('.').filter(Boolean);
+}
+function resolveSignal($base, segments) {
+    let $cursor = $base;
+    for (const segment of segments)
+        $cursor = $cursor[segment];
+    return $cursor;
+}
+function isRootSignal($signal) {
+    return getRoot($signal) === $signal;
+}
+function ignorePromiseRejection() { }
+function isThenable(value) {
+    return !!value && typeof value.then === 'function';
+}
+const UNSET = Symbol('compat start unset');
+function detachStartValue(value) {
+    const rawValue = raw(value);
+    if (!rawValue || typeof rawValue !== 'object')
+        return rawValue;
+    if (typeof globalThis.structuredClone === 'function') {
+        try {
+            return globalThis.structuredClone(rawValue);
+        }
+        catch { }
+    }
+    return racerDeepCopy(rawValue);
+}
+function racerDeepCopy(value) {
+    if (value instanceof Date)
+        return new Date(value);
+    if (typeof value === 'object') {
+        if (value === null)
+            return null;
+        if (Array.isArray(value)) {
+            const array = [];
+            for (let i = value.length; i--;) {
+                array[i] = racerDeepCopy(value[i]);
+            }
+            return array;
+        }
+        const object = new value.constructor();
+        for (const key in value) {
+            if (Object.prototype.hasOwnProperty.call(value, key)) {
+                object[key] = racerDeepCopy(value[key]);
+            }
+        }
+        return object;
+    }
+    return value;
+}
+function deepEqualStartValue(left, right) {
+    if (left === right)
+        return true;
+    if (Number.isNaN(left) && Number.isNaN(right))
+        return true;
+    if (left instanceof Date || right instanceof Date) {
+        return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
+    }
+    if (!left || !right || typeof left !== 'object' || typeof right !== 'object')
+        return false;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right))
+            return false;
+        if (left.length !== right.length)
+            return false;
+        for (let i = 0; i < left.length; i++) {
+            if (!deepEqualStartValue(left[i], right[i]))
+                return false;
+        }
+        return true;
+    }
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    for (const key of leftKeys) {
+        if (!Object.prototype.hasOwnProperty.call(right, key))
+            return false;
+        if (!deepEqualStartValue(left[key], right[key]))
+            return false;
+    }
+    return true;
+}

package/dist/orm/Doc.d.ts

@@ -0,0 +1,96 @@
+import type Signal from './Signal.js'
+
+export type SubscriptionIntent = 'fetch' | 'subscribe'
+export type TransportMode = 'idle' | 'fetch' | 'subscribe'
+export type TransportPhase = 'stable' | 'transition'
+export type SignalPathSegments = Array<string | number>
+
+export interface ReadonlyMapView<TKey, TValue> extends Iterable<[TKey, TValue | undefined]> {
+  get (key: TKey): TValue | undefined
+  has (key: TKey): boolean
+  readonly size: number
+  keys (): IterableIterator<TKey>
+  values (): IterableIterator<TValue | undefined>
+  entries (): IterableIterator<[TKey, TValue | undefined]>
+}
+
+export interface PendingDestroyEntry {
+  timer?: ReturnType<typeof setTimeout>
+  force: boolean
+  promise: Promise<unknown>
+  resolve: () => void
+  reject: (error?: unknown) => void
+}
+
+export interface DocOwnerMeta {
+  hash: string
+  segments: SignalPathSegments
+  rootId?: string
+}
+
+export interface DocOwnerRecord extends DocOwnerMeta {
+  ownerKey: string
+  fetchCount: number
+  subscribeCount: number
+}
+
+export interface DocRuntimeEntry {
+  hash: string
+  segments: SignalPathSegments
+  mode: TransportMode
+  targetMode: TransportMode
+  phase: TransportPhase
+  runtime: Doc | null
+  owners: Set<string>
+  retainCount: number
+  pendingDestroy: PendingDestroyEntry | null
+  reconcilePromise: Promise<void> | null
+}
+
+export class Doc {
+  initialized?: boolean
+  collection: string
+  docId: string | number
+  requestedTransportMode: TransportMode
+  activeTransportMode: TransportMode
+  readonly subscribed: boolean
+  constructor (collection: string, docId: string | number)
+  init (): void
+  subscribe (options?: { mode?: Exclude<TransportMode, 'idle'> }): Promise<void>
+  unsubscribe (): Promise<void>
+  hasPending (): boolean
+  whenNothingPending (fn: () => void): void
+  destroy (): Promise<void>
+  dispose (): void
+}
+
+export type DocConstructor = new (collection: string, docId: string | number) => Doc
+
+export class DocSubscriptions {
+  DocClass: DocConstructor
+  ownerRecords: Map<string, DocOwnerRecord>
+  entries: Map<string, DocRuntimeEntry>
+  subCount: ReadonlyMapView<string, number>
+  ownerFetchCount: ReadonlyMapView<string, number>
+  ownerSubscribeCount: ReadonlyMapView<string, number>
+  ownerMeta: ReadonlyMapView<string, DocOwnerMeta>
+  ownerKeysByHash: ReadonlyMapView<string, Set<string>>
+  docs: ReadonlyMapView<string, Doc>
+  pendingDestroyTimers: ReadonlyMapView<string, PendingDestroyEntry>
+  constructor (DocClass?: DocConstructor)
+  init ($doc: Signal): void
+  subscribe ($doc: Signal, options?: { intent?: SubscriptionIntent }): Promise<void> | void
+  unsubscribe ($doc: Signal, options?: { intent?: SubscriptionIntent }): Promise<void>
+  retain ($doc: Signal): void
+  release ($doc: Signal): Promise<void>
+  destroy (segments: SignalPathSegments): Promise<void>
+  clear (): Promise<void>
+  releaseRootOwnedSubscriptions (rootId: string): Promise<void>
+  flushPendingDestroys (): Promise<void>
+  scheduleDestroy (segments: SignalPathSegments, options?: { force?: boolean }): Promise<void> | void
+  cancelDestroy (hash: string): void
+  getOwnerMeta (ownerKey: string): DocOwnerMeta | undefined
+  getOwnerKeys (hash: string): Set<string> | undefined
+}
+
+export const docSubscriptions: DocSubscriptions