joist-core 2.3.0 → 2.4.0-next.2

package/build/relations/ReactiveReference.js

@@ -1,397 +1,333 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReactiveReferenceImpl = void 0;
-exports.hasReactiveReference = hasReactiveReference;
-exports.isReactiveReference = isReactiveReference;
-const __1 = require("..");
-const fields_1 = require("../fields");
-const newEntity_1 = require("../newEntity");
-const reactiveHints_1 = require("../reactiveHints");
-const AbstractRelationImpl_1 = require("./AbstractRelationImpl");
-const ManyToOneReference_1 = require("./ManyToOneReference");
-const Reference_1 = require("./Reference");
-const Relation_1 = require("./Relation");
+import { AbstractRelationImpl } from "./AbstractRelationImpl.js";
+import { RelationT, RelationU } from "./RelationSymbols.js";
+import { ReferenceN } from "./ReferenceSymbols.js";
+import { convertToLoadHint } from "../reactivity/reactiveHints.js";
+import { isLoaded } from "../loading/loadHints.js";
+import { getField, setField } from "../fields.js";
+import { deTagId, maybeResolveReferenceToId, toIdOf } from "../keys.js";
+import "./Reference.js";
+import { isCascadeDelete } from "./isCascadeDelete.js";
+import { failIfNewEntity, failNoId } from "./ManyToOneReference.js";
+import { fail } from "../utils.js";
+import { lazyField } from "../newEntity.js";
+import { getMetadata } from "../EntityMetadata.js";
+import { ensureNotDeleted } from "../index.js";
+import { getEmInternalApi, sameEntity } from "../EntityManager.js";
+import { isEntity } from "../Entity.js";
+import { getInstanceData } from "../BaseEntity.js";
+//#region src/relations/ReactiveReference.ts
 /** Creates a `ReactiveReference`. */
 function hasReactiveReference(hint, fn) {
-    return (0, newEntity_1.lazyField)((entity, fieldName) => {
-        const m2o = (0, __1.getMetadata)(entity).allFields[fieldName];
-        return new ReactiveReferenceImpl(entity, m2o, hint, fn);
-    });
+	return lazyField((entity, fieldName) => {
+		const m2o = getMetadata(entity).allFields[fieldName];
+		return new ReactiveReferenceImpl(entity, m2o, hint, fn);
+	});
 }
 /**
- * Implements ReactiveReferences.
- *
- * This is a bit trickier than ReactiveFields, because we have to differentiate our loaded
- * between:
- *
- * - our load hint is loaded, and we can directly calculate the referenced entity, or
- * - we've fetched the calculated/stored entity from the database, but not purposefully
- *   not re-calculating it (which would require fetching the load hint, which might be
- *   expensive, and defeat the point of having our field materialized in the database)
- *
- * Further, want to support all of:
- *
- * - When loaded & `.get` has been called, we cache the value
- *
- * - If a WIP mutation happens, we invalidate `.get` *but* if we check `.isLoaded`,
- *   we can return the live/updated value, without an `await`.
- *
- * - If a WIP mutation happens, we invalidate `.isLoaded`, and if we're *no longer loaded*,
- *   we want to keep returning the stale value (as asserted by the tests), but the next
- *   `load` / `populate` should load the graph & recalculate the value.
- */
-class ReactiveReferenceImpl extends AbstractRelationImpl_1.AbstractRelationImpl {
-    reactiveHint;
-    fn;
-    #fieldName;
-    #otherMeta;
-    #state;
-    // #isLoaded doesn't necessary care if we're ref-mode or full-mode, it's just
-    // whether a caller can call `.get` and not have it blow up.
-    #isLoaded = undefined;
-    #isCached = false;
-    #loadPromise;
-    constructor(entity, field, reactiveHint, fn) {
-        super(entity);
-        this.reactiveHint = reactiveHint;
-        this.fn = fn;
-        // Minimizing changes until the other PR lands...
-        this.#fieldName = field.fieldName;
-        this.#otherMeta = field.otherMetadata();
-        this.#state = new RRUnloadedState(this);
-        // We can be initialized with [entity | id | undefined], and if it's entity or id, then setImpl
-        // will set loaded appropriately; but if we're initialized undefined, then mark loaded here
-        if (entity.isNewEntity) {
-            // const isLoaded = isEntity(this.current()) ? true : undefined;
-        }
-        // If the property transformer is not enabled, then the RR will not be in the relations map because they are
-        // defined in the implementation file and not the codegen file.  So we should insert ourselves regardless.
-        (0, __1.getInstanceData)(entity).relations[field.fieldName] = this;
-    }
-    async load(opts) {
-        (0, __1.ensureNotDeleted)(this.entity, "pending");
-        const { loadHint } = this;
-        if (!this.isLoaded || opts?.forceReload) {
-            const { em } = this.entity;
-            // Just because we're not loaded, doesn't mean we necessarily need to load our full hint.
-            // We prefer to load only our previously-calculated/materialized value, and only load the
-            // full load hint if we need recalculated.
-            const maybeDirty = opts?.forceReload || (0, __1.getEmInternalApi)(em).rm.isMaybePendingRecalc(this.entity, this.fieldName);
-            if (maybeDirty) {
-                return (this.#loadPromise ??= em
-                    .populate(this.entity, { hint: loadHint, ...opts })
-                    .then(() => {
-                    this.#state = this.#state.enterRecalcMode(this);
-                    this.#isLoaded = true;
-                    (0, __1.getEmInternalApi)(this.entity.em).isLoadedCache.add(this);
-                    // Go through `this.get` so that `setField` is called to set our latest value
-                    this.#isCached = false;
-                    return this.doGet(opts);
-                })
-                    .finally(() => {
-                    this.#loadPromise = undefined;
-                }));
-            }
-            else {
-                // If we don't need a full recalc, just make sure we have the entity in memory
-                // ...ideally we would check `isSet` and whether the key was in the `instanceData`
-                const current = this.current();
-                if ((0, __1.isEntity)(current) || current === undefined) {
-                    this.#state = new RRRefState(this, current);
-                    this.#isLoaded = true;
-                    (0, __1.getEmInternalApi)(this.entity.em).isLoadedCache.add(this);
-                    return current;
-                }
-                else {
-                    return (this.#loadPromise ??= em
-                        .load(this.#otherMeta.cstr, current)
-                        .then((loaded) => {
-                        this.#state = new RRRefState(this, loaded);
-                        this.#isLoaded = true;
-                        (0, __1.getEmInternalApi)(this.entity.em).isLoadedCache.add(this);
-                        return loaded;
-                    })
-                        .finally(() => {
-                        this.#loadPromise = undefined;
-                    }));
-                }
-            }
-        }
-        // The ReactiveField.load() always sets `#isCached = false`, but our assertion is that our
-        // IsLoadedCache/resetIsLoaded infra is good enough to "see all invalidating mutations",
-        // so we don't need this explicit reset.
-        // this.#isCached = false;
-        return this.doGet(opts);
-    }
-    get isLoaded() {
-        // If we've cached an isLoaded value, just use that, see https://github.com/joist-orm/joist-orm/issues/1166
-        if (this.#isLoaded !== undefined)
-            return this.#isLoaded;
-        (0, __1.getEmInternalApi)(this.entity.em).isLoadedCache.add(this);
-        // If a WIP mutation has marked our field as potentially dirty, we need to be "full" loaded
-        const maybeDirty = (0, __1.getEmInternalApi)(this.entity.em).rm.isMaybePendingRecalc(this.entity, this.fieldName);
-        if (maybeDirty) {
-            // If we're dirty, only being "full" loaded is good enough to recalc
-            this.#state = this.#state.enterRecalcMode(this);
-            this.#isLoaded = (0, __1.isLoaded)(this.entity, this.loadHint);
-            this.#isCached = false;
-        }
-        else {
-            // If we've had `.load` called before, assume we're still loaded
-            this.#isLoaded = this.#state.canReturnValue;
-        }
-        return this.#isLoaded;
-    }
-    resetIsLoaded() {
-        this.#isLoaded = undefined;
-        this.#isCached = false;
-    }
-    doGet(opts) {
-        const { fn } = this;
-        (0, __1.ensureNotDeleted)(this.entity, "pending");
-        // Fast pass if we've already calculated this (cache invalidation will happen on
-        // any mutation via #resetIsLoaded)..
-        if (this.#isCached) {
-            return this.filterDeleted(this.#state.doGet(), opts);
-        }
-        // Call isLoaded to probe the load hint, and get `#isLoaded` set, but still have
-        // our `if` check the raw `#isLoaded` to know if we should eval-latest or return `loaded`.
-        if (this.isLoaded && this.#state.kind === "full") {
-            const newValue = this.filterDeleted(fn(this.entity), opts);
-            // It's cheap to set this every time we're called, i.e. even if it's not the
-            // official "being called during em.flush" update (...unless we're accessing it
-            // during the validate phase of `em.flush`, then skip it to avoid tripping up
-            // the "cannot change entities during flush" logic.)
-            if (!(0, __1.getEmInternalApi)(this.entity.em).isValidating) {
-                this.setImpl(newValue);
-            }
-            this.#state = new RRFullState(this, newValue);
-            this.#isCached = true;
-            (0, __1.getEmInternalApi)(this.entity.em).isLoadedCache.add(this);
-        }
-        else if (this.#state.canReturnValue) {
-            // We're either in ref mode, or in full mode but not actually fully loaded,
-            // but in theory those states only get set after `.load()` / `.preload()` / import,
-            // so we should have some stored value, even if it's not fully up-to-date.
-            this.#isCached = true;
-            (0, __1.getEmInternalApi)(this.entity.em).isLoadedCache.add(this);
-        }
-        else {
-            const noun = this.entity.isNewEntity ? "derived" : "loaded";
-            throw new Error(`${this.entity}.${this.fieldName} has not been ${noun} yet`);
-        }
-        return this.filterDeleted(this.#state.doGet(), opts);
-    }
-    get fieldValue() {
-        return (0, fields_1.getField)(this.entity, this.fieldName);
-    }
-    get getWithDeleted() {
-        return this.doGet({ withDeleted: true });
-    }
-    get get() {
-        return this.doGet({ withDeleted: false });
-    }
-    set(_) {
-        (0, __1.fail)(`Cannot set ${this.entity}.${this.fieldName} ReactiveReference directly.`);
-    }
-    get isSet() {
-        return this.current() !== undefined;
-    }
-    // Internal method used by OneToManyCollection
-    setImpl(entity) {
-        (0, __1.ensureNotDeleted)(this.entity, "pending");
-        if ((0, __1.sameEntity)(entity, this.current({ withDeleted: true }))) {
-            return;
-        }
-        // Prefer to keep the id in our data hash, but if this is a new entity w/o an id, use the entity itself
-        (0, fields_1.setField)(this.entity, this.fieldName, (0, __1.isEntity)(entity) ? (entity.idTaggedMaybe ?? entity) : entity);
-    }
-    get isPreloaded() {
-        return !!this.maybeFindEntity();
-    }
-    preload() {
-        this.#state = new RRRefState(this, this.maybeFindEntity());
-        this.#isLoaded = true;
-        this.#isCached = true;
-    }
-    unload() {
-        this.#state = new RRUnloadedState(this);
-        this.#isLoaded = false;
-        this.#isCached = false;
-        this.#loadPromise = undefined;
-    }
-    import(other, findEntity) {
-        this.#state = other.#state.import(this, findEntity);
-        this.#isLoaded = true;
-        this.#isCached = true;
-    }
-    /** Returns the tagged id of the current value. */
-    get idTaggedMaybe() {
-        (0, __1.ensureNotDeleted)(this.entity, "pending");
-        return (0, __1.maybeResolveReferenceToId)(this.current());
-    }
-    get id() {
-        return this.idMaybe || (0, ManyToOneReference_1.failNoId)(this.entity, this.fieldName, this.current());
-    }
-    get idUntagged() {
-        return this.idUntaggedMaybe || (0, ManyToOneReference_1.failNoId)(this.entity, this.fieldName, this.current());
-    }
-    get idIfSet() {
-        return this.idMaybe || (0, ManyToOneReference_1.failIfNewEntity)(this.entity, this.fieldName, this.current());
-    }
-    get idUntaggedIfSet() {
-        return this.idUntaggedMaybe || (0, ManyToOneReference_1.failIfNewEntity)(this.entity, this.fieldName, this.current());
-    }
-    get loadHint() {
-        const meta = (0, __1.getMetadata)(this.entity);
-        return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= (0, reactiveHints_1.convertToLoadHint)(meta, this.reactiveHint));
-    }
-    // private impl
-    /** Returns the id of the current value. */
-    get idMaybe() {
-        (0, __1.ensureNotDeleted)(this.entity, "pending");
-        return (0, __1.toIdOf)(this.otherMeta, this.idTaggedMaybe);
-    }
-    get idUntaggedMaybe() {
-        return (0, __1.deTagId)(this.otherMeta, this.idMaybe);
-    }
-    setFromOpts(_) {
-        throw new Error(`ReactiveReference ${this.entity}.${this.fieldName} cannot be set via opts`);
-    }
-    maybeCascadeDelete() {
-        if (this.isCascadeDelete) {
-            const current = this.current({ withDeleted: true });
-            if (current !== undefined && typeof current !== "string") {
-                this.entity.em.delete(current);
-            }
-        }
-    }
-    async cleanupOnEntityDeleted() {
-        // if we are going to delete this relation as well, then we don't need to clean it up
-        if (this.isCascadeDelete)
-            return;
-        (0, fields_1.setField)(this.entity, this.fieldName, undefined);
-        this.#state = new RRRefState(this, undefined);
-        this.#isLoaded = false;
-        this.#isCached = false;
-        this.#loadPromise = undefined;
-    }
-    // We need to keep U in data[fieldName] to handle entities without an id assigned yet.
-    current(opts) {
-        const current = (0, fields_1.getField)(this.entity, this.fieldName);
-        if (current !== undefined && (0, __1.isEntity)(current)) {
-            return this.filterDeleted(current, opts);
-        }
-        return current;
-    }
-    get fieldName() {
-        return this.#fieldName;
-    }
-    get otherMeta() {
-        return (0, __1.getMetadata)(this.entity).allFields[this.#fieldName].otherMetadata();
-    }
-    get hasBeenSet() {
-        return true;
-    }
-    toString() {
-        return `ReactiveReference(entity: ${this.entity}, hint: ${this.loadHint}, fieldName: ${this.fieldName}, otherMeta: {
+* Implements ReactiveReferences.
+*
+* This is a bit trickier than ReactiveFields, because we have to differentiate our loaded
+* between:
+*
+* - our load hint is loaded, and we can directly calculate the referenced entity, or
+* - we've fetched the calculated/stored entity from the database, but not purposefully
+*   not re-calculating it (which would require fetching the load hint, which might be
+*   expensive, and defeat the point of having our field materialized in the database)
+*
+* Further, want to support all of:
+*
+* - When loaded & `.get` has been called, we cache the value
+*
+* - If a WIP mutation happens, we invalidate `.get` *but* if we check `.isLoaded`,
+*   we can return the live/updated value, without an `await`.
+*
+* - If a WIP mutation happens, we invalidate `.isLoaded`, and if we're *no longer loaded*,
+*   we want to keep returning the stale value (as asserted by the tests), but the next
+*   `load` / `populate` should load the graph & recalculate the value.
+*/
+var ReactiveReferenceImpl = class extends AbstractRelationImpl {
+	reactiveHint;
+	fn;
+	#fieldName;
+	#otherMeta;
+	#state;
+	#isLoaded = void 0;
+	#isCached = false;
+	#loadPromise;
+	constructor(entity, field, reactiveHint, fn) {
+		super(entity);
+		this.reactiveHint = reactiveHint;
+		this.fn = fn;
+		this.#fieldName = field.fieldName;
+		this.#otherMeta = field.otherMetadata();
+		this.#state = new RRUnloadedState(this);
+		if (entity.isNewEntity) {}
+		(getInstanceData(entity).relations ??= {})[field.fieldName] = this;
+	}
+	async load(opts) {
+		ensureNotDeleted(this.entity, "pending");
+		const { loadHint } = this;
+		if (!this.isLoaded || opts?.forceReload) {
+			const { em } = this.entity;
+			if (opts?.forceReload || getEmInternalApi(em).rm.isMaybePendingRecalc(this.entity, this.fieldName)) return this.#loadPromise ??= em.populate(this.entity, {
+				hint: loadHint,
+				...opts
+			}).then(() => {
+				this.#state = this.#state.enterRecalcMode(this);
+				this.#isLoaded = true;
+				getEmInternalApi(this.entity.em).isLoadedCache.add(this);
+				this.#isCached = false;
+				return this.doGet(opts);
+			}).finally(() => {
+				this.#loadPromise = void 0;
+			});
+			else {
+				const current = this.current();
+				if (isEntity(current) || current === void 0) {
+					this.#state = new RRRefState(this, current);
+					this.#isLoaded = true;
+					getEmInternalApi(this.entity.em).isLoadedCache.add(this);
+					return current;
+				} else return this.#loadPromise ??= em.load(this.#otherMeta.cstr, current).then((loaded) => {
+					this.#state = new RRRefState(this, loaded);
+					this.#isLoaded = true;
+					getEmInternalApi(this.entity.em).isLoadedCache.add(this);
+					return loaded;
+				}).finally(() => {
+					this.#loadPromise = void 0;
+				});
+			}
+		}
+		return this.doGet(opts);
+	}
+	get isLoaded() {
+		if (this.#isLoaded !== void 0) return this.#isLoaded;
+		getEmInternalApi(this.entity.em).isLoadedCache.add(this);
+		if (getEmInternalApi(this.entity.em).rm.isMaybePendingRecalc(this.entity, this.fieldName)) {
+			this.#state = this.#state.enterRecalcMode(this);
+			this.#isLoaded = isLoaded(this.entity, this.loadHint);
+			this.#isCached = false;
+		} else this.#isLoaded = this.#state.canReturnValue;
+		return this.#isLoaded;
+	}
+	resetIsLoaded() {
+		this.#isLoaded = void 0;
+		this.#isCached = false;
+	}
+	doGet(opts) {
+		const { fn } = this;
+		ensureNotDeleted(this.entity, "pending");
+		if (this.#isCached) return this.filterDeleted(this.#state.doGet(), opts);
+		if (this.isLoaded && this.#state.kind === "full") {
+			const newValue = this.filterDeleted(fn(this.entity), opts);
+			if (!getEmInternalApi(this.entity.em).isValidating) this.setImpl(newValue);
+			this.#state = new RRFullState(this, newValue);
+			this.#isCached = true;
+			getEmInternalApi(this.entity.em).isLoadedCache.add(this);
+		} else if (this.#state.canReturnValue) {
+			this.#isCached = true;
+			getEmInternalApi(this.entity.em).isLoadedCache.add(this);
+		} else {
+			const noun = this.entity.isNewEntity ? "derived" : "loaded";
+			throw new Error(`${this.entity}.${this.fieldName} has not been ${noun} yet`);
+		}
+		return this.filterDeleted(this.#state.doGet(), opts);
+	}
+	get fieldValue() {
+		return getField(this.entity, this.fieldName);
+	}
+	get getWithDeleted() {
+		return this.doGet({ withDeleted: true });
+	}
+	get get() {
+		return this.doGet({ withDeleted: false });
+	}
+	set(_) {
+		fail(`Cannot set ${this.entity}.${this.fieldName} ReactiveReference directly.`);
+	}
+	get isSet() {
+		return this.current() !== void 0;
+	}
+	setImpl(entity) {
+		ensureNotDeleted(this.entity, "pending");
+		if (sameEntity(entity, this.current({ withDeleted: true }))) return;
+		setField(this.entity, this.fieldName, isEntity(entity) ? entity.idTaggedMaybe ?? entity : entity);
+	}
+	get isPreloaded() {
+		return !!this.maybeFindEntity();
+	}
+	preload() {
+		this.#state = new RRRefState(this, this.maybeFindEntity());
+		this.#isLoaded = true;
+		this.#isCached = true;
+	}
+	unload() {
+		this.#state = new RRUnloadedState(this);
+		this.#isLoaded = false;
+		this.#isCached = false;
+		this.#loadPromise = void 0;
+	}
+	import(other, findEntity) {
+		this.#state = other.#state.import(this, findEntity);
+		this.#isLoaded = true;
+		this.#isCached = true;
+	}
+	/** Returns the tagged id of the current value. */
+	get idTaggedMaybe() {
+		ensureNotDeleted(this.entity, "pending");
+		return maybeResolveReferenceToId(this.current());
+	}
+	get id() {
+		return this.idMaybe || failNoId(this.entity, this.fieldName, this.current());
+	}
+	get idUntagged() {
+		return this.idUntaggedMaybe || failNoId(this.entity, this.fieldName, this.current());
+	}
+	get idIfSet() {
+		return this.idMaybe || failIfNewEntity(this.entity, this.fieldName, this.current());
+	}
+	get idUntaggedIfSet() {
+		return this.idUntaggedMaybe || failIfNewEntity(this.entity, this.fieldName, this.current());
+	}
+	get loadHint() {
+		const meta = getMetadata(this.entity);
+		return meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.reactiveHint);
+	}
+	/** Returns the id of the current value. */
+	get idMaybe() {
+		ensureNotDeleted(this.entity, "pending");
+		return toIdOf(this.otherMeta, this.idTaggedMaybe);
+	}
+	get idUntaggedMaybe() {
+		return deTagId(this.otherMeta, this.idMaybe);
+	}
+	setFromOpts(_) {
+		throw new Error(`ReactiveReference ${this.entity}.${this.fieldName} cannot be set via opts`);
+	}
+	maybeCascadeDelete() {
+		if (this.isCascadeDelete) {
+			const current = this.current({ withDeleted: true });
+			if (current !== void 0 && typeof current !== "string") this.entity.em.delete(current);
+		}
+	}
+	async cleanupOnEntityDeleted() {
+		if (this.isCascadeDelete) return;
+		setField(this.entity, this.fieldName, void 0);
+		this.#state = new RRRefState(this, void 0);
+		this.#isLoaded = false;
+		this.#isCached = false;
+		this.#loadPromise = void 0;
+	}
+	current(opts) {
+		const current = getField(this.entity, this.fieldName);
+		if (current !== void 0 && isEntity(current)) return this.filterDeleted(current, opts);
+		return current;
+	}
+	get fieldName() {
+		return this.#fieldName;
+	}
+	get otherMeta() {
+		return getMetadata(this.entity).allFields[this.#fieldName].otherMetadata();
+	}
+	get hasBeenSet() {
+		return true;
+	}
+	toString() {
+		return `ReactiveReference(entity: ${this.entity}, hint: ${this.loadHint}, fieldName: ${this.fieldName}, otherMeta: {
       this.otherMeta.type
     }, id: ${this.id})`;
-    }
-    /**
-     * Removes pending-hard-delete (but not soft-deleted), unless explicitly asked for.
-     *
-     * Note that we leave soft-deleted entities b/c the call signature of a `book.author.get`
-     * very likely does not expect a soft-deleted entity to result in `undefined`.
-     *
-     * (Contrasted with `author.books.get` which is more intuitive to have soft-deleted
-     * entities filtered out, i.e. it doesn't fundamentally change the return type.)
-     */
-    filterDeleted(entity, opts) {
-        if (entity && (!opts || !opts.withDeleted) && entity.isDeletedEntity) {
-            return undefined;
-        }
-        return entity;
-    }
-    get isCascadeDelete() {
-        return (0, AbstractRelationImpl_1.isCascadeDelete)(this, this.#fieldName);
-    }
-    /**
-     * Looks for an entity in `EntityManager`, b/c we may have it in memory even if
-     * our reference is not specifically loaded.
-     */
-    maybeFindEntity() {
-        // Check this.loaded first b/c a new entity won't have an id yet
-        if (this.#state.canReturnValue) {
-            const loaded = this.#state.doGet();
-            if (loaded !== undefined) {
-                return loaded;
-            }
-        }
-        const { idTaggedMaybe } = this;
-        return idTaggedMaybe !== undefined ? this.entity.em.getEntity(idTaggedMaybe) : undefined;
-    }
-    [Relation_1.RelationT] = null;
-    [Relation_1.RelationU] = null;
-    [Reference_1.ReferenceN] = null;
-}
-exports.ReactiveReferenceImpl = ReactiveReferenceImpl;
+	}
+	/**
+	* Removes pending-hard-delete (but not soft-deleted), unless explicitly asked for.
+	*
+	* Note that we leave soft-deleted entities b/c the call signature of a `book.author.get`
+	* very likely does not expect a soft-deleted entity to result in `undefined`.
+	*
+	* (Contrasted with `author.books.get` which is more intuitive to have soft-deleted
+	* entities filtered out, i.e. it doesn't fundamentally change the return type.)
+	*/
+	filterDeleted(entity, opts) {
+		if (entity && (!opts || !opts.withDeleted) && entity.isDeletedEntity) return;
+		return entity;
+	}
+	get isCascadeDelete() {
+		return isCascadeDelete(this, this.#fieldName);
+	}
+	/**
+	* Looks for an entity in `EntityManager`, b/c we may have it in memory even if
+	* our reference is not specifically loaded.
+	*/
+	maybeFindEntity() {
+		if (this.#state.canReturnValue) {
+			const loaded = this.#state.doGet();
+			if (loaded !== void 0) return loaded;
+		}
+		const { idTaggedMaybe } = this;
+		return idTaggedMaybe !== void 0 ? this.entity.em.getEntity(idTaggedMaybe) : void 0;
+	}
+	[RelationT] = null;
+	[RelationU] = null;
+	[ReferenceN] = null;
+};
 /** Type guard utility for determining if an entity field is a ReactiveReference. */
 function isReactiveReference(maybeReactiveRef) {
-    return maybeReactiveRef instanceof ReactiveReferenceImpl;
-}
-class RRUnloadedState {
-    kind = "unloaded";
-    canReturnValue = false;
-    #rr;
-    constructor(rr) {
-        this.#rr = rr;
-    }
-    doGet() {
-        throw new Error(`${this.#rr.entity}.${this.#rr.fieldName} was not loaded`);
-    }
-    enterRecalcMode(target) {
-        return new RRFullState(target, undefined);
-    }
-    import(target, _findEntity) {
-        return new RRUnloadedState(target);
-    }
-}
-class RRRefState {
-    kind = "ref";
-    canReturnValue = true;
-    #loaded;
-    constructor(_rr, loaded) {
-        this.#loaded = loaded;
-    }
-    doGet() {
-        return this.#loaded;
-    }
-    enterRecalcMode(target) {
-        return new RRFullState(target, this.#loaded);
-    }
-    import(target, findEntity) {
-        return new RRRefState(target, mapReactiveReferenceEntity(this.#loaded, findEntity));
-    }
-}
-class RRFullState {
-    kind = "full";
-    canReturnValue = true;
-    #loaded;
-    constructor(_rr, loaded) {
-        this.#loaded = loaded;
-    }
-    doGet() {
-        return this.#loaded;
-    }
-    enterRecalcMode(_target) {
-        return this;
-    }
-    import(target, findEntity) {
-        return new RRRefState(target, mapReactiveReferenceEntity(this.#loaded, findEntity));
-    }
+	return maybeReactiveRef instanceof ReactiveReferenceImpl;
 }
+var RRUnloadedState = class RRUnloadedState {
+	kind = "unloaded";
+	canReturnValue = false;
+	#rr;
+	constructor(rr) {
+		this.#rr = rr;
+	}
+	doGet() {
+		throw new Error(`${this.#rr.entity}.${this.#rr.fieldName} was not loaded`);
+	}
+	enterRecalcMode(target) {
+		return new RRFullState(target, void 0);
+	}
+	import(target, _findEntity) {
+		return new RRUnloadedState(target);
+	}
+};
+var RRRefState = class RRRefState {
+	kind = "ref";
+	canReturnValue = true;
+	#loaded;
+	constructor(_rr, loaded) {
+		this.#loaded = loaded;
+	}
+	doGet() {
+		return this.#loaded;
+	}
+	enterRecalcMode(target) {
+		return new RRFullState(target, this.#loaded);
+	}
+	import(target, findEntity) {
+		return new RRRefState(target, mapReactiveReferenceEntity(this.#loaded, findEntity));
+	}
+};
+var RRFullState = class {
+	kind = "full";
+	canReturnValue = true;
+	#loaded;
+	constructor(_rr, loaded) {
+		this.#loaded = loaded;
+	}
+	doGet() {
+		return this.#loaded;
+	}
+	enterRecalcMode(_target) {
+		return this;
+	}
+	import(target, findEntity) {
+		return new RRRefState(target, mapReactiveReferenceEntity(this.#loaded, findEntity));
+	}
+};
 function mapReactiveReferenceEntity(entity, findEntity) {
-    return (0, __1.isEntity)(entity) ? findEntity(entity) : entity;
+	return isEntity(entity) ? findEntity(entity) : entity;
 }
+//#endregion
+export { ReactiveReferenceImpl, hasReactiveReference, isReactiveReference };
+
 //# sourceMappingURL=ReactiveReference.js.map