teamplay 0.5.0-alpha.34 → 0.5.0-alpha.35

package/dist/orm/Compat/SignalCompat.js

@@ -1,7 +1,7 @@
-import { raw, observe, unobserve } from '@nx-js/observer-util';
+import { raw } from '@nx-js/observer-util';
 import arrayDiff from 'arraydiff';
 import { Signal, GETTERS, DEFAULT_GETTERS, SEGMENTS, isPublicCollection, isPublicCollectionSignal, isPublicDocumentSignal } from "../SignalBase.js";
-import { getRoot, ROOT, ROOT_ID, getRootSignal, GLOBAL_ROOT_ID } from "../Root.js";
+import { getRoot, ROOT, ROOT_ID } from "../Root.js";
 import { docSubscriptions } from '../Doc.js';
 import { IS_QUERY, querySubscriptions } from '../Query.js';
 import { AGGREGATIONS, IS_AGGREGATION, aggregationSubscriptions } from '../Aggregation.js';
@@ -9,13 +9,7 @@ import { getIdFieldsForSegments, isIdFieldPath, isPublicDocPath, normalizeIdFiel
 import { incrementPublic as _incrementPublic, arrayPushPublic as _arrayPushPublic, arrayUnshiftPublic as _arrayUnshiftPublic, arrayInsertPublic as _arrayInsertPublic, arrayPopPublic as _arrayPopPublic, arrayShiftPublic as _arrayShiftPublic, arrayRemovePublic as _arrayRemovePublic, arrayMovePublic as _arrayMovePublic, setPublicDocReplace as _setPublicDocReplace, stringInsertPublic as _stringInsertPublic, stringRemovePublic as _stringRemovePublic } from '../dataTree.js';
 import { on as onCustomEvent, removeListener as removeCustomEventListener } from '../events.js';
 import { waitForImperativeQueryReady } from '../queryReadiness.js';
-import { isModelEventsEnabled } from './modelEvents.js';
-import { setRefLink, removeRefLink, getAllRefLinks } from './refRegistry.js';
-import { REF_TARGET, resolveRefSignalSafe, resolveRefSegmentsSafe } from './refFallback.js';
 import { runInBatch } from '../batchScheduler.js';
-import { runInModelEventsSilentContext, isSilentContextActive } from './silentContext.js';
-import universal$ from "../../react/universal$.js";
-import { getRootContext } from "../rootContext.js";
 import { arrayInsertPrivateData, arrayMovePrivateData, arrayPopPrivateData, arrayPushPrivateData, arrayRemovePrivateData, arrayShiftPrivateData, arrayUnshiftPrivateData, delPrivateData, setReplacePrivateData, stringInsertPrivateData, stringRemovePrivateData } from '../privateData.js';
 class SignalCompat extends Signal {
     static [GETTERS] = DEFAULT_GETTERS;
@@ -27,15 +21,9 @@ class SignalCompat extends Signal {
     getId() {
         if (isAggregationValuePath(this[SEGMENTS]))
             return super.getId();
-        const $target = resolveRefSignal(this);
-        if ($target !== this)
-            return $target.getId();
         return super.getId();
     }
     getCollection() {
-        const $target = resolveRefSignal(this);
-        if ($target !== this)
-            return $target.getCollection();
         return super.getCollection();
     }
     getCopy() {
@@ -75,15 +63,9 @@ class SignalCompat extends Signal {
     peek() {
         if (arguments.length > 0)
             throw Error('Signal.peek() does not accept any arguments');
-        const $target = resolveRefSignal(this);
-        if ($target !== this)
-            return Signal.prototype.peek.apply($target, arguments);
         return Signal.prototype.peek.apply(this, arguments);
     }
     async set(value) {
-        const forwarded = forwardRef(this, 'set', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.set() expects a single argument');
         if (value === undefined)
@@ -91,9 +73,6 @@ class SignalCompat extends Signal {
         return setReplaceOnSignal(this, value);
     }
     async setReplace(value) {
-        const forwarded = forwardRef(this, 'setReplace', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.setReplace() expects a single argument');
         if (value === undefined)
@@ -101,9 +80,6 @@ class SignalCompat extends Signal {
         return setReplaceOnSignal(this, value);
     }
     async setNull(value) {
-        const forwarded = forwardRef(this, 'setNull', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.setNull() expects a single argument');
         if (this.get() != null)
@@ -111,17 +87,11 @@ class SignalCompat extends Signal {
         return setReplaceOnSignal(this, value);
     }
     async setDiffDeep(value) {
-        const forwarded = forwardRef(this, 'setDiffDeep', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.setDiffDeep() expects a single argument');
         return runInBatch(() => setDiffDeepOnSignal(this, value));
     }
     async setDiff(value) {
-        const forwarded = forwardRef(this, 'setDiff', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.setDiff() expects a single argument');
         const before = this.peek();
@@ -130,9 +100,6 @@ class SignalCompat extends Signal {
         return setReplaceOnSignal(this, value);
     }
     async setEach(object) {
-        const forwarded = forwardRef(this, 'setEach', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.setEach() expects a single argument');
         if (!object)
@@ -149,9 +116,6 @@ class SignalCompat extends Signal {
         });
     }
     async del() {
-        const forwarded = forwardRef(this, 'del', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 0)
             throw Error('Signal.del() does not accept any arguments');
         try {
@@ -164,9 +128,6 @@ class SignalCompat extends Signal {
         }
     }
     async increment(byNumber) {
-        const forwarded = forwardRef(this, 'increment', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.increment() expects zero or one argument');
         if (byNumber != null && (typeof byNumber !== 'number' || !Number.isFinite(byNumber))) {
@@ -175,25 +136,16 @@ class SignalCompat extends Signal {
         return incrementOnSignal(this, byNumber);
     }
     async push(value) {
-        const forwarded = forwardRef(this, 'push', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.push() expects a single argument');
         return arrayPushOnSignal(this, value);
     }
     async unshift(value) {
-        const forwarded = forwardRef(this, 'unshift', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.unshift() expects a single argument');
         return arrayUnshiftOnSignal(this, value);
     }
     async insert(index, values) {
-        const forwarded = forwardRef(this, 'insert', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length < 2)
             throw Error('Not enough arguments for insert');
         if (arguments.length > 2)
@@ -204,25 +156,16 @@ class SignalCompat extends Signal {
         return arrayInsertOnSignal(this, index, values);
     }
     async pop() {
-        const forwarded = forwardRef(this, 'pop', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 0)
             throw Error('Signal.pop() does not accept any arguments');
         return arrayPopOnSignal(this);
     }
     async shift() {
-        const forwarded = forwardRef(this, 'shift', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 0)
             throw Error('Signal.shift() does not accept any arguments');
         return arrayShiftOnSignal(this);
     }
     async remove(index, howMany) {
-        const forwarded = forwardRef(this, 'remove', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length === 0) {
             const segments = this[SEGMENTS].slice();
             if (!segments.length || typeof segments[segments.length - 1] !== 'number') {
@@ -241,9 +184,6 @@ class SignalCompat extends Signal {
         return arrayRemoveOnSignal(this, index, howMany);
     }
     async move(from, to, howMany) {
-        const forwarded = forwardRef(this, 'move', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length < 2)
             throw Error('Not enough arguments for move');
         if (arguments.length > 3)
@@ -254,9 +194,6 @@ class SignalCompat extends Signal {
         return arrayMoveOnSignal(this, from, to, howMany);
     }
     async stringInsert(index, text) {
-        const forwarded = forwardRef(this, 'stringInsert', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length < 2)
             throw Error('Not enough arguments for stringInsert');
         if (arguments.length > 2)
@@ -267,9 +204,6 @@ class SignalCompat extends Signal {
         return stringInsertOnSignal(this, index, text);
     }
     async stringRemove(index, howMany) {
-        const forwarded = forwardRef(this, 'stringRemove', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length < 2)
             throw Error('Not enough arguments for stringRemove');
         if (arguments.length > 2)
@@ -282,9 +216,6 @@ class SignalCompat extends Signal {
         return stringRemoveOnSignal(this, index, howMany);
     }
     async assign(value) {
-        const forwarded = forwardRef(this, 'assign', arguments);
-        if (forwarded)
-            return forwarded;
         if (arguments.length > 1)
             throw Error('Signal.assign() expects a single argument');
         return Signal.prototype.assign.call(this, value);
@@ -319,245 +250,15 @@ class SignalCompat extends Signal {
             throw Error('Signal.removeListener() expects two arguments');
         return removeCustomEventListener(eventName, handler);
     }
-    ref(path, target, options) {
-        if (arguments.length < 1 || arguments.length > 2)
-            throw Error('Signal.ref() expects one or two arguments');
-        let $to;
-        if (arguments.length === 1) {
-            $to = resolveRefTarget(this, path, 'Signal.ref()');
-        }
-        else {
-            $to = resolveRefTarget(this, path, 'Signal.ref()');
-            options = target;
-        }
-        if (!$to)
-            throw Error('Signal.ref() expects a target path or signal');
-        if (this === $to)
-            return this;
-        ensurePrivateRefSource(this, 'Signal.ref()');
-        const store = getRefStore(this);
-        const fromPath = this.path();
-        const existing = store.get(fromPath);
-        if (existing)
-            existing.stop();
-        const mirrorOnly = !!($to?.[IS_QUERY] || $to?.[IS_AGGREGATION]);
-        const { stop, onChange } = createRefLink(this, $to, { mirrorOnly, options });
-        store.set(fromPath, { stop });
-        const fromRootId = (getRoot(this) || this)?.[ROOT_ID];
-        const toRootId = (getRoot($to) || $to)?.[ROOT_ID];
-        if (!mirrorOnly) {
-            this[REF_TARGET] = $to;
-            setRefLink(fromRootId, fromPath, $to.path(), this[SEGMENTS], $to[SEGMENTS], {
-                mirrorOnly: false,
-                fromRootId,
-                toRootId
-            });
-        }
-        else {
-            setRefLink(fromRootId, fromPath, $to.path(), this[SEGMENTS], $to[SEGMENTS], {
-                mirrorOnly: true,
-                onChange,
-                fromRootId,
-                toRootId
-            });
-            if (this[REF_TARGET])
-                delete this[REF_TARGET];
-        }
-        return this;
-    }
-    refExtra(path) {
-        if (arguments.length !== 1)
-            throw Error('Signal.refExtra() expects a single argument');
-        const segments = parseAtSubpath(path, 1, 'Signal.refExtra()');
-        const $root = getRoot(this) || this;
-        const $target = resolveSignal($root, segments);
-        let $source = this;
-        if (this[IS_QUERY]) {
-            $source = this.extra;
-        }
-        return SignalCompat.prototype.ref.call($target, $source);
-    }
-    refIds(path) {
-        if (arguments.length !== 1)
-            throw Error('Signal.refIds() expects a single argument');
-        if (!this[IS_QUERY]) {
-            throw Error('Signal.refIds() can only be used on query signals');
-        }
-        const segments = parseAtSubpath(path, 1, 'Signal.refIds()');
-        const $root = getRoot(this) || this;
-        const $target = resolveSignal($root, segments);
-        return SignalCompat.prototype.ref.call($target, this.ids);
-    }
-    removeRef() {
-        if (arguments.length > 0)
-            throw Error('Signal.removeRef() does not accept any arguments');
-        const store = getRefStore(this);
-        const fromPath = this.path();
-        const existing = store.get(fromPath);
-        if (existing) {
-            existing.stop();
-            store.delete(fromPath);
-        }
-        const fromRootId = (getRoot(this) || this)?.[ROOT_ID];
-        removeRefLink(fromRootId, fromPath);
-        const $target = resolveRefSignal(this);
-        if ($target !== this) {
-            setDiffDeepBypassRef(this, deepCopy($target.get()));
-        }
-        if (this[REF_TARGET])
-            delete this[REF_TARGET];
-    }
-}
-function getRefStore($signal) {
-    const $root = getRoot($signal) || $signal;
-    const rootId = $root?.[ROOT_ID];
-    return getRootContext(rootId, true).activeRefs;
-}
-function createRefLink($from, $to, { mirrorOnly = false } = {}) {
-    let disposed = false;
-    let pendingRead = null;
-    let mirrorObserver;
-    const syncFromTarget = () => {
-        const value = readRefValue($to);
-        if (isThenable(value)) {
-            pendingRead = value;
-            value.then(() => {
-                if (disposed || pendingRead !== value)
-                    return;
-                pendingRead = null;
-                syncFromTarget();
-            }, () => {
-                if (pendingRead === value)
-                    pendingRead = null;
-            });
-            return;
-        }
-        if (value === undefined)
-            return;
-        setDiffDeepBypassRef($from, deepCopy(value));
-    };
-    syncFromTarget();
-    if (mirrorOnly) {
-        mirrorObserver = observe(() => {
-            syncFromTarget();
-            return readRefValue($to);
-        }, {
-            scheduler: job => job()
-        });
-        // initialize dependency graph
-        mirrorObserver();
-    }
-    return {
-        onChange: syncFromTarget,
-        stop: () => {
-            disposed = true;
-            if (mirrorObserver)
-                unobserve(mirrorObserver);
-            // Subsequent sync happens directly at mutation time via mirrorRefMutationFromTarget().
-        }
-    };
-}
-function readRefValue($signal) {
-    try {
-        return $signal.get();
-    }
-    catch (err) {
-        if (isThenable(err))
-            return err;
-        throw err;
-    }
 }
 function isAggregationValuePath(segments) {
     return Array.isArray(segments) &&
         segments.length >= 3 &&
         segments[0] === AGGREGATIONS;
 }
-function resolveRefSignal($signal) {
-    const directTarget = resolveRefSignalSafe($signal);
-    if (directTarget && directTarget !== $signal)
-        return directTarget;
-    const resolvedSegments = resolveRefSegmentsSafe($signal[SEGMENTS], (getRoot($signal) || $signal)?.[ROOT_ID]);
-    if (!resolvedSegments)
-        return $signal;
-    const $root = getRoot($signal) || $signal;
-    return resolveSignal($root, resolvedSegments);
-}
-function forwardRef($signal, methodName, args) {
-    const $target = resolveRefSignal($signal);
-    if ($target === $signal)
-        return null;
-    return SignalCompat.prototype[methodName].apply($target, args);
-}
-function setDiffDeepBypassRef($signal, value) {
-    const segments = $signal[SEGMENTS];
-    if (isPublicCollection(segments[0]))
-        return Signal.prototype.set.call($signal, value);
-    return setReplacePrivateData(getOwningRootId($signal), segments, value);
-}
-function mirrorRefMutationFromTarget(targetSegments, value) {
-    if (!Array.isArray(targetSegments) || targetSegments.length === 0)
-        return;
-    const updates = [];
-    for (const link of getAllRefLinks()) {
-        if (!isPathPrefix(link.toSegments, targetSegments))
-            continue;
-        const suffix = targetSegments.slice(link.toSegments.length);
-        updates.push({
-            fromRootId: link.fromRootId,
-            segments: link.fromSegments.concat(suffix),
-            value: deepCopy(value)
-        });
-    }
-    if (!updates.length)
-        return;
-    runInModelEventsSilentContext(() => {
-        for (const update of updates) {
-            const $root = getRootSignal({
-                rootId: update.fromRootId || GLOBAL_ROOT_ID,
-                rootFunction: universal$
-            });
-            const $target = resolveSignal($root, update.segments);
-            setDiffDeepBypassRef($target, update.value);
-        }
-    });
-}
-function isPathPrefix(prefixSegments, fullSegments) {
-    if (prefixSegments.length > fullSegments.length)
-        return false;
-    for (let i = 0; i < prefixSegments.length; i++) {
-        if (String(prefixSegments[i]) !== String(fullSegments[i]))
-            return false;
-    }
-    return true;
-}
-function isSignalLike(value) {
-    return value && typeof value.path === 'function' && typeof value.get === 'function';
-}
 function isReactLike(value) {
     return !!(value && typeof value === 'object' && typeof value.$$typeof === 'symbol');
 }
-function isThenable(value) {
-    return !!value && typeof value.then === 'function';
-}
-function resolveRefTarget($signal, target, methodName) {
-    if (isSignalLike(target))
-        return target;
-    if (typeof target === 'string') {
-        const segments = parseAtSubpath(target, 1, methodName);
-        const $root = getRoot($signal) || $signal;
-        return resolveSignal($root, segments);
-    }
-    return undefined;
-}
-function parseAtSubpath(subpath, argsLength, methodName) {
-    if (argsLength === 0)
-        return [];
-    if (typeof subpath === 'string')
-        return subpath.split('.').filter(Boolean);
-    if (typeof subpath === 'number' && Number.isFinite(subpath) && Number.isInteger(subpath))
-        return [subpath];
-    throw Error(`${methodName} expects a string or integer argument`);
-}
 function resolveSignal($signal, segments) {
     let $cursor = $signal;
     for (const segment of segments) {
@@ -716,9 +417,6 @@ function setReplacePrivateCompatSync($signal, value) {
         value = normalizeIdFields(value, idFields, segments[1]);
     }
     setReplacePrivateData(getOwningRootId($signal), segments, value);
-    if (shouldMirrorPrivateRefMutationLocally()) {
-        mirrorRefMutationFromTarget(segments, value);
-    }
 }
 function delPrivateCompatSync($signal, options) {
     const segments = $signal[SEGMENTS];
@@ -775,17 +473,9 @@ async function setReplaceOnSignal($signal, value) {
         value = normalizeIdFields(value, idFields, segments[1]);
     }
     if (isPublicCollection(segments[0])) {
-        const result = await _setPublicDocReplace(segments, value);
-        if (shouldMirrorPublicRefMutationLocally(segments)) {
-            mirrorRefMutationFromTarget(segments, value);
-        }
-        return result;
+        return _setPublicDocReplace(segments, value);
     }
-    const result = setReplacePrivateData(getOwningRootId($signal), segments, value);
-    if (shouldMirrorPrivateRefMutationLocally()) {
-        mirrorRefMutationFromTarget(segments, value);
-    }
-    return result;
+    return setReplacePrivateData(getOwningRootId($signal), segments, value);
 }
 async function incrementOnSignal($signal, byNumber) {
     const segments = $signal[SEGMENTS];
@@ -911,28 +601,6 @@ function getOwningRootId($signal) {
     const $root = getRoot($signal) || $signal;
     return $root?.[ROOT_ID];
 }
-function ensurePrivateRefSource($signal, methodName) {
-    const segments = $signal?.[SEGMENTS];
-    const collection = segments?.[0];
-    if (typeof collection === 'string' && /^[_$]/.test(collection))
-        return;
-    throw Error(`${methodName} source path must be in a private collection`);
-}
-function shouldMirrorPublicRefMutationLocally(segments) {
-    if (isSilentContextActive())
-        return true;
-    if (!Array.isArray(segments) || segments.length < 2)
-        return true;
-    // Public doc ops emit compat model events only when there is an initialized
-    // Doc runtime (subscribed/fetched). Without runtime we must mirror immediately.
-    const transportHash = JSON.stringify([segments[0], segments[1]]);
-    return !docSubscriptions.hasRuntime(transportHash);
-}
-function shouldMirrorPrivateRefMutationLocally() {
-    if (isSilentContextActive())
-        return true;
-    return !isModelEventsEnabled();
-}
 function shallowCopy(value) {
     const rawValue = raw(value);
     if (Array.isArray(rawValue))

package/dist/orm/Compat/modelEvents.js

@@ -1,10 +1,7 @@
-import { getRefLinks, getRefRootIds } from './refRegistry.js';
 import { isCompatEnv } from '../compatEnv.js';
-import { isSilentContextActive, isModelEventsSilentContextActive, runInModelEventsSilentContext } from './silentContext.js';
+import { isSilentContextActive, isModelEventsSilentContextActive } from './silentContext.js';
 import { normalizeRootId } from "../rootScope.js";
 import { getRootContext, getRootContexts } from "../rootContext.js";
-import { setReplace as setReplaceInDataTree, del as delFromDataTree } from '../dataTree.js';
-import { setReplacePrivateData, delPrivateData } from '../privateData.js';
 const MODEL_EVENT_NAMES = ['change', 'all'];
 export function isModelEventsEnabled() {
     return isCompatEnv();
@@ -57,32 +54,8 @@ export function emitModelChange(path, value, prevValue, meta) {
     const eventName = meta?.eventName || 'change';
     const rootIds = getTargetRootIds(meta?.rootId);
     for (const rootId of rootIds) {
-        const visited = new Set();
-        const queue = [initialSegments];
-        while (queue.length) {
-            const segments = queue.shift();
-            const key = segments.join('.');
-            if (visited.has(key))
-                continue;
-            visited.add(key);
-            emitForEvent(rootId, 'change', segments, value, prevValue, meta);
-            emitForEvent(rootId, 'all', segments, value, prevValue, meta, eventName);
-            for (const link of getRefLinks(rootId).values()) {
-                if (!isPathPrefix(link.toSegments, segments))
-                    continue;
-                if (link.mirrorOnly && typeof link.onChange === 'function') {
-                    link.onChange();
-                }
-                else if (!link.mirrorOnly) {
-                    mirrorRefAliasFromTargetSegments(rootId, link, segments, value, meta);
-                }
-                const suffix = segments.slice(link.toSegments.length);
-                const nextSegments = link.fromSegments.concat(suffix);
-                const nextKey = nextSegments.join('.');
-                if (!visited.has(nextKey))
-                    queue.push(nextSegments);
-            }
-        }
+        emitForEvent(rootId, 'change', initialSegments, value, prevValue, meta);
+        emitForEvent(rootId, 'all', initialSegments, value, prevValue, meta, eventName);
     }
 }
 export function __resetModelEventsForTests() {
@@ -113,51 +86,6 @@ function splitPattern(pattern) {
         return [];
     return pattern.split('.').filter(Boolean);
 }
-function mirrorRefAliasFromTargetSegments(rootId, link, targetSegments, value, meta) {
-    const suffix = targetSegments.slice(link.toSegments.length);
-    const fromSegments = link.fromSegments.concat(suffix);
-    const fromRootId = normalizeRootId(link.fromRootId ?? rootId);
-    const shouldDelete = shouldDeleteMirroredPath(value, meta);
-    runInModelEventsSilentContext(() => {
-        if (isPrivateSegments(fromSegments)) {
-            if (shouldDelete) {
-                delPrivateData(fromRootId, fromSegments);
-            }
-            else {
-                setReplacePrivateData(fromRootId, fromSegments, cloneValue(value));
-            }
-            return;
-        }
-        if (shouldDelete) {
-            delFromDataTree(fromSegments);
-            return;
-        }
-        setReplaceInDataTree(fromSegments, cloneValue(value));
-    });
-}
-function isPrivateSegments(segments) {
-    if (!Array.isArray(segments) || !segments.length)
-        return false;
-    return /^[_$]/.test(String(segments[0]));
-}
-function shouldDeleteMirroredPath(value, meta) {
-    if (meta?.op === 'setReplace')
-        return false;
-    if (meta?.op === 'del')
-        return true;
-    return value === undefined;
-}
-function cloneValue(value) {
-    if (Array.isArray(value))
-        return value.map(cloneValue);
-    if (value && typeof value === 'object') {
-        const cloned = {};
-        for (const key of Object.keys(value))
-            cloned[key] = cloneValue(value[key]);
-        return cloned;
-    }
-    return value;
-}
 function getModelEventRootStore(eventName, rootId, create = false) {
     return getRootContext(normalizeRootId(rootId), create)?.getModelEventStore(eventName, create);
 }
@@ -174,11 +102,7 @@ function getModelEventRootIds() {
 function getTargetRootIds(rootId) {
     if (rootId != null)
         return [normalizeRootId(rootId)];
-    const rootIds = new Set([
-        ...getModelEventRootIds(),
-        ...getRefRootIds()
-    ]);
-    return rootIds;
+    return getModelEventRootIds();
 }
 function splitPath(path) {
     if (Array.isArray(path))
@@ -187,15 +111,6 @@ function splitPath(path) {
         return [];
     return String(path).split('.').filter(Boolean);
 }
-function isPathPrefix(prefixSegments, fullSegments) {
-    if (prefixSegments.length > fullSegments.length)
-        return false;
-    for (let i = 0; i < prefixSegments.length; i++) {
-        if (prefixSegments[i] !== fullSegments[i])
-            return false;
-    }
-    return true;
-}
 function matchPattern(patternSegments, pathSegments) {
     function walk(patternIndex, pathIndex) {
         if (patternIndex === patternSegments.length) {

package/dist/orm/SignalBase.js

@@ -22,8 +22,6 @@ import { IS_QUERY, HASH, QUERIES } from './Query.js';
 import { AGGREGATIONS, IS_AGGREGATION, getAggregationCollectionName, getAggregationDocId } from './Aggregation.js';
 import { ROOT_FUNCTION, ROOT_ID, closeRootSignal, getRoot } from "./Root.js";
 import { getDefaultIdFields, getIdFieldsForSegments, isIdFieldPath, isPlainObject, isPublicDocPath, normalizeIdFields, prepareAddPayload, resolveAddDocId } from "./idFields.js";
-import { isCompatEnv } from './compatEnv.js';
-import { resolveRefSegmentsSafe, resolveRefSignalSafe } from './Compat/refFallback.js';
 import { runInBatch } from './batchScheduler.js';
 import { isPublicCollection } from "./signalPathKind.js";
 import { ARRAY_METHOD, DEFAULT_GETTERS, GET, GETTERS, SEGMENTS } from "./signalSymbols.js";
@@ -781,7 +779,7 @@ export const regularBindings = {
     }
 };
 const QUERY_METHODS = ['map', 'reduce', 'find', 'get', 'getIds', 'getExtra', 'fetch', 'unfetch'];
-const AGGREGATION_ALLOWED_METHODS = ['fetch', 'unfetch', 'ref', 'removeRef', 'refExtra', 'refIds'];
+const AGGREGATION_ALLOWED_METHODS = ['fetch', 'unfetch'];
 // dot syntax always returns a child signal even if such method or property exists.
 // The method is only called when the signal is explicitly called as a function,
 // in which case we get the original method from the raw (non-proxied) parent signal
@@ -834,25 +832,6 @@ export const extremelyLateBindings = {
         const rawParent = rawSignal($parent);
         if (key in rawParent)
             return Reflect.apply(rawParent[key], $parent, argumentsList);
-        if (isCompatEnv()) {
-            const $resolvedParent = resolveRefSignalSafe($parent);
-            if ($resolvedParent && $resolvedParent !== $parent) {
-                const rawResolvedParent = rawSignal($resolvedParent);
-                if (rawResolvedParent && key in rawResolvedParent) {
-                    return Reflect.apply(rawResolvedParent[key], $resolvedParent, argumentsList);
-                }
-            }
-            else {
-                const resolvedSegments = resolveRefSegmentsSafe(segments, (getRoot(signal) || signal)?.[ROOT_ID]);
-                if (resolvedSegments) {
-                    const $resolvedByPath = getSignal(getRoot(signal), resolvedSegments);
-                    const rawResolvedByPath = rawSignal($resolvedByPath);
-                    if (rawResolvedByPath && key in rawResolvedByPath) {
-                        return Reflect.apply(rawResolvedByPath[key], $resolvedByPath, argumentsList);
-                    }
-                }
-            }
-        }
         throw Error(ERRORS.noSignalKey($parent, key));
     },
     get(signal, key, receiver) {

package/dist/orm/disposeRootContext.js

@@ -27,8 +27,6 @@ async function runDispose(rootId) {
     const context = getRootContext(rootId, false);
     if (!context)
         return;
-    stopActiveRefs(context);
-    context.resetRefs();
     context.resetModelListeners();
     for (const transportHash of Array.from(context.queryRuntimeHashes)) {
         await querySubscriptions.destroyByRuntimeHash(transportHash, { rootId, force: true });
@@ -43,17 +41,6 @@ async function runDispose(rootId) {
     context.resetDirectDocSubscriptions();
     deleteRootContext(rootId);
 }
-function stopActiveRefs(context) {
-    for (const entry of context.activeRefs.values()) {
-        try {
-            entry?.stop?.();
-        }
-        catch (err) {
-            console.error(err);
-        }
-    }
-    context.resetActiveRefs();
-}
 export function __resetPendingRootDisposesForTests() {
     PENDING_DISPOSES.clear();
 }

package/dist/orm/getSignal.d.ts

@@ -10,7 +10,7 @@ export interface GetSignalOptions {
 }
 declare const PROXIES_CACHE: Cache<RootSignalRuntime>;
 export default function getSignal($root?: RootSignalRuntime, segments?: PathSegment[], { useExtremelyLateBindings, rootId, signalHash, proxyHandlers }?: GetSignalOptions): RootSignalRuntime;
-export declare function getSignalClass(segments: PathSegment[], rootId?: string): SignalModelConstructor;
+export declare function getSignalClass(segments: PathSegment[], _rootId?: string): SignalModelConstructor;
 export declare function rawSignal(proxy: unknown): RootSignalRuntime | undefined;
 export { PROXIES_CACHE as __DEBUG_SIGNALS_CACHE__ };
 export declare function purgeSignalHashes(hashes: Iterable<string>): void;

package/dist/orm/getSignal.js

@@ -5,8 +5,6 @@ import { LOCAL } from './$.js';
 import { ROOT, ROOT_ID, GLOBAL_ROOT_ID } from "./Root.js";
 import { QUERIES } from './Query.js';
 import { AGGREGATIONS } from './Aggregation.js';
-import { isCompatEnv } from './compatEnv.js';
-import { resolveRefSegmentsSafe } from './Compat/refFallback.js';
 import { getSignalIdentityHash } from "./rootScope.js";
 import { isRootContextClosed, registerRootOwnedSignalHash } from "./rootContext.js";
 const PROXIES_CACHE = new Cache();
@@ -81,18 +79,10 @@ export default function getSignal($root, segments = [], { useExtremelyLateBindin
 function getDefaultProxyHandlers({ useExtremelyLateBindings } = {}) {
     return (useExtremelyLateBindings ? extremelyLateBindings : regularBindings);
 }
-export function getSignalClass(segments, rootId = GLOBAL_ROOT_ID) {
-    let Model = findModel(segments);
+export function getSignalClass(segments, _rootId = GLOBAL_ROOT_ID) {
+    const Model = findModel(segments);
     if (Model)
         return Model;
-    if (!isCompatEnv())
-        return Signal;
-    const dereferencedSegments = resolveRefSegmentsSafe(segments, rootId);
-    if (dereferencedSegments) {
-        Model = findModel(dereferencedSegments);
-        if (Model)
-            return Model;
-    }
     return Signal;
 }
 export function rawSignal(proxy) {

package/dist/orm/rootContext.d.ts

@@ -3,9 +3,6 @@ type RootId = string | null | undefined;
 type DataTree = Record<string | number, unknown>;
 type RuntimeKind = 'query' | 'aggregation';
 type ModelEventStore = Map<string, unknown>;
-type ActiveRefEntry = {
-    stop?: () => void;
-};
 interface RootContextOptions {
     fetchOnly?: boolean;
 }
@@ -24,8 +21,6 @@ export default class RootContext {
     fetchOnly: boolean;
     privateDataRaw: DataTree;
     privateData: DataTree;
-    readonly refLinks: Map<string, unknown>;
-    readonly activeRefs: Map<string, ActiveRefEntry>;
     readonly modelListeners: ModelListeners;
     readonly queryRuntimeHashes: Set<string>;
     readonly aggregationRuntimeHashes: Set<string>;
@@ -48,8 +43,6 @@ export default class RootContext {
     unregisterSignalHash(signalHash: string | null | undefined): void;
     registerDirectDocSubscription(hash: string | null | undefined, segments: readonly PathSegment[], token?: unknown): void;
     unregisterDirectDocSubscription(hash: string | null | undefined, token?: unknown): void;
-    resetRefs(): void;
-    resetActiveRefs(): void;
     resetModelListeners(): void;
     resetRuntimeHashes(): void;
     resetPrivateData(): void;

package/dist/orm/rootContext.js

@@ -12,8 +12,6 @@ export default class RootContext {
     fetchOnly;
     privateDataRaw;
     privateData;
-    refLinks = new Map();
-    activeRefs = new Map();
     modelListeners = {
         change: new Map(),
         all: new Map()
@@ -124,12 +122,6 @@ export default class RootContext {
         if (entry.count === 0)
             this.directDocSubscriptions.delete(hash);
     }
-    resetRefs() {
-        this.refLinks.clear();
-    }
-    resetActiveRefs() {
-        this.activeRefs.clear();
-    }
     resetModelListeners() {
         for (const store of Object.values(this.modelListeners)) {
             store.clear();
@@ -151,8 +143,6 @@ export default class RootContext {
     }
     isRuntimeEmpty() {
         return (isPlainObjectEmpty(this.privateData) &&
-            this.refLinks.size === 0 &&
-            this.activeRefs.size === 0 &&
             Object.values(this.modelListeners).every(store => store.size === 0) &&
             this.queryRuntimeHashes.size === 0 &&
             this.aggregationRuntimeHashes.size === 0 &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.5.0-alpha.34",
+  "version": "0.5.0-alpha.35",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "./dist/index.js",

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

@@ -1,13 +0,0 @@
-import type { PathSegment } from '../types/path.js'
-import type { SignalBaseInstance } from '../Signal.js'
-
-export const REF_TARGET: unique symbol
-export function resolveRefSignalSafe<TSignal extends SignalBaseInstance> (
-  $signal: TSignal | undefined,
-  maxDepth?: number
-): TSignal | undefined
-export function resolveRefSegmentsSafe (
-  segments: readonly PathSegment[],
-  rootId?: string,
-  maxDepth?: number
-): PathSegment[] | undefined

package/dist/orm/Compat/refFallback.js

@@ -1,65 +0,0 @@
-import { getRefLinks } from './refRegistry.js';
-import { GLOBAL_ROOT_ID } from "../Root.js";
-export const REF_TARGET = Symbol.for('teamplay.compat.refTarget');
-export function resolveRefSignalSafe($signal, maxDepth = 32) {
-    let current = $signal;
-    const seen = new Set();
-    for (let i = 0; i < maxDepth; i++) {
-        if (!current)
-            return undefined;
-        const next = current[REF_TARGET];
-        if (!next)
-            return current;
-        if (seen.has(current))
-            return undefined;
-        seen.add(current);
-        current = next;
-    }
-    return undefined;
-}
-export function resolveRefSegmentsSafe(segments, rootId = GLOBAL_ROOT_ID, maxDepth = 32) {
-    if (!Array.isArray(segments) || segments.length === 0)
-        return undefined;
-    let current = [...segments];
-    const visited = new Set([toPathKey(current)]);
-    let changed = false;
-    for (let i = 0; i < maxDepth; i++) {
-        const link = findBestMatchingLink(current, rootId);
-        if (!link)
-            return changed ? current : undefined;
-        const suffix = current.slice(link.fromSegments.length);
-        const next = link.toSegments.concat(suffix);
-        const key = toPathKey(next);
-        if (visited.has(key))
-            return undefined;
-        visited.add(key);
-        current = next;
-        changed = true;
-    }
-    return undefined;
-}
-function findBestMatchingLink(segments, rootId) {
-    let best;
-    for (const link of getRefLinks(rootId).values()) {
-        if (link.mirrorOnly)
-            continue;
-        if (!isPathPrefix(link.fromSegments, segments))
-            continue;
-        if (!best || link.fromSegments.length > best.fromSegments.length) {
-            best = link;
-        }
-    }
-    return best;
-}
-function isPathPrefix(prefixSegments, fullSegments) {
-    if (prefixSegments.length > fullSegments.length)
-        return false;
-    for (let i = 0; i < prefixSegments.length; i++) {
-        if (prefixSegments[i] !== String(fullSegments[i]))
-            return false;
-    }
-    return true;
-}
-function toPathKey(segments) {
-    return segments.map(segment => String(segment)).join('.');
-}

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

@@ -1,6 +0,0 @@
-export function setRefLink(rootId: any, fromPath: any, toPath: any, fromSegments: any, toSegments: any, options?: {}): void;
-export function removeRefLink(rootId: any, fromPath: any): void;
-export function getRefLinks(rootId?: string): Map<string, unknown>;
-export function getAllRefLinks(): Generator<unknown, void, unknown>;
-export function getRefRootIds(): string[];
-export function __resetRefLinksForTests(): void;

package/dist/orm/Compat/refRegistry.js

@@ -1,54 +0,0 @@
-import { GLOBAL_ROOT_ID } from "../Root.js";
-import { normalizeRootId } from "../rootScope.js";
-import { getRootContext, getRootContexts } from "../rootContext.js";
-const EMPTY_MAP = new Map();
-export function setRefLink(rootId, fromPath, toPath, fromSegments, toSegments, options = {}) {
-    if (typeof fromPath !== 'string' || typeof toPath !== 'string')
-        return;
-    const normalizedFromSegments = Array.isArray(fromSegments)
-        ? fromSegments.map(segment => String(segment))
-        : splitPath(fromPath);
-    const normalizedToSegments = Array.isArray(toSegments)
-        ? toSegments.map(segment => String(segment))
-        : splitPath(toPath);
-    getRefStore(rootId, true).set(fromPath, {
-        fromPath,
-        toPath,
-        fromSegments: normalizedFromSegments,
-        toSegments: normalizedToSegments,
-        fromRootId: normalizeRootId(rootId),
-        toRootId: options.toRootId,
-        mirrorOnly: !!options.mirrorOnly,
-        onChange: typeof options.onChange === 'function' ? options.onChange : undefined
-    });
-}
-export function removeRefLink(rootId, fromPath) {
-    const store = getRefStore(rootId);
-    if (!store)
-        return;
-    store.delete(fromPath);
-}
-export function getRefLinks(rootId = GLOBAL_ROOT_ID) {
-    return getRefStore(rootId) || EMPTY_MAP;
-}
-export function* getAllRefLinks() {
-    for (const context of getRootContexts()) {
-        yield* context.refLinks.values();
-    }
-}
-export function getRefRootIds() {
-    return Array.from(getRootContexts())
-        .filter(context => context.refLinks.size > 0)
-        .map(context => context.rootId);
-}
-export function __resetRefLinksForTests() {
-    for (const context of getRootContexts()) {
-        context.resetRefs();
-    }
-}
-function splitPath(path) {
-    return path.split('.').filter(Boolean);
-}
-function getRefStore(rootId, create = false) {
-    return getRootContext(normalizeRootId(rootId), create)?.refLinks;
-}