teamplay 0.5.0-alpha.8 → 0.5.0

package/dist/orm/Compat/modelEvents.js

@@ -1,228 +0,0 @@
-import { getRefLinks, getRefRootIds } from './refRegistry.js';
-import { isCompatEnv } from '../compatEnv.js';
-import { isSilentContextActive, isModelEventsSilentContextActive, runInModelEventsSilentContext } 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();
-}
-export function normalizePattern(pattern, methodName) {
-    if (pattern && typeof pattern.path === 'function')
-        pattern = pattern.path();
-    if (pattern == null || typeof pattern !== 'string') {
-        if (methodName)
-            throw Error(`${methodName} expects a string path or a signal`);
-        return null;
-    }
-    return pattern.split('.').filter(Boolean).join('.');
-}
-export function onModelEvent(rootId, eventName, pattern, handler) {
-    if (typeof handler !== 'function')
-        throw Error('Model event handler must be a function');
-    if (!MODEL_EVENT_NAMES.includes(eventName))
-        throw Error(`Unsupported model event: ${eventName}`);
-    const store = getModelEventRootStore(eventName, rootId, true);
-    const normalized = normalizePattern(pattern);
-    let entry = store.get(normalized);
-    if (!entry) {
-        entry = {
-            pattern: normalized,
-            segments: splitPattern(normalized),
-            handlers: new Set()
-        };
-        store.set(normalized, entry);
-    }
-    entry.handlers.add(handler);
-    return handler;
-}
-export function removeModelListener(rootId, eventName, handler) {
-    const store = getModelEventRootStore(eventName, rootId);
-    if (!store)
-        return;
-    for (const [pattern, entry] of store) {
-        entry.handlers.delete(handler);
-        if (!entry.handlers.size)
-            store.delete(pattern);
-    }
-}
-export function emitModelChange(path, value, prevValue, meta) {
-    if (!isModelEventsEnabled())
-        return;
-    if (isSilentContextActive() || isModelEventsSilentContextActive())
-        return;
-    const initialSegments = splitPath(path);
-    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);
-            }
-        }
-    }
-}
-export function __resetModelEventsForTests() {
-    for (const context of getRootContexts()) {
-        context.resetModelListeners();
-    }
-}
-function emitForEvent(rootId, eventName, pathSegments, value, prevValue, meta, resolvedEventName = eventName) {
-    const store = getModelEventRootStore(eventName, rootId);
-    if (!store || store.size === 0)
-        return;
-    for (const entry of store.values()) {
-        const captures = matchPattern(entry.segments, pathSegments);
-        if (!captures)
-            continue;
-        for (const handler of entry.handlers) {
-            if (eventName === 'all') {
-                handler(...captures, resolvedEventName, value, prevValue, meta);
-            }
-            else {
-                handler(...captures, value, prevValue, meta);
-            }
-        }
-    }
-}
-function splitPattern(pattern) {
-    if (!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);
-}
-function getModelEventRootIds() {
-    const rootIds = new Set();
-    for (const context of getRootContexts()) {
-        for (const store of Object.values(context.modelListeners)) {
-            if (store.size)
-                rootIds.add(context.rootId);
-        }
-    }
-    return rootIds;
-}
-function getTargetRootIds(rootId) {
-    if (rootId != null)
-        return [normalizeRootId(rootId)];
-    const rootIds = new Set([
-        ...getModelEventRootIds(),
-        ...getRefRootIds()
-    ]);
-    return rootIds;
-}
-function splitPath(path) {
-    if (Array.isArray(path))
-        return path.map(segment => String(segment));
-    if (!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) {
-            return pathIndex === pathSegments.length ? [] : null;
-        }
-        const segment = patternSegments[patternIndex];
-        if (segment === '**') {
-            for (let i = pathIndex; i <= pathSegments.length; i++) {
-                const rest = walk(patternIndex + 1, i);
-                if (rest !== null) {
-                    const capture = pathSegments.slice(pathIndex, i).join('.');
-                    return [capture, ...rest];
-                }
-            }
-            return null;
-        }
-        if (pathIndex >= pathSegments.length)
-            return null;
-        if (segment === '*') {
-            const rest = walk(patternIndex + 1, pathIndex + 1);
-            if (rest === null)
-                return null;
-            return [pathSegments[pathIndex], ...rest];
-        }
-        if (segment !== pathSegments[pathIndex])
-            return null;
-        return walk(patternIndex + 1, pathIndex + 1);
-    }
-    return walk(0, 0);
-}

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

