joist-core 2.3.0-next.9 → 2.3.0-next.91

package/build/relations/AsyncProperty.js

@@ -1,80 +1,71 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncPropertyImpl = void 0;
-exports.hasAsyncProperty = hasAsyncProperty;
-exports.isAsyncProperty = isAsyncProperty;
-exports.isLoadedAsyncProperty = isLoadedAsyncProperty;
-const newEntity_1 = require("../newEntity");
-const AbstractPropertyImpl_1 = require("./AbstractPropertyImpl");
-const hasProperty_1 = require("./hasProperty");
+import { lazyField } from "../newEntity.js";
+import { AbstractPropertyImpl } from "./AbstractPropertyImpl.js";
+import { PropertyT } from "./PropertySymbols.js";
+import "./hasProperty.js";
+import "../Entity.js";
+//#region src/relations/AsyncProperty.ts
 /**
- * Creates a derived value calculated from a SQL query.
- *
- * Unlike `hasProperty`, the lambda receives the entity and is expected
- * to perform its own SQL queries rather than relying on in-memory graph data.
- *
- * - For new (un-flushed) entities, `load` throws because the entity has no id yet.
- * - The result is cached until the next `em.flush`.
- */
+* Creates a derived value calculated from a SQL query.
+*
+* Unlike `hasProperty`, the lambda receives the entity and is expected
+* to perform its own SQL queries rather than relying on in-memory graph data.
+*
+* - For new (un-flushed) entities, `load` throws because the entity has no id yet.
+* - The result is cached until the next `em.flush`.
+*/
 function hasAsyncProperty(fn) {
-    return (0, newEntity_1.lazyField)((entity) => {
-        return new AsyncPropertyImpl(entity, fn);
-    });
+	return lazyField((entity) => {
+		return new AsyncPropertyImpl(entity, fn);
+	});
 }
-class AsyncPropertyImpl extends AbstractPropertyImpl_1.AbstractPropertyImpl {
-    fn;
-    #loadPromise;
-    #loaded = false;
-    #value;
-    constructor(entity, fn) {
-        super(entity);
-        this.fn = fn;
-    }
-    load(opts) {
-        if (this.entity.isNewEntity) {
-            throw new Error("AsyncProperty cannot be loaded on a new entity that has not been flushed yet");
-        }
-        if (opts?.forceReload) {
-            this.#loadPromise = undefined;
-            this.#loaded = false;
-        }
-        if (this.#loaded) {
-            return Promise.resolve(this.#value);
-        }
-        return (this.#loadPromise ??= this.fn(this.entity).then((value) => {
-            this.#value = value;
-            this.#loaded = true;
-            return value;
-        }));
-    }
-    get get() {
-        if (this.entity.isNewEntity) {
-            throw new Error("AsyncProperty cannot be accessed on a new entity that has not been flushed yet");
-        }
-        if (!this.#loaded)
-            throw new Error("AsyncProperty has not been loaded yet");
-        return this.#value;
-    }
-    get isLoaded() {
-        if (this.entity.isNewEntity)
-            return false;
-        return this.#loaded;
-    }
-    /** Called after em.flush to invalidate the cached value. */
-    resetAfterFlush() {
-        this.#loadPromise = undefined;
-        this.#loaded = false;
-        this.#value = undefined;
-    }
-    [hasProperty_1.PropertyT] = undefined;
-}
-exports.AsyncPropertyImpl = AsyncPropertyImpl;
+var AsyncPropertyImpl = class extends AbstractPropertyImpl {
+	fn;
+	#loadPromise;
+	#loaded = false;
+	#value;
+	constructor(entity, fn) {
+		super(entity);
+		this.fn = fn;
+	}
+	load(opts) {
+		if (this.entity.isNewEntity) throw new Error("AsyncProperty cannot be loaded on a new entity that has not been flushed yet");
+		if (opts?.forceReload) {
+			this.#loadPromise = void 0;
+			this.#loaded = false;
+		}
+		if (this.#loaded) return Promise.resolve(this.#value);
+		return this.#loadPromise ??= this.fn(this.entity).then((value) => {
+			this.#value = value;
+			this.#loaded = true;
+			return value;
+		});
+	}
+	get get() {
+		if (this.entity.isNewEntity) throw new Error("AsyncProperty cannot be accessed on a new entity that has not been flushed yet");
+		if (!this.#loaded) throw new Error("AsyncProperty has not been loaded yet");
+		return this.#value;
+	}
+	get isLoaded() {
+		if (this.entity.isNewEntity) return false;
+		return this.#loaded;
+	}
+	/** Called after em.flush to invalidate the cached value. */
+	resetAfterFlush() {
+		this.#loadPromise = void 0;
+		this.#loaded = false;
+		this.#value = void 0;
+	}
+	[PropertyT] = void 0;
+};
 /** Type guard utility for determining if an entity field is an AsyncProperty. */
 function isAsyncProperty(maybe) {
-    return maybe instanceof AsyncPropertyImpl;
+	return maybe instanceof AsyncPropertyImpl;
 }
 /** Type guard utility for determining if an entity field is a loaded AsyncProperty. */
 function isLoadedAsyncProperty(maybe) {
-    return isAsyncProperty(maybe) && maybe.isLoaded;
+	return isAsyncProperty(maybe) && maybe.isLoaded;
 }
+//#endregion
+export { AsyncPropertyImpl, hasAsyncProperty, isAsyncProperty, isLoadedAsyncProperty };
+
 //# sourceMappingURL=AsyncProperty.js.map

