joist-core 2.3.0-next.7 → 2.3.0-next.71

package/build/ReactionsManager.js

@@ -1,315 +1,265 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReactionsManager = void 0;
-const EntityMetadata_1 = require("./EntityMetadata");
-const index_1 = require("./index");
-const ReactionLogger_1 = require("./logging/ReactionLogger");
-const reactiveHints_1 = require("./reactiveHints");
-const trusted_1 = require("./trusted");
+import { globalLogger, noopReactionLogger } from "./logging/ReactionLogger.js";
+import { runInTrustedContext } from "./trusted.js";
+import { getMetadata } from "./EntityMetadata.js";
+import { followReverseHint } from "./reactiveHints.js";
+import { NoIdError } from "./index.js";
+import { getEmInternalApi } from "./EntityManager.js";
+import "./Entity.js";
+import "./config.js";
+//#region src/ReactionsManager.ts
 /**
- * Manages the reactivity of tracking which source fields have changed and finding/recalculating
- * their downstream derived fields.
- *
- * Source fields are usually regular/dumb primitives, i.e. `Author.age` is a source field
- * of `Book.isPublic`, but derived fields can themselves be source fields as well.
- */
-class ReactionsManager {
-    /** Stores all source `Reactables`s that have been marked for later traversal. */
-    pendingReactables = new Map();
-    actionsPendingTypeErrors = new Map();
-    /**
-     * A map of entity tagName -> fields that have been marked as dirty.
-     *
-     * The key of the map is "just" the tag name, instead of a specific entity, b/c at the time of
-     * being marked dirty, we only have the upstream/source entity + fieldName that has changed, and
-     * not the 1-or-more downstream/target entities that will actually recalc.
-     *
-     * Instead, we just track the dirty fields by type-of-entity, which is enough for `isPendingRecalc`.
-     */
-    dirtyFields = new Map();
-    processedActions = new Set();
-    #needsRecalc = { populate: false, query: false, reaction: false };
-    // Accessible for EntityManager.runValidation to reuse
-    logger = ReactionLogger_1.globalLogger;
-    em;
-    /** These are NPEs that *might* have been from invalid m2o fields, so we only throw them after validation. */
-    suppressedTypeErrors = [];
-    constructor(em) {
-        this.em = em;
-    }
-    /**
-     * Queue all downstream reactive fields that depend on `fieldName` as a source field.
-     *
-     * This method can be synchronous b/c we internally queue the `Reactable` reverse
-     * indexes on the given source `fieldName`, and don't crawl/walk back to the downstream
-     * entities/fields until `recalcPendingReactables` is called.
-     */
-    queueDownstreamReactables(entity, fieldName) {
-        // Use the reverse index of Reactables that configureMetadata sets up
-        for (const r of this.getReactablesByField(entity, fieldName)) {
-            // We always queue the reactable/entity, even if we're mid-flush or even mid-recalc, to avoid:
-            // - firstName is changed from a1 to a2
-            // - this triggers firstName's reactable to `Author.initials` to be queued
-            // - during the 1st em.flush loop, we recalc `Author.initials` and it didn't change
-            // - during the 1st em.flush loop, a hook changes firstName from a2 to b2
-            // - if we skip re-queuing firstName's reactables, we will miss that initials needs
-            //   its `.load()` called again so that it's `setField` marks `initials` as
-            //   dirty, otherwise it will be left out of any INSERTs/UPDATEs.
-            this.getPending(r).todo.add(entity);
-            this.getDirtyFields((0, EntityMetadata_1.getMetadata)(r.cstr)).add(r.name);
-            this.#needsRecalc[r.kind] = true;
-            this.logger?.logQueued(entity, fieldName, r);
-        }
-    }
-    /** Dequeues reactivity on `fieldName`, i.e. if it's no longer dirty. */
-    dequeueDownstreamReactables(entity, fieldName) {
-        // Use the reverse index of Reactables that configureMetadata sets up
-        for (const r of this.getReactablesByField(entity, fieldName)) {
-            const pending = this.getPending(r);
-            if (pending.done.has(entity)) {
-                // Ironically, if we've already run this reactable, asking to dequeue probably means
-                // we need to run it again (to recalc its value), b/c this could be a mid-flush change, i.e.:
-                // - firstName = a1 from db
-                // - firstName is changed to a2, triggers initials reactable
-                // - firstName is changed back to a1, which is the original value, so setField
-                //   thinks we can dequeue the reactable
-                // - but actually our reactable needs to be re-run with the restored value
-                pending.todo.add(entity);
-                this.#needsRecalc[r.kind] = true;
-            }
-            else if (r.fields.length === 1) {
-                // We can only delete/dequeue a reaction if `fieldName` is the only or last field
-                // that had triggered `r` to run. Since we don't track that currently, i.e. we'd
-                // need to have a `Pending.dirtyFields`, for now just only dequeue if `r` only
-                // has one field (which is us) anyway.
-                pending.todo.delete(entity);
-            }
-        }
-    }
-    /** Queue all downstream reactive fields that depend on this entity being created or deleted. */
-    queueAllDownstreamFields(entity, reason) {
-        for (const r of this.getReactables(entity)) {
-            this.getPending(r).todo.add(entity);
-            this.getDirtyFields((0, EntityMetadata_1.getMetadata)(r.cstr)).add(r.name);
-            this.#needsRecalc[r.kind] = true;
-            this.logger?.logQueuedAll(entity, reason, r);
-        }
-    }
-    /**
-     * Returns whether this field might be pending recalc.
-     *
-     * This is technically a guess, b/c our reaction infra may not yet have crawled from an upstream
-     * source field down to the `N` specific target entities that need recalced, and instead just
-     * knows "it will need to do that soon" i.e. at the next `em.flush`.
-     *
-     * So, instead this is a heuristic that reports if `fieldName` has been marked dirty for _some_
-     * entities of type `entity`, but we don't technically know if that's _this_ entity.
-     *
-     * I.e. this might return false positives, but should never return false negatives.
-     */
-    isMaybePendingRecalc(entity, fieldName) {
-        return this.getDirtyFields((0, EntityMetadata_1.getMetadata)(entity)).has(fieldName);
-    }
-    hasPendingReactiveQueries() {
-        return this.#needsRecalc.query;
-    }
-    /**
-     * Given source `Reactable` "reverse indexes" that have been queued as dirty by calls
-     * to setters, `em.register`, or `em.delete`, asynchronously walks/crawls to the downstream
-     * derived fields and calls `.load()` on them to calc.
-     *
-     * We also do this in a loop to handle reactive fields depending on other reactive fields.
-     */
-    async recalcPendingReactables(kind) {
-        if (this.needsRecalc(kind))
-            this.logger?.logStartingRecalc(this.em, kind);
-        let loops = 0;
-        while (this.needsRecalc(kind)) {
-            // ...we probably should only loop for `kind=reactables` Reactables, and `kind=reactiveQueries`
-            // AsyncReactiveFields should probably only have a single loop, after which we return and
-            // let `em.flush` push the latest values to the db, so our 2nd-order AsyncReactiveFields
-            // will see the latest value.
-            if (kind === "reactables") {
-                this.#needsRecalc.populate = false;
-                this.#needsRecalc.reaction = false;
-            }
-            else {
-                this.#needsRecalc.query = false;
-            }
-            const actionsMap = new Map();
-            await Promise.all([...this.pendingReactables.entries()].map(async ([r, pending]) => {
-                // Skip reactive queries until post-flush
-                if (kind === "reactables" && r.kind === "query")
-                    return [];
-                if (kind === "reactiveQueries" && (r.kind === "populate" || r.kind === "reaction"))
-                    return [];
-                // Copy pending and clear it
-                const todo = [...pending.todo];
-                if (todo.length === 0)
-                    return [];
-                pending.todo.clear();
-                for (const doing of todo)
-                    pending.done.add(doing);
-                // Walk back from the source to any downstream entities
-                const entities = r.path.length === 0 ? todo : await (0, reactiveHints_1.followReverseHint)(r.name, todo, r.path);
-                const actionableEntities = entities.filter((entity) => !entity.isDeletedEntity && entity instanceof r.cstr);
-                this.logger?.logWalked(todo, r, actionableEntities, "recalc");
-                actionableEntities.forEach((entity) => {
-                    const key = makeActionKey(entity, r);
-                    // We could arrive at the same reactable from multiple paths (eg, 2 dependent fields changed), so we need to
-                    // dedupe based on the entity and reactable to only run each action once for any given entity per loop
-                    if (actionsMap.has(key))
-                        return;
-                    // If this reactable has already run and shouldn't run again, then skip it
-                    if (r.runOnce && this.processedActions.has(key))
-                        return;
-                    actionsMap.set(key, { key, r, entity });
-                });
-            }));
-            const actions = [...actionsMap.values()];
-            this.logger?.logLoadingStart(this.em, actions);
-            // Use allSettled so that we can watch for derived values that want to use an entity's id
-            // i.e. they can fail, but we'll queue them from later.
-            const startTime = this.logger?.now() ?? 0;
-            const results = await (0, trusted_1.runInTrustedContext)(() => Promise.allSettled(actions.map((a) => this.#doAction(a))));
-            const endTime = this.logger?.now() ?? 0;
-            this.logger?.logLoadingEnd(this.em, endTime - startTime);
-            const actionsPendingAssignedIds = new Map();
-            const failures = [];
-            results.forEach((result, i) => {
-                if (result.status === "rejected") {
-                    // Let `author.id` and `book.author.get.firstName` errors run again after flush/hooks fills them in
-                    if (result.reason instanceof index_1.NoIdError) {
-                        const action = actions[i];
-                        actionsPendingAssignedIds.set(action.key, action);
-                    }
-                    else if (result.reason instanceof TypeError) {
-                        const action = actions[i];
-                        this.actionsPendingTypeErrors.set(action.key, action);
-                    }
-                    else {
-                        failures.push(result.reason);
-                    }
-                }
-            });
-            // If we have any actions that need to be re-run because they failed due to a missing id, then we assign ids and
-            // re-run them.
-            if (actionsPendingAssignedIds.size > 0) {
-                await this.em.assignNewIds();
-                const actions = [...actionsPendingAssignedIds.values()];
-                this.logger?.logLoadingStart(this.em, actions);
-                const startTime = this.logger?.now() ?? 0;
-                const results = await (0, trusted_1.runInTrustedContext)(() => Promise.allSettled(actions.map((a) => this.#doAction(a))));
-                const endTime = this.logger?.now() ?? 0;
-                this.logger?.logLoadingEnd(this.em, endTime - startTime);
-                results.forEach((result, i) => {
-                    if (result.status === "rejected") {
-                        if (result.reason instanceof TypeError) {
-                            const action = actions[i];
-                            this.actionsPendingTypeErrors.set(action.key, action);
-                        }
-                        else {
-                            failures.push(result.reason);
-                        }
-                    }
-                });
-            }
-            if (failures.length > 0)
-                throw failures[0];
-            // Record any successful actions that should only run once so we don't run them again
-            actions.forEach((action) => {
-                if (action.r.runOnce)
-                    this.processedActions.add(action.key);
-            });
-            // This should generally not happen, only if two reactive fields depend on each other,
-            // which in theory should probably be caught/blow up in the `configureMetadata` step,
-            // but if it's not caught sooner, at least don't infinite loop.
-            if (loops++ > 50) {
-                throw new Error("recalc looped too many times, probably a circular dependency");
-            }
-        }
-    }
-    async recalcPendingTypeErrors() {
-        const actions = [...this.actionsPendingTypeErrors.values()];
-        this.actionsPendingTypeErrors.clear();
-        const startTime = this.logger?.now() ?? 0;
-        const results = await (0, trusted_1.runInTrustedContext)(() => Promise.allSettled(actions.filter((a) => !a.entity.isDeletedEntity).map((a) => this.#doAction(a))));
-        const endTime = this.logger?.now() ?? 0;
-        this.logger?.logLoadingEnd(this.em, endTime - startTime);
-        const failures = [];
-        results.forEach((result) => {
-            if (result.status === "rejected") {
-                if (result.reason instanceof TypeError) {
-                    // Defer to the validation error to catch this
-                    this.suppressedTypeErrors.push(result.reason);
-                }
-                else {
-                    failures.push(result.reason);
-                }
-            }
-        });
-        if (failures.length > 0)
-            throw failures[0];
-    }
-    get hasPendingTypeErrors() {
-        return this.actionsPendingTypeErrors.size > 0;
-    }
-    /** Clears all the pending source fields, i.e. after `em.flush` is complete. */
-    clear() {
-        this.pendingReactables = new Map();
-        this.processedActions.clear();
-    }
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    clearSuppressedTypeErrors() {
-        this.suppressedTypeErrors = [];
-    }
-    throwIfAnySuppressedTypeErrors() {
-        if (this.suppressedTypeErrors.length > 0) {
-            throw this.suppressedTypeErrors[0];
-        }
-    }
-    #doAction(action) {
-        const { r, entity } = action;
-        return r.kind === "reaction" ? r.fn(entity, this.em.ctx) : entity[r.name].load();
-    }
-    needsRecalc(kind) {
-        return kind === "reactables" ? this.#needsRecalc.populate || this.#needsRecalc.reaction : this.#needsRecalc.query;
-    }
-    getPending(r) {
-        let pending = this.pendingReactables.get(r);
-        if (!pending) {
-            pending = { todo: new Set(), done: new Set() };
-            this.pendingReactables.set(r, pending);
-        }
-        return pending;
-    }
-    getDirtyFields(meta) {
-        let dirty = this.dirtyFields.get(meta.tagName);
-        if (!dirty) {
-            dirty = new Set();
-            this.dirtyFields.set(meta.tagName, dirty);
-        }
-        return dirty;
-    }
-    getReactables(entity) {
-        // If two books are getting merged, and so a normally-immutable `BookReview.book` is being changed,
-        // then even normally-immutable fields need to be recalculated.
-        const meta = (0, EntityMetadata_1.getMetadata)(entity);
-        return (0, index_1.getEmInternalApi)(this.em).isMerging(entity) ? meta.reactablesIncludingReadOnly : meta.reactables;
-    }
-    getReactablesByField(entity, fieldName) {
-        const meta = (0, EntityMetadata_1.getMetadata)(entity);
-        const byField = (0, index_1.getEmInternalApi)(this.em).isMerging(entity)
-            ? meta.reactablesIncludingReadOnlyByField
-            : meta.reactablesByField;
-        return byField.get(fieldName) ?? [];
-    }
-}
-exports.ReactionsManager = ReactionsManager;
-/** Returns a stable dedupe key for retry/runOnce reaction bookkeeping. */
-function makeActionKey(entity, r) {
-    return `${entity.toTaggedString()}_${r.name}`;
-}
+* Manages the reactivity of tracking which source fields have changed and finding/recalculating
+* their downstream derived fields.
+*
+* Source fields are usually regular/dumb primitives, i.e. `Author.age` is a source field
+* of `Book.isPublic`, but derived fields can themselves be source fields as well.
+*/
+var ReactionsManager = class {
+	/** Stores all source `Reactables`s that have been marked for later traversal. */
+	pendingReactables = /* @__PURE__ */ new Map();
+	/** Failed actions to retry post-hooks, deduped by target field name -> entity (rare error path). */
+	actionsPendingTypeErrors = /* @__PURE__ */ new Map();
+	/**
+	* A map of entity tagName -> fields that have been marked as dirty.
+	*
+	* The key of the map is "just" the tag name, instead of a specific entity, b/c at the time of
+	* being marked dirty, we only have the upstream/source entity + fieldName that has changed, and
+	* not the 1-or-more downstream/target entities that will actually recalc.
+	*
+	* Instead, we just track the dirty fields by type-of-entity, which is enough for `isPendingRecalc`.
+	*/
+	dirtyFields = /* @__PURE__ */ new Map();
+	/**
+	* Tracks which entities have already run a `runOnce` reactable, keyed by the target field
+	* name -> entities. We key on `r.name` (not `r` itself) b/c two `Reactable`s reverse-indexed
+	* from different source paths can target the same derived field, and must dedupe together.
+	* Keying the outer map by field name (of which there are few) instead of by entity (of which
+	* there are many) means we allocate just one `Set` per distinct field name, rather than a
+	* `Set` per entity or the old per-action `${entity.toTaggedString()}_${r.name}` key strings.
+	*/
+	processedActions = /* @__PURE__ */ new Map();
+	#needsRecalc = {
+		populate: false,
+		query: false,
+		reaction: false
+	};
+	logger = globalLogger ?? noopReactionLogger;
+	em;
+	/** These are NPEs that *might* have been from invalid m2o fields, so we only throw them after validation. */
+	suppressedTypeErrors = [];
+	constructor(em) {
+		this.em = em;
+	}
+	/**
+	* Queue all downstream reactive fields that depend on `fieldName` as a source field.
+	*
+	* This method can be synchronous b/c we internally queue the `Reactable` reverse
+	* indexes on the given source `fieldName`, and don't crawl/walk back to the downstream
+	* entities/fields until `recalcPendingReactables` is called.
+	*/
+	queueDownstreamReactables(entity, fieldName) {
+		for (const r of this.getReactablesByField(entity, fieldName)) {
+			this.getPending(r).todo.add(entity);
+			this.#needsRecalc[r.kind] = true;
+			this.logger.logQueued(entity, fieldName, r);
+		}
+	}
+	/** Dequeues reactivity on `fieldName`, i.e. if it's no longer dirty. */
+	dequeueDownstreamReactables(entity, fieldName) {
+		for (const r of this.getReactablesByField(entity, fieldName)) {
+			const pending = this.getPending(r);
+			if (pending.done.has(entity)) {
+				pending.todo.add(entity);
+				this.#needsRecalc[r.kind] = true;
+			} else if (r.fields.length === 1) pending.todo.delete(entity);
+		}
+	}
+	/** Queue all downstream reactive fields that depend on this entity being created or deleted. */
+	queueAllDownstreamFields(entity, reason) {
+		for (const r of this.getReactables(entity)) {
+			this.getPending(r).todo.add(entity);
+			this.#needsRecalc[r.kind] = true;
+			this.logger.logQueuedAll(entity, reason, r);
+		}
+	}
+	/**
+	* Returns whether this field might be pending recalc.
+	*
+	* This is technically a guess, b/c our reaction infra may not yet have crawled from an upstream
+	* source field down to the `N` specific target entities that need recalced, and instead just
+	* knows "it will need to do that soon" i.e. at the next `em.flush`.
+	*
+	* So, instead this is a heuristic that reports if `fieldName` has been marked dirty for _some_
+	* entities of type `entity`, but we don't technically know if that's _this_ entity.
+	*
+	* I.e. this might return false positives, but should never return false negatives.
+	*/
+	isMaybePendingRecalc(entity, fieldName) {
+		return this.getDirtyFields(getMetadata(entity)).has(fieldName);
+	}
+	hasPendingReactiveQueries() {
+		return this.#needsRecalc.query;
+	}
+	/**
+	* Given source `Reactable` "reverse indexes" that have been queued as dirty by calls
+	* to setters, `em.register`, or `em.delete`, asynchronously walks/crawls to the downstream
+	* derived fields and calls `.load()` on them to calc.
+	*
+	* We also do this in a loop to handle reactive fields depending on other reactive fields.
+	*/
+	async recalcPendingReactables(kind) {
+		if (this.needsRecalc(kind)) this.logger.logStartingRecalc(this.em, kind);
+		let loops = 0;
+		while (this.needsRecalc(kind)) {
+			if (kind === "reactables") {
+				this.#needsRecalc.populate = false;
+				this.#needsRecalc.reaction = false;
+			} else this.#needsRecalc.query = false;
+			const seen = /* @__PURE__ */ new Map();
+			const actions = [];
+			const walks = await Promise.all([...this.pendingReactables.entries()].map(async ([r, pending]) => {
+				if (kind === "reactables" && r.kind === "query") return void 0;
+				if (kind === "reactiveQueries" && (r.kind === "populate" || r.kind === "reaction")) return void 0;
+				const todo = [...pending.todo];
+				if (todo.length === 0) return void 0;
+				pending.todo.clear();
+				for (const doing of todo) pending.done.add(doing);
+				const actionableEntities = (r.path.length === 0 ? todo : await followReverseHint(r.name, todo, r.path)).filter((entity) => !entity.isDeletedEntity && entity instanceof r.cstr);
+				let seenEntities = seen.get(r.name);
+				if (!seenEntities) seen.set(r.name, seenEntities = /* @__PURE__ */ new Set());
+				const processed = r.runOnce ? this.processedActions.get(r.name) : void 0;
+				for (const entity of actionableEntities) {
+					if (seenEntities.has(entity)) continue;
+					if (processed && processed.has(entity)) continue;
+					seenEntities.add(entity);
+					actions.push({
+						r,
+						entity
+					});
+				}
+				return {
+					r,
+					todo,
+					entities: actionableEntities
+				};
+			}));
+			this.logger.logWalks(walks, "recalc");
+			this.logger.logLoadingStart(this.em, actions);
+			const startTime = this.logger.now();
+			const results = await runInTrustedContext(() => Promise.allSettled(actions.map((a) => this.#doAction(a))));
+			const endTime = this.logger.now();
+			this.logger.logLoadingEnd(this.em, endTime - startTime);
+			const actionsPendingAssignedIds = [];
+			const failures = [];
+			results.forEach((result, i) => {
+				if (result.status === "rejected") {
+					if (result.reason instanceof NoIdError) actionsPendingAssignedIds.push(actions[i]);
+					else if (result.reason instanceof TypeError) this.addPendingTypeError(actions[i]);
+					else failures.push(result.reason);
+				}
+			});
+			if (actionsPendingAssignedIds.length > 0) {
+				await this.em.assignNewIds();
+				this.logger.logLoadingStart(this.em, actionsPendingAssignedIds);
+				const startTime = this.logger.now();
+				const results = await runInTrustedContext(() => Promise.allSettled(actionsPendingAssignedIds.map((a) => this.#doAction(a))));
+				const endTime = this.logger.now();
+				this.logger.logLoadingEnd(this.em, endTime - startTime);
+				results.forEach((result, i) => {
+					if (result.status === "rejected") {
+						if (result.reason instanceof TypeError) this.addPendingTypeError(actionsPendingAssignedIds[i]);
+						else failures.push(result.reason);
+					}
+				});
+			}
+			if (failures.length > 0) throw failures[0];
+			for (const action of actions) if (action.r.runOnce) {
+				let set = this.processedActions.get(action.r.name);
+				if (!set) this.processedActions.set(action.r.name, set = /* @__PURE__ */ new Set());
+				set.add(action.entity);
+			}
+			if (loops++ > 50) throw new Error("recalc looped too many times, probably a circular dependency");
+		}
+	}
+	async recalcPendingTypeErrors() {
+		const actions = [];
+		for (const byEntity of this.actionsPendingTypeErrors.values()) for (const action of byEntity.values()) actions.push(action);
+		this.actionsPendingTypeErrors.clear();
+		const startTime = this.logger.now();
+		const results = await runInTrustedContext(() => Promise.allSettled(actions.filter((a) => !a.entity.isDeletedEntity).map((a) => this.#doAction(a))));
+		const endTime = this.logger.now();
+		this.logger.logLoadingEnd(this.em, endTime - startTime);
+		const failures = [];
+		results.forEach((result) => {
+			if (result.status === "rejected") {
+				if (result.reason instanceof TypeError) this.suppressedTypeErrors.push(result.reason);
+				else failures.push(result.reason);
+			}
+		});
+		if (failures.length > 0) throw failures[0];
+	}
+	get hasPendingTypeErrors() {
+		return this.actionsPendingTypeErrors.size > 0;
+	}
+	/** Clears all the pending source fields, i.e. after `em.flush` is complete. */
+	clear() {
+		this.pendingReactables = /* @__PURE__ */ new Map();
+		this.processedActions.clear();
+	}
+	setLogger(logger) {
+		this.logger = logger ?? noopReactionLogger;
+	}
+	clearSuppressedTypeErrors() {
+		this.suppressedTypeErrors = [];
+	}
+	throwIfAnySuppressedTypeErrors() {
+		if (this.suppressedTypeErrors.length > 0) throw this.suppressedTypeErrors[0];
+	}
+	#doAction(action) {
+		const { r, entity } = action;
+		return r.kind === "reaction" ? r.fn(entity, this.em.ctx) : entity[r.name].load();
+	}
+	/** Remembers a TypeError'd action to retry post-hooks, deduped by (target field name, entity). */
+	addPendingTypeError(action) {
+		let byEntity = this.actionsPendingTypeErrors.get(action.r.name);
+		if (!byEntity) this.actionsPendingTypeErrors.set(action.r.name, byEntity = /* @__PURE__ */ new Map());
+		byEntity.set(action.entity, action);
+	}
+	needsRecalc(kind) {
+		return kind === "reactables" ? this.#needsRecalc.populate || this.#needsRecalc.reaction : this.#needsRecalc.query;
+	}
+	getPending(r) {
+		let pending = this.pendingReactables.get(r);
+		if (!pending) {
+			pending = {
+				todo: /* @__PURE__ */ new Set(),
+				done: /* @__PURE__ */ new Set()
+			};
+			this.pendingReactables.set(r, pending);
+			this.getDirtyFields(getMetadata(r.cstr)).add(r.name);
+		}
+		return pending;
+	}
+	getDirtyFields(meta) {
+		let dirty = this.dirtyFields.get(meta.tagName);
+		if (!dirty) {
+			dirty = /* @__PURE__ */ new Set();
+			this.dirtyFields.set(meta.tagName, dirty);
+		}
+		return dirty;
+	}
+	getReactables(entity) {
+		const meta = getMetadata(entity);
+		return getEmInternalApi(this.em).isMerging(entity) ? meta.reactablesIncludingReadOnly : meta.reactables;
+	}
+	getReactablesByField(entity, fieldName) {
+		const meta = getMetadata(entity);
+		return (getEmInternalApi(this.em).isMerging(entity) ? meta.reactablesIncludingReadOnlyByField : meta.reactablesByField).get(fieldName) ?? noReactables;
+	}
+};
+/** A shared frozen array for fields with no downstream reactables. */
+const noReactables = Object.freeze([]);
+//#endregion
+export { ReactionsManager };
+
 //# sourceMappingURL=ReactionsManager.js.map