@@ -1,5 +0,0 @@
-export function isQueryReady(collection: any, idsSegments: any, docsSegments: any, extraSegments: any, aggregationSegments: any, isAggregate: any, hasExtraResult: any): boolean;
-export function isDocReady(segments: any): boolean;
-export function waitForImperativeQueryReady($query: any): Promise<void>;
-export function __setImperativeQueryReadyTimeoutForTests(timeoutMs: any): void;
-export function __resetImperativeQueryReadyTimeoutForTests(): void;

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;
-}

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

@@ -1,5 +0,0 @@
-export function isSilentContextActive(): boolean;
-export function isModelEventsSilentContextActive(): boolean;
-export function runInSilentContext(fn: any): any;
-export function runInModelEventsSilentContext(fn: any): any;
-export function __resetSilentContextForTests(): void;

package/dist/orm/Compat/silentContext.js

@@ -1,48 +0,0 @@
-let silentDepth = 0;
-let modelEventsSilentDepth = 0;
-export function isSilentContextActive() {
-    return silentDepth > 0;
-}
-export function isModelEventsSilentContextActive() {
-    return modelEventsSilentDepth > 0;
-}
-export function runInSilentContext(fn) {
-    silentDepth += 1;
-    let result;
-    try {
-        result = fn();
-    }
-    catch (error) {
-        silentDepth -= 1;
-        throw error;
-    }
-    if (result?.then) {
-        return Promise.resolve(result).finally(() => {
-            silentDepth -= 1;
-        });
-    }
-    silentDepth -= 1;
-    return result;
-}
-export function runInModelEventsSilentContext(fn) {
-    modelEventsSilentDepth += 1;
-    let result;
-    try {
-        result = fn();
-    }
-    catch (error) {
-        modelEventsSilentDepth -= 1;
-        throw error;
-    }
-    if (result?.then) {
-        return Promise.resolve(result).finally(() => {
-            modelEventsSilentDepth -= 1;
-        });
-    }
-    modelEventsSilentDepth -= 1;
-    return result;
-}
-export function __resetSilentContextForTests() {
-    silentDepth = 0;
-    modelEventsSilentDepth = 0;
-}

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

@@ -1,3 +0,0 @@
-export function compatStartOnRoot($root: any, targetPath: any, ...depsAndGetter: any[]): any;
-export function compatStopOnRoot($root: any, targetPath: any): void;
-export function joinScopePath(scopePath: any, relativePath: any): string;

package/dist/orm/Compat/startStopCompat.js

@@ -1,217 +0,0 @@
-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/compatEnv.d.ts

@@ -1 +0,0 @@
-export function isCompatEnv (): boolean

package/dist/orm/compatEnv.js

@@ -1,4 +0,0 @@
-export function isCompatEnv() {
-    return globalThis?.teamplayCompatibilityMode ??
-        (typeof process !== 'undefined' && process?.env?.TEAMPLAY_COMPAT === '1');
-}

package/dist/react/compatComponentRegistry.d.ts

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

package/dist/react/compatComponentRegistry.js

@@ -1,19 +0,0 @@
-const compatComponentIds = new Set();
-export function markCompatComponent(componentId) {
-    if (!componentId)
-        return;
-    compatComponentIds.add(componentId);
-}
-export function unmarkCompatComponent(componentId) {
-    if (!componentId)
-        return;
-    compatComponentIds.delete(componentId);
-}
-export function isCompatComponent(componentId) {
-    if (!componentId)
-        return false;
-    return compatComponentIds.has(componentId);
-}
-export function __resetCompatComponentRegistryForTests() {
-    compatComponentIds.clear();
-}