package/build/relations/AsyncProperty.js.map

@@ -1 +1 @@
-{"version":3,"file":"AsyncProperty.js","sourceRoot":"","sources":["../../src/relations/AsyncProperty.ts"],"names":[],"mappings":";;;AAkBA,4CAMC;AA2DD,0CAEC;AAGD,sDAEC;AAzFD,4CAAyC;AACzC,iEAA8D;AAC9D,+CAAoD;AAMpD;;;;;;;;GAQG;AACH,SAAgB,gBAAgB,CAC9B,EAA6B;IAE7B,OAAO,IAAA,qBAAS,EAAC,CAAC,MAAS,EAAE,EAAE;QAC7B,OAAO,IAAI,iBAAiB,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC3C,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAa,iBACX,SAAQ,2CAAuB;IASrB;IANV,YAAY,CAAyB;IACrC,OAAO,GAAG,KAAK,CAAC;IAChB,MAAM,CAAgB;IAEtB,YACE,MAAS,EACD,EAA6B;QAErC,KAAK,CAAC,MAAM,CAAC,CAAC;QAFN,OAAE,GAAF,EAAE,CAA2B;IAGvC,CAAC;IAED,IAAI,CAAC,IAAgC;QACnC,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,8EAA8E,CAAC,CAAC;QAClG,CAAC;QACD,IAAI,IAAI,EAAE,WAAW,EAAE,CAAC;YACtB,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;YAC9B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACvB,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,MAAW,CAAC,CAAC;QAC3C,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YAChE,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YACpB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,OAAO,KAAK,CAAC;QACf,CAAC,CAAC,CAAC,CAAC;IACN,CAAC;IAED,IAAI,GAAG;QACL,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,gFAAgF,CAAC,CAAC;QACpG,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;QAC5E,OAAO,IAAI,CAAC,MAAW,CAAC;IAC1B,CAAC;IAED,IAAI,QAAQ;QACV,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW;YAAE,OAAO,KAAK,CAAC;QAC1C,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,4DAA4D;IAC5D,eAAe;QACb,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;QAC9B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;IAC1B,CAAC;IAED,CAAC,uBAAS,CAAC,GAAG,SAAqB,CAAC;CACrC;AAtDD,8CAsDC;AAED,iFAAiF;AACjF,SAAgB,eAAe,CAAC,KAAU;IACxC,OAAO,KAAK,YAAY,iBAAiB,CAAC;AAC5C,CAAC;AAED,uFAAuF;AACvF,SAAgB,qBAAqB,CAAC,KAAU;IAC9C,OAAO,eAAe,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC;AAClD,CAAC"}
+{"version":3,"file":"AsyncProperty.js","names":["#loadPromise","#loaded","#value"],"sources":["../../src/relations/AsyncProperty.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { AbstractPropertyImpl } from \"./AbstractPropertyImpl.ts\";\nimport { type LoadedProperty, type Property } from \"./hasProperty.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\n\nexport interface AsyncProperty<T extends Entity, V> extends Property<T, V> {\n  load(opts?: { forceReload?: boolean }): Promise<V>;\n}\n\n/**\n * Creates a derived value calculated from a SQL query.\n *\n * Unlike `hasProperty`, the lambda receives the entity and is expected\n * to perform its own SQL queries rather than relying on in-memory graph data.\n *\n * - For new (un-flushed) entities, `load` throws because the entity has no id yet.\n * - The result is cached until the next `em.flush`.\n */\nexport function hasAsyncProperty<T extends Entity, V>(fn: (entity: T) => Promise<V>): Property<T, V> {\n  return lazyField((entity: T) => {\n    return new AsyncPropertyImpl(entity, fn);\n  });\n}\n\nexport class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements AsyncProperty<T, V> {\n  #loadPromise: Promise<V> | undefined;\n  #loaded = false;\n  #value: V | undefined;\n\n  constructor(\n    entity: T,\n    private fn: (entity: T) => Promise<V>,\n  ) {\n    super(entity);\n  }\n\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    if (this.entity.isNewEntity) {\n      throw new Error(\"AsyncProperty cannot be loaded on a new entity that has not been flushed yet\");\n    }\n    if (opts?.forceReload) {\n      this.#loadPromise = undefined;\n      this.#loaded = false;\n    }\n    if (this.#loaded) {\n      return Promise.resolve(this.#value as V);\n    }\n    return (this.#loadPromise ??= this.fn(this.entity).then((value) => {\n      this.#value = value;\n      this.#loaded = true;\n      return value;\n    }));\n  }\n\n  get get(): V {\n    if (this.entity.isNewEntity) {\n      throw new Error(\"AsyncProperty cannot be accessed on a new entity that has not been flushed yet\");\n    }\n    if (!this.#loaded) throw new Error(\"AsyncProperty has not been loaded yet\");\n    return this.#value as V;\n  }\n\n  get isLoaded(): boolean {\n    if (this.entity.isNewEntity) return false;\n    return this.#loaded;\n  }\n\n  /** Called after em.flush to invalidate the cached value. */\n  resetAfterFlush(): void {\n    this.#loadPromise = undefined;\n    this.#loaded = false;\n    this.#value = undefined;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is an AsyncProperty. */\nexport function isAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> {\n  return maybe instanceof AsyncPropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded AsyncProperty. */\nexport function isLoadedAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> & LoadedProperty<any, any> {\n  return isAsyncProperty(maybe) && maybe.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,SAAgB,iBAAsC,IAA+C;CACnG,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,kBAAkB,QAAQ,EAAE;CACzC,CAAC;AACH;AAEA,IAAa,oBAAb,cAA4D,qBAAuD;CAOvG;CANV;CACA,UAAU;CACV;CAEA,YACE,QACA,IACA;EACA,MAAM,MAAM;EAFJ,KAAA,KAAA;CAGV;CAEA,KAAK,MAA8C;EACjD,IAAI,KAAK,OAAO,aACd,MAAM,IAAI,MAAM,8EAA8E;EAEhG,IAAI,MAAM,aAAa;GACrB,KAAKA,eAAe,KAAA;GACpB,KAAKC,UAAU;EACjB;EACA,IAAI,KAAKA,SACP,OAAO,QAAQ,QAAQ,KAAKC,MAAW;EAEzC,OAAQ,KAAKF,iBAAiB,KAAK,GAAG,KAAK,MAAM,CAAC,CAAC,MAAM,UAAU;GACjE,KAAKE,SAAS;GACd,KAAKD,UAAU;GACf,OAAO;EACT,CAAC;CACH;CAEA,IAAI,MAAS;EACX,IAAI,KAAK,OAAO,aACd,MAAM,IAAI,MAAM,gFAAgF;EAElG,IAAI,CAAC,KAAKA,SAAS,MAAM,IAAI,MAAM,uCAAuC;EAC1E,OAAO,KAAKC;CACd;CAEA,IAAI,WAAoB;EACtB,IAAI,KAAK,OAAO,aAAa,OAAO;EACpC,OAAO,KAAKD;CACd;;CAGA,kBAAwB;EACtB,KAAKD,eAAe,KAAA;EACpB,KAAKC,UAAU;EACf,KAAKC,SAAS,KAAA;CAChB;CAEA,CAAC,aAAa,KAAA;AAChB;;AAGA,SAAgB,gBAAgB,OAA8C;CAC5E,OAAO,iBAAiB;AAC1B;;AAGA,SAAgB,sBAAsB,OAAyE;CAC7G,OAAO,gBAAgB,KAAK,KAAK,MAAM;AACzC"}

package/build/relations/AsyncReactiveField.cjs

@@ -0,0 +1,110 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_newEntity = require("../newEntity.cjs");
+const require_relations_AbstractPropertyImpl = require("./AbstractPropertyImpl.cjs");
+const require_relations_PropertySymbols = require("./PropertySymbols.cjs");
+const require_EntityMetadata = require("../EntityMetadata.cjs");
+const require_fields = require("../fields.cjs");
+const require_reactiveHints = require("../reactiveHints.cjs");
+const require_normalizeHints = require("../normalizeHints.cjs");
+const require_loadHints = require("../loadHints.cjs");
+const require_utils = require("../utils.cjs");
+require("../index.cjs");
+require("../Entity.cjs");
+//#region src/relations/AsyncReactiveField.ts
+/**
+* An `AsyncReactiveField` is a value that is derived from a SQL query, similar to
+* a `ReactiveField`, but when the value needs to be calculated from SQL because
+* it would be too expensive to calculate in-memory.
+*
+* Its hint is split in two: the `loadHint` names data that is both reacted-to *and*
+* loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is
+* only reacted-to (its changes recompute the value) but is left in the database rather
+* than pulled into memory. The `fn` lambda re-runs when data referred to by either hint
+* changes, but only the `loadHint`'s data is populated.
+*/
+function hasAsyncReactiveField(loadHint, reactiveHint, fn) {
+	return require_newEntity.lazyField((entity, fieldName) => {
+		return new AsyncReactiveFieldImpl(entity, fieldName, loadHint, reactiveHint, fn);
+	});
+}
+var AsyncReactiveFieldImpl = class extends require_relations_AbstractPropertyImpl.AbstractPropertyImpl {
+	fieldName;
+	fn;
+	#loadHint;
+	#reactiveHint;
+	#loadPromise;
+	#loaded;
+	#useFactoryValue = false;
+	constructor(entity, fieldName, loadHint, reactiveHint, fn) {
+		super(entity);
+		this.fieldName = fieldName;
+		this.fn = fn;
+		this.#loadHint = loadHint;
+		this.#reactiveHint = reactiveHint;
+		this.#loaded = false;
+	}
+	/**
+	* Our combined load + reactive-only hint, so that we react to changes within both.
+	*
+	* The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`
+	* half only triggers recalculation, so its data stays in the database.
+	*/
+	get reactiveHint() {
+		const hint = require_normalizeHints.deepNormalizeHint(this.#loadHint);
+		require_utils.mergeNormalizedHints(hint, require_normalizeHints.deepNormalizeHint(this.#reactiveHint));
+		return hint;
+	}
+	load(opts) {
+		return this.#loadPromise ??= this.entity.em.populate(this.entity, { hint: this.loadHint }).then(() => {
+			return this.#useFactoryValue ? this.fieldValue : this.fn(this.entity);
+		}).then((newValue) => {
+			require_fields.setField(this.entity, this.fieldName, newValue);
+			this.#loadPromise = void 0;
+			this.#loaded = true;
+			return newValue;
+		}).catch((e) => {
+			this.#loadPromise = void 0;
+			throw e;
+		});
+	}
+	/** Returns the previously-calculated value. */
+	get get() {
+		if (this.isSet) return this.fieldValue;
+		else throw new Error(`${this.fieldName} has not been derived yet`);
+	}
+	get fieldValue() {
+		return require_fields.getField(this.entity, this.fieldName);
+	}
+	get isSet() {
+		return require_fields.isFieldSet(this.entity, this.fieldName);
+	}
+	get isLoaded() {
+		const hintLoaded = require_loadHints.isLoaded(this.entity, this.loadHint);
+		if (hintLoaded) this.#loaded = true;
+		return hintLoaded;
+	}
+	get loadHint() {
+		const meta = require_EntityMetadata.getMetadata(this.entity);
+		return meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= require_reactiveHints.convertToLoadHint(meta, this.#loadHint);
+	}
+	setFactoryValue(newValue) {
+		this.#useFactoryValue = true;
+		require_fields.setField(this.entity, this.fieldName, newValue);
+	}
+	[require_relations_PropertySymbols.PropertyT] = void 0;
+};
+/** Type guard utility for determining if an entity field is an AsyncReactiveField. */
+function isAsyncReactiveField(maybe) {
+	return maybe instanceof AsyncReactiveFieldImpl;
+}
+/** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */
+function isLoadedAsyncReactiveField(maybe) {
+	return isAsyncReactiveField(maybe) && maybe.isLoaded;
+}
+//#endregion
+exports.AsyncReactiveFieldImpl = AsyncReactiveFieldImpl;
+exports.hasAsyncReactiveField = hasAsyncReactiveField;
+exports.isAsyncReactiveField = isAsyncReactiveField;
+exports.isLoadedAsyncReactiveField = isLoadedAsyncReactiveField;
+
+//# sourceMappingURL=AsyncReactiveField.cjs.map

package/build/relations/AsyncReactiveField.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncReactiveField.cjs","names":["lazyField","AbstractPropertyImpl","#loadHint","#reactiveHint","#loaded","deepNormalizeHint","#loadPromise","#useFactoryValue","getField","isFieldSet","isLoaded","getMetadata","convertToLoadHint","PropertyT"],"sources":["../../src/relations/AsyncReactiveField.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { getMetadata } from \"../EntityMetadata.ts\";\nimport { getField, isFieldSet, setField } from \"../fields.ts\";\nimport { type ReactiveField, deepNormalizeHint, isLoaded } from \"../index.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { type Reacted, type ReactiveHint, convertToLoadHint } from \"../reactiveHints.ts\";\nimport { mergeNormalizedHints } from \"../utils.ts\";\nimport { AbstractPropertyImpl } from \"./AbstractPropertyImpl.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\n\n/**\n * An `AsyncReactiveField` is a value that is derived from a SQL query, similar to\n * a `ReactiveField`, but when the value needs to be calculated from SQL because\n * it would be too expensive to calculate in-memory.\n *\n * Its hint is split in two: the `loadHint` names data that is both reacted-to *and*\n * loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is\n * only reacted-to (its changes recompute the value) but is left in the database rather\n * than pulled into memory. The `fn` lambda re-runs when data referred to by either hint\n * changes, but only the `loadHint`'s data is populated.\n */\nexport function hasAsyncReactiveField<\n  T extends Entity,\n  const H1 extends ReactiveHint<T>,\n  const H2 extends ReactiveHint<T>,\n  V,\n>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new AsyncReactiveFieldImpl(entity, fieldName as keyof T & string, loadHint, reactiveHint, fn);\n  });\n}\n\nexport class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V>\n  extends AbstractPropertyImpl<T>\n  implements ReactiveField<T, V>\n{\n  readonly #loadHint: H1;\n  readonly #reactiveHint: H2;\n  #loadPromise: any;\n  #loaded: boolean;\n  #useFactoryValue = false;\n\n  constructor(\n    entity: T,\n    public fieldName: keyof T & string,\n    loadHint: H1,\n    reactiveHint: H2,\n    private fn: (entity: Reacted<T, H1>) => Promise<V>,\n  ) {\n    super(entity);\n    this.#loadHint = loadHint;\n    this.#reactiveHint = reactiveHint;\n    this.#loaded = false;\n  }\n\n  /**\n   * Our combined load + reactive-only hint, so that we react to changes within both.\n   *\n   * The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`\n   * half only triggers recalculation, so its data stays in the database.\n   */\n  get reactiveHint(): ReactiveHint<any> {\n    // We do this in a getter (instead of the constructor) b/c it might be a little expensive,\n    // and I'm pretty sure this is only called on boot, when hooking up the reactivity.\n    const hint = deepNormalizeHint(this.#loadHint);\n    mergeNormalizedHints(hint, deepNormalizeHint(this.#reactiveHint));\n    return hint;\n  }\n\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    // if (!this.isSet || opts?.forceReload) {\n    return (this.#loadPromise ??= this.entity.em\n      .populate(this.entity, { hint: this.loadHint } as any)\n      .then(() => {\n        // Even if the factory used a `with...`, we'll still go through the RFQ logic, but just ignore the new value\n        return this.#useFactoryValue ? this.fieldValue : this.fn(this.entity as Reacted<T, H1>);\n      })\n      .then((newValue) => {\n        setField(this.entity, this.fieldName, newValue);\n        this.#loadPromise = undefined;\n        this.#loaded = true;\n        return newValue;\n      })\n      .catch((e) => {\n        // If we blow up calling `this.fn` i.e. due to a NoIdError, we want to make\n        // sure that the next `.load` call tries again.\n        this.#loadPromise = undefined;\n        throw e;\n      }));\n    // }\n    // return tryResolve(() => this.get);\n  }\n\n  /** Returns the previously-calculated value. */\n  get get(): V {\n    // Regular ReactiveFields repeatedly call their `fn` lambda to calculate the value, to ensure\n    // they always return the latest/correct value, but because AsyncReactiveFields are fundamentally\n    // calculated from DB queries, we can only return the previously-calculated value, if set.\n    if (this.isSet) {\n      return this.fieldValue;\n    } else {\n      throw new Error(`${this.fieldName} has not been derived yet`);\n    }\n  }\n\n  get fieldValue(): V {\n    return getField(this.entity, this.fieldName);\n  }\n\n  get isSet() {\n    return isFieldSet(this.entity, this.fieldName);\n  }\n\n  get isLoaded() {\n    const hintLoaded = isLoaded(this.entity, this.loadHint);\n    if (hintLoaded) {\n      this.#loaded = true;\n    }\n    return hintLoaded;\n  }\n\n  get loadHint(): any {\n    // Only convert the loadHint, so we don't pull the reactiveHint-referenced data into memory\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.#loadHint));\n  }\n\n  setFactoryValue(newValue: any): void {\n    this.#useFactoryValue = true;\n    setField(this.entity, this.fieldName, newValue);\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is an AsyncReactiveField. */\nexport function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any> {\n  return maybe instanceof AsyncReactiveFieldImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */\nexport function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any> {\n  return isAsyncReactiveField(maybe) && maybe.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,sBAKd,UAAc,cAAkB,IAAiE;CACjG,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,uBAAuB,QAAQ,WAA+B,UAAU,cAAc,EAAE;CACrG,CAAC;AACH;AAEA,IAAa,yBAAb,cACUC,uCAAAA,qBAEV;CASW;CAGC;CAXV;CACA;CACA;CACA;CACA,mBAAmB;CAEnB,YACE,QACA,WACA,UACA,cACA,IACA;EACA,MAAM,MAAM;EALL,KAAA,YAAA;EAGC,KAAA,KAAA;EAGR,KAAKC,YAAY;EACjB,KAAKC,gBAAgB;EACrB,KAAKC,UAAU;CACjB;;;;;;;CAQA,IAAI,eAAkC;EAGpC,MAAM,OAAOC,uBAAAA,kBAAkB,KAAKH,SAAS;EAC7C,cAAA,qBAAqB,MAAMG,uBAAAA,kBAAkB,KAAKF,aAAa,CAAC;EAChE,OAAO;CACT;CAEA,KAAK,MAA8C;EAEjD,OAAQ,KAAKG,iBAAiB,KAAK,OAAO,GACvC,SAAS,KAAK,QAAQ,EAAE,MAAM,KAAK,SAAS,CAAQ,CAAC,CACrD,WAAW;GAEV,OAAO,KAAKC,mBAAmB,KAAK,aAAa,KAAK,GAAG,KAAK,MAAwB;EACxF,CAAC,CAAC,CACD,MAAM,aAAa;GAClB,eAAA,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;GAC9C,KAAKD,eAAe,KAAA;GACpB,KAAKF,UAAU;GACf,OAAO;EACT,CAAC,CAAC,CACD,OAAO,MAAM;GAGZ,KAAKE,eAAe,KAAA;GACpB,MAAM;EACR,CAAC;CAGL;;CAGA,IAAI,MAAS;EAIX,IAAI,KAAK,OACP,OAAO,KAAK;OAEZ,MAAM,IAAI,MAAM,GAAG,KAAK,UAAU,0BAA0B;CAEhE;CAEA,IAAI,aAAgB;EAClB,OAAOE,eAAAA,SAAS,KAAK,QAAQ,KAAK,SAAS;CAC7C;CAEA,IAAI,QAAQ;EACV,OAAOC,eAAAA,WAAW,KAAK,QAAQ,KAAK,SAAS;CAC/C;CAEA,IAAI,WAAW;EACb,MAAM,aAAaC,kBAAAA,SAAS,KAAK,QAAQ,KAAK,QAAQ;EACtD,IAAI,YACF,KAAKN,UAAU;EAEjB,OAAO;CACT;CAEA,IAAI,WAAgB;EAElB,MAAM,OAAOO,uBAAAA,YAAY,KAAK,MAAM;EACpC,OAAQ,KAAK,OAAO,OAAO,wBAAwB,KAAK,eAAeC,sBAAAA,kBAAkB,MAAM,KAAKV,SAAS;CAC/G;CAEA,gBAAgB,UAAqB;EACnC,KAAKK,mBAAmB;EACxB,eAAA,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;CAChD;CAEA,CAACM,kCAAAA,aAAa,KAAA;AAChB;;AAGA,SAAgB,qBAAqB,OAA8C;CACjF,OAAO,iBAAiB;AAC1B;;AAGA,SAAgB,2BAA2B,OAA8C;CACvF,OAAO,qBAAqB,KAAK,KAAK,MAAM;AAC9C"}

package/build/relations/AsyncReactiveField.d.cts

@@ -0,0 +1,50 @@
+import { AbstractPropertyImpl } from "./AbstractPropertyImpl.cjs";
+import { PropertyT } from "./PropertySymbols.cjs";
+import { ReactiveField } from "./ReactiveField.cjs";
+import { Reacted, ReactiveHint } from "../reactiveHints.cjs";
+import "../index.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/relations/AsyncReactiveField.d.ts
+/**
+ * An `AsyncReactiveField` is a value that is derived from a SQL query, similar to
+ * a `ReactiveField`, but when the value needs to be calculated from SQL because
+ * it would be too expensive to calculate in-memory.
+ *
+ * Its hint is split in two: the `loadHint` names data that is both reacted-to *and*
+ * loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is
+ * only reacted-to (its changes recompute the value) but is left in the database rather
+ * than pulled into memory. The `fn` lambda re-runs when data referred to by either hint
+ * changes, but only the `loadHint`'s data is populated.
+ */
+declare function hasAsyncReactiveField<T extends Entity, const H1 extends ReactiveHint<T>, const H2 extends ReactiveHint<T>, V>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V>;
+declare class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V> extends AbstractPropertyImpl<T> implements ReactiveField<T, V> {
+  #private;
+  fieldName: keyof T & string;
+  private fn;
+  constructor(entity: T, fieldName: keyof T & string, loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>);
+  /**
+   * Our combined load + reactive-only hint, so that we react to changes within both.
+   *
+   * The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`
+   * half only triggers recalculation, so its data stays in the database.
+   */
+  get reactiveHint(): ReactiveHint<any>;
+  load(opts?: {
+    forceReload?: boolean;
+  }): Promise<V>;
+  /** Returns the previously-calculated value. */
+  get get(): V;
+  get fieldValue(): V;
+  get isSet(): boolean;
+  get isLoaded(): boolean;
+  get loadHint(): any;
+  setFactoryValue(newValue: any): void;
+  [PropertyT]: T;
+}
+/** Type guard utility for determining if an entity field is an AsyncReactiveField. */
+declare function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
+/** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */
+declare function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
+//#endregion
+export { AsyncReactiveFieldImpl, hasAsyncReactiveField, isAsyncReactiveField, isLoadedAsyncReactiveField };
+//# sourceMappingURL=AsyncReactiveField.d.cts.map

package/build/relations/AsyncReactiveField.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncReactiveField.d.cts","names":[],"sources":["../../src/relations/AsyncReactiveField.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAqBgB,sBACd,UAAU,cACJ,WAAW,aAAa,UACxB,WAAW,aAAa,IAC9B,GACA,UAAU,IAAI,cAAc,IAAI,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ,KAAK,cAAc,GAAG;cAMnF,uBAAuB,UAAU,QAAQ,WAAW,aAAa,IAAI,WAAW,aAAa,IAAI,WACpG,qBAAqB,cAClB,cAAc,GAAG;;EAUnB,iBAAiB;UAGhB;EALV,YACE,QAAQ,GACD,iBAAiB,YACxB,UAAU,IACV,cAAc,IACN,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ;;;;;;;MAc9C,gBAAgB;EAQpB,KAAK;IAAS;MAA0B,QAAQ;;MAyB5C,OAAO;MAWP,cAAc;MAId;MAIA;MAQA;EAMJ,gBAAgB;GAKf,YAAiC;;;iBAIpB,qBAAqB,aAAa,SAAS;;iBAK3C,2BAA2B,aAAa,SAAS"}

package/build/relations/AsyncReactiveField.d.mts

@@ -0,0 +1,50 @@
+import { AbstractPropertyImpl } from "./AbstractPropertyImpl.mjs";
+import { PropertyT } from "./PropertySymbols.mjs";
+import { ReactiveField } from "./ReactiveField.mjs";
+import { Reacted, ReactiveHint } from "../reactiveHints.mjs";
+import "../index.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/relations/AsyncReactiveField.d.ts
+/**
+ * An `AsyncReactiveField` is a value that is derived from a SQL query, similar to
+ * a `ReactiveField`, but when the value needs to be calculated from SQL because
+ * it would be too expensive to calculate in-memory.
+ *
+ * Its hint is split in two: the `loadHint` names data that is both reacted-to *and*
+ * loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is
+ * only reacted-to (its changes recompute the value) but is left in the database rather
+ * than pulled into memory. The `fn` lambda re-runs when data referred to by either hint
+ * changes, but only the `loadHint`'s data is populated.
+ */
+declare function hasAsyncReactiveField<T extends Entity, const H1 extends ReactiveHint<T>, const H2 extends ReactiveHint<T>, V>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V>;
+declare class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V> extends AbstractPropertyImpl<T> implements ReactiveField<T, V> {
+  #private;
+  fieldName: keyof T & string;
+  private fn;
+  constructor(entity: T, fieldName: keyof T & string, loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>);
+  /**
+   * Our combined load + reactive-only hint, so that we react to changes within both.
+   *
+   * The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`
+   * half only triggers recalculation, so its data stays in the database.
+   */
+  get reactiveHint(): ReactiveHint<any>;
+  load(opts?: {
+    forceReload?: boolean;
+  }): Promise<V>;
+  /** Returns the previously-calculated value. */
+  get get(): V;
+  get fieldValue(): V;
+  get isSet(): boolean;
+  get isLoaded(): boolean;
+  get loadHint(): any;
+  setFactoryValue(newValue: any): void;
+  [PropertyT]: T;
+}
+/** Type guard utility for determining if an entity field is an AsyncReactiveField. */
+declare function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
+/** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */
+declare function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
+//#endregion
+export { AsyncReactiveFieldImpl, hasAsyncReactiveField, isAsyncReactiveField, isLoadedAsyncReactiveField };
+//# sourceMappingURL=AsyncReactiveField.d.mts.map

package/build/relations/AsyncReactiveField.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncReactiveField.d.mts","names":[],"sources":["../../src/relations/AsyncReactiveField.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAqBgB,sBACd,UAAU,cACJ,WAAW,aAAa,UACxB,WAAW,aAAa,IAC9B,GACA,UAAU,IAAI,cAAc,IAAI,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ,KAAK,cAAc,GAAG;cAMnF,uBAAuB,UAAU,QAAQ,WAAW,aAAa,IAAI,WAAW,aAAa,IAAI,WACpG,qBAAqB,cAClB,cAAc,GAAG;;EAUnB,iBAAiB;UAGhB;EALV,YACE,QAAQ,GACD,iBAAiB,YACxB,UAAU,IACV,cAAc,IACN,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ;;;;;;;MAc9C,gBAAgB;EAQpB,KAAK;IAAS;MAA0B,QAAQ;;MAyB5C,OAAO;MAWP,cAAc;MAId;MAIA;MAQA;EAMJ,gBAAgB;GAKf,YAAiC;;;iBAIpB,qBAAqB,aAAa,SAAS;;iBAK3C,2BAA2B,aAAa,SAAS"}

package/build/relations/AsyncReactiveField.js

@@ -1,125 +1,106 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncReactiveFieldImpl = void 0;
-exports.hasAsyncReactiveField = hasAsyncReactiveField;
-exports.isAsyncReactiveField = isAsyncReactiveField;
-exports.isLoadedAsyncReactiveField = isLoadedAsyncReactiveField;
-const EntityMetadata_1 = require("../EntityMetadata");
-const fields_1 = require("../fields");
-const index_1 = require("../index");
-const newEntity_1 = require("../newEntity");
-const reactiveHints_1 = require("../reactiveHints");
-const utils_1 = require("../utils");
-const AbstractPropertyImpl_1 = require("./AbstractPropertyImpl");
-const hasProperty_1 = require("./hasProperty");
+import { lazyField } from "../newEntity.js";
+import { AbstractPropertyImpl } from "./AbstractPropertyImpl.js";
+import { PropertyT } from "./PropertySymbols.js";
+import { getMetadata } from "../EntityMetadata.js";
+import { getField, isFieldSet, setField } from "../fields.js";
+import { convertToLoadHint } from "../reactiveHints.js";
+import { deepNormalizeHint } from "../normalizeHints.js";
+import { isLoaded } from "../loadHints.js";
+import { mergeNormalizedHints } from "../utils.js";
+import "../index.js";
+import "../Entity.js";
+//#region src/relations/AsyncReactiveField.ts
 /**
- * An `AsyncReactiveField` is a value that is derived from a SQL query, similar to
- * a `ReactiveField`, but when the value needs to be calculated from SQL because
- * it would be too expensive to calculate in-memory.
- *
- * The `fn` lambda will be called when any data referred to by either the `paramHint` or
- * `dbHint` reactive hints have changed, but only the `paramHint`'s data will be pulled
- * into memory.
- */
-function hasAsyncReactiveField(paramHint, dbHint, fn) {
-    return (0, newEntity_1.lazyField)((entity, fieldName) => {
-        return new AsyncReactiveFieldImpl(entity, fieldName, paramHint, dbHint, fn);
-    });
+* An `AsyncReactiveField` is a value that is derived from a SQL query, similar to
+* a `ReactiveField`, but when the value needs to be calculated from SQL because
+* it would be too expensive to calculate in-memory.
+*
+* Its hint is split in two: the `loadHint` names data that is both reacted-to *and*
+* loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is
+* only reacted-to (its changes recompute the value) but is left in the database rather
+* than pulled into memory. The `fn` lambda re-runs when data referred to by either hint
+* changes, but only the `loadHint`'s data is populated.
+*/
+function hasAsyncReactiveField(loadHint, reactiveHint, fn) {
+	return lazyField((entity, fieldName) => {
+		return new AsyncReactiveFieldImpl(entity, fieldName, loadHint, reactiveHint, fn);
+	});
 }
-class AsyncReactiveFieldImpl extends AbstractPropertyImpl_1.AbstractPropertyImpl {
-    fieldName;
-    paramHint;
-    dbHint;
-    fn;
-    #paramHint;
-    #dbHint;
-    #loadPromise;
-    #loaded;
-    #useFactoryValue = false;
-    constructor(entity, fieldName, paramHint, dbHint, fn) {
-        super(entity);
-        this.fieldName = fieldName;
-        this.paramHint = paramHint;
-        this.dbHint = dbHint;
-        this.fn = fn;
-        this.#paramHint = paramHint;
-        this.#dbHint = dbHint;
-        this.#loaded = false;
-    }
-    /** Our combined param + db reactivity hint, so that we react to changes within both. */
-    get reactiveHint() {
-        // We do this in a getter (instead of the constructor) b/c it might be a little expensive,
-        // and I'm pretty sure this is only called on boot, when hooking up the reactivity.
-        const hint = (0, index_1.deepNormalizeHint)(this.#paramHint);
-        (0, utils_1.mergeNormalizedHints)(hint, (0, index_1.deepNormalizeHint)(this.#dbHint));
-        return hint;
-    }
-    load(opts) {
-        // if (!this.isSet || opts?.forceReload) {
-        return (this.#loadPromise ??= this.entity.em
-            .populate(this.entity, { hint: this.loadHint })
-            .then(() => {
-            // Even if the factory used a `with...`, we'll still go through the RFQ logic, but just ignore the new value
-            return this.#useFactoryValue ? this.fieldValue : this.fn(this.entity);
-        })
-            .then((newValue) => {
-            (0, fields_1.setField)(this.entity, this.fieldName, newValue);
-            this.#loadPromise = undefined;
-            this.#loaded = true;
-            return newValue;
-        })
-            .catch((e) => {
-            // If we blow up calling `this.fn` i.e. due to a NoIdError, we want to make
-            // sure that the next `.load` call tries again.
-            this.#loadPromise = undefined;
-            throw e;
-        }));
-        // }
-        // return tryResolve(() => this.get);
-    }
-    /** Returns the previously-calculated value. */
-    get get() {
-        // Regular ReactiveFields repeatedly call their `fn` lambda to calculate the value, to ensure
-        // they always return the latest/correct value, but because AsyncReactiveFields are fundamentally
-        // calculated from DB queries, we can only return the previously-calculated value, if set.
-        if (this.isSet) {
-            return this.fieldValue;
-        }
-        else {
-            throw new Error(`${this.fieldName} has not been derived yet`);
-        }
-    }
-    get fieldValue() {
-        return (0, fields_1.getField)(this.entity, this.fieldName);
-    }
-    get isSet() {
-        return (0, fields_1.isFieldSet)(this.entity, this.fieldName);
-    }
-    get isLoaded() {
-        const hintLoaded = (0, index_1.isLoaded)(this.entity, this.loadHint);
-        if (hintLoaded) {
-            this.#loaded = true;
-        }
-        return hintLoaded;
-    }
-    get loadHint() {
-        // Only convert the paramHint, so we don't pull the dbHint-referenced data into memory
-        const meta = (0, EntityMetadata_1.getMetadata)(this.entity);
-        return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= (0, reactiveHints_1.convertToLoadHint)(meta, this.#paramHint));
-    }
-    setFactoryValue(newValue) {
-        this.#useFactoryValue = true;
-        (0, fields_1.setField)(this.entity, this.fieldName, newValue);
-    }
-    [hasProperty_1.PropertyT] = undefined;
-}
-exports.AsyncReactiveFieldImpl = AsyncReactiveFieldImpl;
+var AsyncReactiveFieldImpl = class extends AbstractPropertyImpl {
+	fieldName;
+	fn;
+	#loadHint;
+	#reactiveHint;
+	#loadPromise;
+	#loaded;
+	#useFactoryValue = false;
+	constructor(entity, fieldName, loadHint, reactiveHint, fn) {
+		super(entity);
+		this.fieldName = fieldName;
+		this.fn = fn;
+		this.#loadHint = loadHint;
+		this.#reactiveHint = reactiveHint;
+		this.#loaded = false;
+	}
+	/**
+	* Our combined load + reactive-only hint, so that we react to changes within both.
+	*
+	* The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`
+	* half only triggers recalculation, so its data stays in the database.
+	*/
+	get reactiveHint() {
+		const hint = deepNormalizeHint(this.#loadHint);
+		mergeNormalizedHints(hint, deepNormalizeHint(this.#reactiveHint));
+		return hint;
+	}
+	load(opts) {
+		return this.#loadPromise ??= this.entity.em.populate(this.entity, { hint: this.loadHint }).then(() => {
+			return this.#useFactoryValue ? this.fieldValue : this.fn(this.entity);
+		}).then((newValue) => {
+			setField(this.entity, this.fieldName, newValue);
+			this.#loadPromise = void 0;
+			this.#loaded = true;
+			return newValue;
+		}).catch((e) => {
+			this.#loadPromise = void 0;
+			throw e;
+		});
+	}
+	/** Returns the previously-calculated value. */
+	get get() {
+		if (this.isSet) return this.fieldValue;
+		else throw new Error(`${this.fieldName} has not been derived yet`);
+	}
+	get fieldValue() {
+		return getField(this.entity, this.fieldName);
+	}
+	get isSet() {
+		return isFieldSet(this.entity, this.fieldName);
+	}
+	get isLoaded() {
+		const hintLoaded = isLoaded(this.entity, this.loadHint);
+		if (hintLoaded) this.#loaded = true;
+		return hintLoaded;
+	}
+	get loadHint() {
+		const meta = getMetadata(this.entity);
+		return meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.#loadHint);
+	}
+	setFactoryValue(newValue) {
+		this.#useFactoryValue = true;
+		setField(this.entity, this.fieldName, newValue);
+	}
+	[PropertyT] = void 0;
+};
 /** Type guard utility for determining if an entity field is an AsyncReactiveField. */
 function isAsyncReactiveField(maybe) {
-    return maybe instanceof AsyncReactiveFieldImpl;
+	return maybe instanceof AsyncReactiveFieldImpl;
 }
 /** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */
 function isLoadedAsyncReactiveField(maybe) {
-    return isAsyncReactiveField(maybe) && maybe.isLoaded;
+	return isAsyncReactiveField(maybe) && maybe.isLoaded;
 }
+//#endregion
+export { AsyncReactiveFieldImpl, hasAsyncReactiveField, isAsyncReactiveField, isLoadedAsyncReactiveField };
+
 //# sourceMappingURL=AsyncReactiveField.js.map