joist-core 2.3.0 → 2.4.0-next.2

package/build/relations/ReactiveGetter.cjs

@@ -0,0 +1,40 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_PropertySymbols = require("./PropertySymbols.cjs");
+const require_newEntity = require("../newEntity.cjs");
+require("../Entity.cjs");
+//#region src/relations/ReactiveGetter.ts
+/** Creates a `ReactiveGetter`, for simple "getters" that still trackable for reactivity. */
+function hasReactiveGetter(fieldName, hint, fn) {
+	return require_newEntity.lazyField((entity, fieldName) => {
+		return new ReactiveGetterImpl(entity, fieldName, hint, fn);
+	});
+}
+var ReactiveGetterImpl = class {
+	#entity;
+	#fieldName;
+	#hint;
+	#fn;
+	constructor(entity, fieldName, hint, fn) {
+		this.#entity = entity;
+		this.#fieldName = fieldName;
+		this.#hint = hint;
+		this.#fn = fn;
+	}
+	get get() {
+		return this.#fn(this.#entity);
+	}
+	get reactiveHint() {
+		return this.#hint;
+	}
+	[require_relations_PropertySymbols.PropertyT] = void 0;
+};
+/** Type guard utility for determining if an entity field is a ReactiveGetter. */
+function isReactiveGetter(maybeReactiveGetter) {
+	return maybeReactiveGetter instanceof ReactiveGetterImpl;
+}
+//#endregion
+exports.ReactiveGetterImpl = ReactiveGetterImpl;
+exports.hasReactiveGetter = hasReactiveGetter;
+exports.isReactiveGetter = isReactiveGetter;
+
+//# sourceMappingURL=ReactiveGetter.cjs.map

package/build/relations/ReactiveGetter.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactiveGetter.cjs","names":["lazyField","#entity","#fieldName","#hint","#fn","PropertyT"],"sources":["../../src/relations/ReactiveGetter.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport type { Reacted, ShallowReactiveHint } from \"src/reactivity/reactiveHints.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\n\n/**\n * A `ReactiveGetter` is a getter that declares what primitive fields it depends on.\n *\n * This is very similar to a `ReactiveProperty`, except because it's limited to\n * only immediate fields on the entity, it can always have `.get` called, and doesn't\n * need to be loaded.\n *\n * The benefit over a pure getter is that `ReactiveGetter` can be used in reactive\n * rules and reactive fields, which would otherwise need to use `fullNonReactiveAccess`\n * to access getter, and risk missing reactivity.\n */\nexport interface ReactiveGetter<T extends Entity, V> {\n  [PropertyT]: T;\n  get: V;\n}\n\n/** Creates a `ReactiveGetter`, for simple \"getters\" that still trackable for reactivity. */\nexport function hasReactiveGetter<T extends Entity, const H extends ShallowReactiveHint<T>, V>(\n  fieldName: keyof T & string,\n  hint: H,\n  fn: (entity: Reacted<T, H>) => V,\n): ReactiveGetter<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new ReactiveGetterImpl(entity, fieldName as keyof T & string, hint, fn);\n  });\n}\n\nexport class ReactiveGetterImpl<T extends Entity, const H extends ShallowReactiveHint<T>, V> implements ReactiveGetter<\n  T,\n  V\n> {\n  readonly #entity: T;\n  readonly #fieldName: keyof T & string;\n  readonly #hint: H;\n  readonly #fn: (entity: Reacted<T, H>) => V;\n\n  constructor(entity: T, fieldName: keyof T & string, hint: H, fn: (entity: Reacted<T, H>) => V) {\n    this.#entity = entity;\n    this.#fieldName = fieldName;\n    this.#hint = hint;\n    this.#fn = fn;\n  }\n\n  get get(): V {\n    return this.#fn(this.#entity as any);\n  }\n\n  get reactiveHint(): H {\n    return this.#hint;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveGetter. */\nexport function isReactiveGetter(maybeReactiveGetter: any): maybeReactiveGetter is ReactiveGetter<any, any> {\n  return maybeReactiveGetter instanceof ReactiveGetterImpl;\n}\n"],"mappings":";;;;;;AAsBA,SAAgB,kBACd,WACA,MACA,IACsB;CACtB,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,mBAAmB,QAAQ,WAA+B,MAAM,EAAE;CAC/E,CAAC;AACH;AAEA,IAAa,qBAAb,MAGE;CACA;CACA;CACA;CACA;CAEA,YAAY,QAAW,WAA6B,MAAS,IAAkC;EAC7F,KAAKC,UAAU;EACf,KAAKC,aAAa;EAClB,KAAKC,QAAQ;EACb,KAAKC,MAAM;CACb;CAEA,IAAI,MAAS;EACX,OAAO,KAAKA,IAAI,KAAKH,OAAc;CACrC;CAEA,IAAI,eAAkB;EACpB,OAAO,KAAKE;CACd;CAEA,CAACE,kCAAAA,aAAa,KAAA;AAChB;;AAGA,SAAgB,iBAAiB,qBAA2E;CAC1G,OAAO,+BAA+B;AACxC"}

package/build/relations/ReactiveGetter.d.cts

@@ -0,0 +1,33 @@
+import { PropertyT } from "./PropertySymbols.cjs";
+import { Reacted, ShallowReactiveHint } from "../reactivity/reactiveHints.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/relations/ReactiveGetter.d.ts
+/**
+ * A `ReactiveGetter` is a getter that declares what primitive fields it depends on.
+ *
+ * This is very similar to a `ReactiveProperty`, except because it's limited to
+ * only immediate fields on the entity, it can always have `.get` called, and doesn't
+ * need to be loaded.
+ *
+ * The benefit over a pure getter is that `ReactiveGetter` can be used in reactive
+ * rules and reactive fields, which would otherwise need to use `fullNonReactiveAccess`
+ * to access getter, and risk missing reactivity.
+ */
+interface ReactiveGetter<T extends Entity, V> {
+  [PropertyT]: T;
+  get: V;
+}
+/** Creates a `ReactiveGetter`, for simple "getters" that still trackable for reactivity. */
+declare function hasReactiveGetter<T extends Entity, const H extends ShallowReactiveHint<T>, V>(fieldName: keyof T & string, hint: H, fn: (entity: Reacted<T, H>) => V): ReactiveGetter<T, V>;
+declare class ReactiveGetterImpl<T extends Entity, const H extends ShallowReactiveHint<T>, V> implements ReactiveGetter<T, V> {
+  #private;
+  constructor(entity: T, fieldName: keyof T & string, hint: H, fn: (entity: Reacted<T, H>) => V);
+  get get(): V;
+  get reactiveHint(): H;
+  [PropertyT]: T;
+}
+/** Type guard utility for determining if an entity field is a ReactiveGetter. */
+declare function isReactiveGetter(maybeReactiveGetter: any): maybeReactiveGetter is ReactiveGetter<any, any>;
+//#endregion
+export { ReactiveGetter, ReactiveGetterImpl, hasReactiveGetter, isReactiveGetter };
+//# sourceMappingURL=ReactiveGetter.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ReactiveGetter.d.cts","names":[],"sources":["../../src/relations/ReactiveGetter.ts"],"mappings":";;;;;;;;;;;;;;;UAgBiB,eAAe,UAAU,QAAQ;GAC/C,YAAY;EACb,KAAK;;;iBAIS,kBAAkB,UAAU,cAAc,UAAU,oBAAoB,IAAI,GAC1F,iBAAiB,YACjB,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,OAAO,IAC9B,eAAe,GAAG;cAMR,mBAAmB,UAAU,cAAc,UAAU,oBAAoB,IAAI,cAAc,eACtG,GACA;;EAOA,YAAY,QAAQ,GAAG,iBAAiB,YAAY,MAAM,GAAG,KAAK,QAAQ,QAAQ,GAAG,OAAO;MAOxF,OAAO;MAIP,gBAAgB;GAInB,YAAiC;;;iBAIpB,iBAAiB,2BAA2B,uBAAuB"}

package/build/relations/ReactiveGetter.d.mts

@@ -0,0 +1,33 @@
+import { PropertyT } from "./PropertySymbols.mjs";
+import { Reacted, ShallowReactiveHint } from "../reactivity/reactiveHints.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/relations/ReactiveGetter.d.ts
+/**
+ * A `ReactiveGetter` is a getter that declares what primitive fields it depends on.
+ *
+ * This is very similar to a `ReactiveProperty`, except because it's limited to
+ * only immediate fields on the entity, it can always have `.get` called, and doesn't
+ * need to be loaded.
+ *
+ * The benefit over a pure getter is that `ReactiveGetter` can be used in reactive
+ * rules and reactive fields, which would otherwise need to use `fullNonReactiveAccess`
+ * to access getter, and risk missing reactivity.
+ */
+interface ReactiveGetter<T extends Entity, V> {
+  [PropertyT]: T;
+  get: V;
+}
+/** Creates a `ReactiveGetter`, for simple "getters" that still trackable for reactivity. */
+declare function hasReactiveGetter<T extends Entity, const H extends ShallowReactiveHint<T>, V>(fieldName: keyof T & string, hint: H, fn: (entity: Reacted<T, H>) => V): ReactiveGetter<T, V>;
+declare class ReactiveGetterImpl<T extends Entity, const H extends ShallowReactiveHint<T>, V> implements ReactiveGetter<T, V> {
+  #private;
+  constructor(entity: T, fieldName: keyof T & string, hint: H, fn: (entity: Reacted<T, H>) => V);
+  get get(): V;
+  get reactiveHint(): H;
+  [PropertyT]: T;
+}
+/** Type guard utility for determining if an entity field is a ReactiveGetter. */
+declare function isReactiveGetter(maybeReactiveGetter: any): maybeReactiveGetter is ReactiveGetter<any, any>;
+//#endregion
+export { ReactiveGetter, ReactiveGetterImpl, hasReactiveGetter, isReactiveGetter };
+//# sourceMappingURL=ReactiveGetter.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ReactiveGetter.d.mts","names":[],"sources":["../../src/relations/ReactiveGetter.ts"],"mappings":";;;;;;;;;;;;;;;UAgBiB,eAAe,UAAU,QAAQ;GAC/C,YAAY;EACb,KAAK;;;iBAIS,kBAAkB,UAAU,cAAc,UAAU,oBAAoB,IAAI,GAC1F,iBAAiB,YACjB,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,OAAO,IAC9B,eAAe,GAAG;cAMR,mBAAmB,UAAU,cAAc,UAAU,oBAAoB,IAAI,cAAc,eACtG,GACA;;EAOA,YAAY,QAAQ,GAAG,iBAAiB,YAAY,MAAM,GAAG,KAAK,QAAQ,QAAQ,GAAG,OAAO;MAOxF,OAAO;MAIP,gBAAgB;GAInB,YAAiC;;;iBAIpB,iBAAiB,2BAA2B,uBAAuB"}

package/build/relations/ReactiveGetter.js

@@ -1,38 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReactiveGetterImpl = void 0;
-exports.hasReactiveGetter = hasReactiveGetter;
-exports.isReactiveGetter = isReactiveGetter;
-const newEntity_1 = require("../newEntity");
-const hasProperty_1 = require("./hasProperty");
+import { PropertyT } from "./PropertySymbols.js";
+import { lazyField } from "../newEntity.js";
+import "../Entity.js";
+//#region src/relations/ReactiveGetter.ts
 /** Creates a `ReactiveGetter`, for simple "getters" that still trackable for reactivity. */
 function hasReactiveGetter(fieldName, hint, fn) {
-    return (0, newEntity_1.lazyField)((entity, fieldName) => {
-        return new ReactiveGetterImpl(entity, fieldName, hint, fn);
-    });
+	return lazyField((entity, fieldName) => {
+		return new ReactiveGetterImpl(entity, fieldName, hint, fn);
+	});
 }
-class ReactiveGetterImpl {
-    #entity;
-    #fieldName;
-    #hint;
-    #fn;
-    constructor(entity, fieldName, hint, fn) {
-        this.#entity = entity;
-        this.#fieldName = fieldName;
-        this.#hint = hint;
-        this.#fn = fn;
-    }
-    get get() {
-        return this.#fn(this.#entity);
-    }
-    get reactiveHint() {
-        return this.#hint;
-    }
-    [hasProperty_1.PropertyT] = undefined;
-}
-exports.ReactiveGetterImpl = ReactiveGetterImpl;
+var ReactiveGetterImpl = class {
+	#entity;
+	#fieldName;
+	#hint;
+	#fn;
+	constructor(entity, fieldName, hint, fn) {
+		this.#entity = entity;
+		this.#fieldName = fieldName;
+		this.#hint = hint;
+		this.#fn = fn;
+	}
+	get get() {
+		return this.#fn(this.#entity);
+	}
+	get reactiveHint() {
+		return this.#hint;
+	}
+	[PropertyT] = void 0;
+};
 /** Type guard utility for determining if an entity field is a ReactiveGetter. */
 function isReactiveGetter(maybeReactiveGetter) {
-    return maybeReactiveGetter instanceof ReactiveGetterImpl;
+	return maybeReactiveGetter instanceof ReactiveGetterImpl;
 }
+//#endregion
+export { ReactiveGetterImpl, hasReactiveGetter, isReactiveGetter };
+
 //# sourceMappingURL=ReactiveGetter.js.map

package/build/relations/ReactiveGetter.js.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveGetter.js","sourceRoot":"","sources":["../../src/relations/ReactiveGetter.ts"],"names":[],"mappings":";;;AAsBA,8CAQC;AA8BD,4CAEC;AA7DD,4CAAyC;AAEzC,+CAA0C;AAkB1C,4FAA4F;AAC5F,SAAgB,iBAAiB,CAC/B,SAA2B,EAC3B,IAAO,EACP,EAAgC;IAEhC,OAAO,IAAA,qBAAS,EAAC,CAAC,MAAS,EAAE,SAAS,EAAE,EAAE;QACxC,OAAO,IAAI,kBAAkB,CAAC,MAAM,EAAE,SAA6B,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;IACjF,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAa,kBAAkB;IAIpB,OAAO,CAAI;IACX,UAAU,CAAmB;IAC7B,KAAK,CAAI;IACT,GAAG,CAA+B;IAE3C,YAAY,MAAS,EAAE,SAA2B,EAAE,IAAO,EAAE,EAAgC;QAC3F,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC;IAChB,CAAC;IAED,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAc,CAAC,CAAC;IACvC,CAAC;IAED,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,CAAC,uBAAS,CAAC,GAAG,SAAqB,CAAC;CACrC;AAzBD,gDAyBC;AAED,iFAAiF;AACjF,SAAgB,gBAAgB,CAAC,mBAAwB;IACvD,OAAO,mBAAmB,YAAY,kBAAkB,CAAC;AAC3D,CAAC"}
+{"version":3,"file":"ReactiveGetter.js","names":["#entity","#fieldName","#hint","#fn"],"sources":["../../src/relations/ReactiveGetter.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport type { Reacted, ShallowReactiveHint } from \"src/reactivity/reactiveHints.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\n\n/**\n * A `ReactiveGetter` is a getter that declares what primitive fields it depends on.\n *\n * This is very similar to a `ReactiveProperty`, except because it's limited to\n * only immediate fields on the entity, it can always have `.get` called, and doesn't\n * need to be loaded.\n *\n * The benefit over a pure getter is that `ReactiveGetter` can be used in reactive\n * rules and reactive fields, which would otherwise need to use `fullNonReactiveAccess`\n * to access getter, and risk missing reactivity.\n */\nexport interface ReactiveGetter<T extends Entity, V> {\n  [PropertyT]: T;\n  get: V;\n}\n\n/** Creates a `ReactiveGetter`, for simple \"getters\" that still trackable for reactivity. */\nexport function hasReactiveGetter<T extends Entity, const H extends ShallowReactiveHint<T>, V>(\n  fieldName: keyof T & string,\n  hint: H,\n  fn: (entity: Reacted<T, H>) => V,\n): ReactiveGetter<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new ReactiveGetterImpl(entity, fieldName as keyof T & string, hint, fn);\n  });\n}\n\nexport class ReactiveGetterImpl<T extends Entity, const H extends ShallowReactiveHint<T>, V> implements ReactiveGetter<\n  T,\n  V\n> {\n  readonly #entity: T;\n  readonly #fieldName: keyof T & string;\n  readonly #hint: H;\n  readonly #fn: (entity: Reacted<T, H>) => V;\n\n  constructor(entity: T, fieldName: keyof T & string, hint: H, fn: (entity: Reacted<T, H>) => V) {\n    this.#entity = entity;\n    this.#fieldName = fieldName;\n    this.#hint = hint;\n    this.#fn = fn;\n  }\n\n  get get(): V {\n    return this.#fn(this.#entity as any);\n  }\n\n  get reactiveHint(): H {\n    return this.#hint;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveGetter. */\nexport function isReactiveGetter(maybeReactiveGetter: any): maybeReactiveGetter is ReactiveGetter<any, any> {\n  return maybeReactiveGetter instanceof ReactiveGetterImpl;\n}\n"],"mappings":";;;;;AAsBA,SAAgB,kBACd,WACA,MACA,IACsB;CACtB,OAAO,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,mBAAmB,QAAQ,WAA+B,MAAM,EAAE;CAC/E,CAAC;AACH;AAEA,IAAa,qBAAb,MAGE;CACA;CACA;CACA;CACA;CAEA,YAAY,QAAW,WAA6B,MAAS,IAAkC;EAC7F,KAAKA,UAAU;EACf,KAAKC,aAAa;EAClB,KAAKC,QAAQ;EACb,KAAKC,MAAM;CACb;CAEA,IAAI,MAAS;EACX,OAAO,KAAKA,IAAI,KAAKH,OAAc;CACrC;CAEA,IAAI,eAAkB;EACpB,OAAO,KAAKE;CACd;CAEA,CAAC,aAAa,KAAA;AAChB;;AAGA,SAAgB,iBAAiB,qBAA2E;CAC1G,OAAO,+BAA+B;AACxC"}

package/build/relations/ReactiveManyToMany.cjs

@@ -0,0 +1,198 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_AbstractRelationImpl = require("./AbstractRelationImpl.cjs");
+const require_relations_RelationSymbols = require("./RelationSymbols.cjs");
+const require_reactivity_reactiveHints = require("../reactivity/reactiveHints.cjs");
+const require_loading_loadHints = require("../loading/loadHints.cjs");
+const require_batchloaders_manyToManyBatchLoader = require("../batchloaders/manyToManyBatchLoader.cjs");
+const require_relations_isCascadeDelete = require("./isCascadeDelete.cjs");
+const require_utils = require("../utils.cjs");
+const require_newEntity = require("../newEntity.cjs");
+const require_EntityMetadata = require("../EntityMetadata.cjs");
+const require_index = require("../index.cjs");
+const require_EntityManager = require("../EntityManager.cjs");
+const require_BaseEntity = require("../BaseEntity.cjs");
+//#region src/relations/ReactiveManyToMany.ts
+/** Creates a `ReactiveManyToMany`. */
+function hasReactiveManyToMany(hint, fn) {
+	return require_newEntity.lazyField((entity, fieldName) => {
+		const m2m = require_EntityMetadata.getMetadata(entity).allFields[fieldName];
+		return new ReactiveManyToManyImpl(entity, m2m, hint, fn);
+	});
+}
+/** Implements ReactiveManyToMany, initially a copy/paste of ReactiveReference but for m2m. */
+var ReactiveManyToManyImpl = class extends require_relations_AbstractRelationImpl.AbstractRelationImpl {
+	reactiveHint;
+	fn;
+	#field;
+	#loaded;
+	#loadedMode = void 0;
+	#isLoaded = void 0;
+	#isCached = false;
+	#loadPromise;
+	constructor(entity, field, reactiveHint, fn) {
+		super(entity);
+		this.reactiveHint = reactiveHint;
+		this.fn = fn;
+		this.#field = field;
+		(require_BaseEntity.getInstanceData(entity).relations ??= {})[this.fieldName] = this;
+	}
+	async load(opts) {
+		require_index.ensureNotDeleted(this.entity, "pending");
+		const { loadHint } = this;
+		if (!this.isLoaded || opts?.forceReload) {
+			const { em } = this.entity;
+			if (opts?.forceReload || require_EntityManager.getEmInternalApi(em).rm.isMaybePendingRecalc(this.entity, this.fieldName)) {
+				this.#isCached = false;
+				return this.#loadPromise ??= em.populate(this.entity, {
+					hint: loadHint,
+					...opts
+				}).then(() => {
+					this.#loadPromise = void 0;
+					this.#loadedMode = "full";
+					this.#isLoaded = true;
+					require_EntityManager.getEmInternalApi(this.entity.em).isLoadedCache.add(this);
+					return this.#doGet(opts);
+				});
+			} else return this.#loadPromise ??= this.#loadFromJoinTable().then((loaded) => {
+				this.#loadPromise = void 0;
+				this.#loadedMode = "ref";
+				this.#isLoaded = true;
+				this.#loaded = loaded;
+				require_EntityManager.getEmInternalApi(this.entity.em).isLoadedCache.add(this);
+				return this.#filterDeleted(loaded, opts);
+			});
+		}
+		return this.#doGet(opts);
+	}
+	get isLoaded() {
+		if (this.#isLoaded !== void 0) return this.#isLoaded;
+		require_EntityManager.getEmInternalApi(this.entity.em).isLoadedCache.add(this);
+		if (require_EntityManager.getEmInternalApi(this.entity.em).rm.isMaybePendingRecalc(this.entity, this.fieldName)) {
+			this.#loadedMode = "full";
+			this.#isLoaded = require_loading_loadHints.isLoaded(this.entity, this.loadHint);
+			this.#isCached = false;
+		} else this.#isLoaded = !!this.#loadedMode;
+		return this.#isLoaded;
+	}
+	resetIsLoaded() {
+		this.#isLoaded = void 0;
+		this.#isCached = false;
+	}
+	#doGet(opts) {
+		const { fn } = this;
+		require_index.ensureNotDeleted(this.entity, "pending");
+		if (this.#isCached) return this.#filterDeleted(this.#loaded ?? [], opts);
+		if (this.isLoaded && this.#loadedMode === "full") {
+			const newValue = fn(this.entity);
+			const previousDeleted = (this.#loaded ?? []).filter((e) => e.isDeletedEntity);
+			for (const entity of previousDeleted) if (!newValue.includes(entity)) newValue.push(entity);
+			if (!require_EntityManager.getEmInternalApi(this.entity.em).isValidating) this.#syncJoinTableRows(newValue);
+			this.#loaded = newValue;
+			this.#isCached = true;
+			require_EntityManager.getEmInternalApi(this.entity.em).isLoadedCache.add(this);
+		} else if (!!this.#loadedMode) {
+			this.#isCached = true;
+			require_EntityManager.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.#loaded ?? [], opts);
+	}
+	get getWithDeleted() {
+		return this.#doGet({ withDeleted: true });
+	}
+	get get() {
+		return this.#doGet({ withDeleted: false });
+	}
+	set() {
+		require_utils.fail(`Cannot set ${this.entity}.${this.fieldName} ReactiveManyToMany directly.`);
+	}
+	get loadHint() {
+		const meta = require_EntityMetadata.getMetadata(this.entity);
+		return meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= require_reactivity_reactiveHints.convertToLoadHint(meta, this.reactiveHint);
+	}
+	setFromOpts(_others) {
+		throw new Error(`ReactiveManyToMany ${this.entity}.${this.fieldName} cannot be set via opts`);
+	}
+	maybeCascadeDelete() {
+		if (this.#isCascadeDelete) require_EntityManager.getEmInternalApi(this.entity.em).joinRows(this).getOthers(this.columnName, this.entity).forEach((e) => this.entity.em.delete(e));
+	}
+	async cleanupOnEntityDeleted() {
+		const existing = await this.load({ withDeleted: true });
+		const jr = require_EntityManager.getEmInternalApi(this.entity.em).joinRows(this);
+		for (const entity of existing) jr.addRemove(this, this.entity, entity);
+		this.#loaded = [];
+		this.#isLoaded = false;
+	}
+	get meta() {
+		return require_EntityMetadata.getMetadataForField(require_EntityMetadata.getMetadata(this.entity), this.fieldName);
+	}
+	get fieldName() {
+		return this.#field.fieldName;
+	}
+	get otherMeta() {
+		return this.#field.otherMetadata();
+	}
+	get joinTableName() {
+		return this.#field.joinTableName;
+	}
+	get columnName() {
+		return this.#field.columnNames[0];
+	}
+	get otherColumnName() {
+		return this.#field.columnNames[1];
+	}
+	get hasJoinTableId() {
+		return this.#field.hasJoinTableId;
+	}
+	get otherFieldName() {
+		return this.#field.otherFieldName;
+	}
+	get hasBeenSet() {
+		return true;
+	}
+	get isPreloaded() {
+		return false;
+	}
+	preload() {}
+	import(other, _, mapEntities) {
+		this.#loaded = mapEntities(other.#loaded);
+		this.#loadedMode = other.#loadedMode;
+		this.#isLoaded = other.#isLoaded ?? false;
+	}
+	toString() {
+		return `ReactiveManyToMany(entity: ${this.entity}, fieldName: ${this.fieldName}, otherMeta: ${this.otherMeta.type})`;
+	}
+	get #isCascadeDelete() {
+		return require_relations_isCascadeDelete.isCascadeDelete(this, this.#field.fieldName);
+	}
+	async #loadFromJoinTable() {
+		const { em } = this.entity;
+		const key = `${this.columnName}=${this.entity.id}`;
+		await require_batchloaders_manyToManyBatchLoader.manyToManyBatchLoader(em, this).load(key);
+		return require_EntityManager.getEmInternalApi(em).joinRows(this).getOthers(this.columnName, this.entity);
+	}
+	#syncJoinTableRows(newValue) {
+		const jr = require_EntityManager.getEmInternalApi(this.entity.em).joinRows(this);
+		const newSet = new Set(newValue);
+		const oldSet = new Set(jr.getOthers(this.columnName, this.entity));
+		for (const entity of newValue) if (!oldSet.has(entity)) jr.addNew(this, this.entity, entity);
+		for (const entity of oldSet) if (!newSet.has(entity)) jr.addRemove(this, this.entity, entity);
+	}
+	#filterDeleted(entities, opts) {
+		return opts?.withDeleted === true ? [...entities] : entities.filter((e) => !e.isDeletedEntity && !e.isSoftDeletedEntity);
+	}
+	[require_relations_RelationSymbols.RelationT] = null;
+	[require_relations_RelationSymbols.RelationU] = null;
+};
+/** Type guard utility for determining if an entity field is a ReactiveManyToMany. */
+function isReactiveManyToMany(maybeReactiveManyToMany) {
+	return maybeReactiveManyToMany instanceof ReactiveManyToManyImpl;
+}
+//#endregion
+exports.ReactiveManyToManyImpl = ReactiveManyToManyImpl;
+exports.hasReactiveManyToMany = hasReactiveManyToMany;
+exports.isReactiveManyToMany = isReactiveManyToMany;
+
+//# sourceMappingURL=ReactiveManyToMany.cjs.map

package/build/relations/ReactiveManyToMany.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactiveManyToMany.cjs","names":["lazyField","getMetadata","AbstractRelationImpl","#field","getEmInternalApi","#isCached","#loadPromise","#loadedMode","#isLoaded","#doGet","#loadFromJoinTable","#loaded","#filterDeleted","isLoaded","#syncJoinTableRows","convertToLoadHint","#isCascadeDelete","getMetadataForField","isCascadeDelete","manyToManyBatchLoader","RelationT","RelationU"],"sources":["../../src/relations/ReactiveManyToMany.ts"],"sourcesContent":["import { manyToManyBatchLoader } from \"src/batchloaders/manyToManyBatchLoader.ts\";\nimport {\n  type Entity,\n  type EntityMetadata,\n  type ManyToManyField,\n  type ReadOnlyCollection,\n  ensureNotDeleted,\n  fail,\n  getEmInternalApi,\n  getInstanceData,\n  getMetadata,\n  getMetadataForField,\n  isLoaded,\n} from \"src/index.ts\";\nimport type { IsLoadedCachable } from \"src/loading/IsLoadedCache.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport {\n  type MaybeReactedEntity,\n  type Reacted,\n  type ReactiveHint,\n  convertToLoadHint,\n} from \"src/reactivity/reactiveHints.ts\";\nimport { AbstractRelationImpl } from \"src/relations/AbstractRelationImpl.ts\";\nimport { isCascadeDelete } from \"src/relations/isCascadeDelete.ts\";\nimport { RelationT, RelationU } from \"src/relations/RelationSymbols.ts\";\n\n/**\n * A reactive, derived many-to-many collection.\n *\n * Similar to `ReactiveReference` but for collections--membership is calculated from a reactive\n * function and persisted to the underlying join table.\n */\nexport interface ReactiveManyToMany<T extends Entity, U extends Entity> extends ReadOnlyCollection<T, U> {\n  load(opts?: { withDeleted?: boolean; forceReload?: boolean }): Promise<readonly U[]>;\n}\n\n/** Creates a `ReactiveManyToMany`. */\nexport function hasReactiveManyToMany<T extends Entity, U extends Entity, const H extends ReactiveHint<T>>(\n  hint: H,\n  fn: (entity: Reacted<T, H>) => readonly MaybeReactedEntity<U>[],\n): ReactiveManyToMany<T, U> {\n  return lazyField((entity: T, fieldName) => {\n    const m2m = getMetadata(entity).allFields[fieldName] as ManyToManyField;\n    return new ReactiveManyToManyImpl<T, U, H>(entity, m2m, hint, fn);\n  });\n}\n\n/** Implements ReactiveManyToMany, initially a copy/paste of ReactiveReference but for m2m. */\nexport class ReactiveManyToManyImpl<T extends Entity, U extends Entity, H extends ReactiveHint<T>>\n  extends AbstractRelationImpl<T, U[]>\n  implements ReactiveManyToMany<T, U>, IsLoadedCachable\n{\n  readonly #field: ManyToManyField;\n\n  // Could be either the ref-loaded stored array, or full-loaded calculated array\n  #loaded: U[] | undefined;\n  // In ref-mode, we use our materialized FK value (which might be undefined)\n  // If full-mode, we calculate the FK value from the subgraph\n  #loadedMode: \"ref\" | \"full\" | undefined = undefined;\n  // #isLoaded doesn't necessary care if we're ref-mode or full-mode, it's just\n  // whether a caller can call `.get` and not have it blow up.\n  #isLoaded: boolean | undefined = undefined;\n  #isCached: boolean = false;\n  #loadPromise: Promise<ReadonlyArray<U>> | undefined;\n\n  constructor(\n    entity: T,\n    field: ManyToManyField,\n    public reactiveHint: H,\n    private fn: (entity: Reacted<T, H>) => readonly MaybeReactedEntity<U>[],\n  ) {\n    super(entity);\n    this.#field = field;\n    (getInstanceData(entity).relations ??= {})[this.fieldName] = this;\n  }\n\n  async load(opts?: { withDeleted?: boolean; forceReload?: boolean }): Promise<ReadonlyArray<U>> {\n    ensureNotDeleted(this.entity, \"pending\");\n    const { loadHint } = this;\n\n    if (!this.isLoaded || opts?.forceReload) {\n      const { em } = this.entity;\n      const maybeDirty = opts?.forceReload || getEmInternalApi(em).rm.isMaybePendingRecalc(this.entity, this.fieldName);\n\n      if (maybeDirty) {\n        this.#isCached = false;\n        return (this.#loadPromise ??= em.populate(this.entity, { hint: loadHint, ...opts }).then(() => {\n          this.#loadPromise = undefined;\n          this.#loadedMode = \"full\";\n          this.#isLoaded = true;\n          getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n          return this.#doGet(opts);\n        }));\n      } else {\n        // Load from join table (existing materialized state)\n        return (this.#loadPromise ??= this.#loadFromJoinTable().then((loaded) => {\n          this.#loadPromise = undefined;\n          this.#loadedMode = \"ref\";\n          this.#isLoaded = true;\n          this.#loaded = loaded;\n          getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n          return this.#filterDeleted(loaded, opts);\n        }));\n      }\n    }\n    return this.#doGet(opts);\n  }\n\n  get isLoaded(): boolean {\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    // If a WIP mutation has marked our field as potentially dirty, we need to be \"full\" loaded\n    const maybeDirty = getEmInternalApi(this.entity.em).rm.isMaybePendingRecalc(this.entity, this.fieldName);\n    if (maybeDirty) {\n      // If we're dirty, only being \"full\" loaded is good enough to recalc\n      this.#loadedMode = \"full\";\n      this.#isLoaded = isLoaded(this.entity, this.loadHint);\n      this.#isCached = false;\n    } else {\n      // If we've had `.load` called before, assume we're still loaded\n      this.#isLoaded = !!this.#loadedMode;\n    }\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n    this.#isCached = false;\n  }\n\n  #doGet(opts?: { withDeleted?: boolean }): U[] {\n    const { fn } = this;\n    ensureNotDeleted(this.entity, \"pending\");\n    // Fast pass if we've already calculated this (cache invalidation will happen on\n    // any mutation via #resetIsLoaded)..\n    if (this.#isCached) {\n      return this.#filterDeleted(this.#loaded ?? [], opts) as U[];\n    }\n    // Call isLoaded to probe the load hint, and get `#isLoaded` set, but still have\n    // our `if` check the raw `#isLoaded` to know if we should eval-latest or return `loaded`.\n    if (this.isLoaded && this.#loadedMode === \"full\") {\n      const newValue = fn(this.entity as any) as unknown as U[];\n      // Preserve deleted entities that were in the previous loaded value\n      const previousDeleted = (this.#loaded ?? []).filter((e) => e.isDeletedEntity);\n      for (const entity of previousDeleted) {\n        if (!newValue.includes(entity)) newValue.push(entity);\n      }\n      if (!getEmInternalApi(this.entity.em).isValidating) {\n        this.#syncJoinTableRows(newValue);\n      }\n      this.#loaded = newValue;\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    } else if (!!this.#loadedMode) {\n      // We're either loadedMode=ref, or loadedMode=full (but not actually fully loaded),\n      // but in theory loadedMode only gets set in `.load()`, so we should have #loaded\n      // set to some value, even if it's not fully up-to-date.\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    } else {\n      const noun = this.entity.isNewEntity ? \"derived\" : \"loaded\";\n      throw new Error(`${this.entity}.${this.fieldName} has not been ${noun} yet`);\n    }\n    return this.#filterDeleted(this.#loaded ?? [], opts) as U[];\n  }\n\n  get getWithDeleted(): U[] {\n    return this.#doGet({ withDeleted: true });\n  }\n\n  get get(): U[] {\n    return this.#doGet({ withDeleted: false });\n  }\n\n  set(): void {\n    fail(`Cannot set ${this.entity}.${this.fieldName} ReactiveManyToMany directly.`);\n  }\n\n  get loadHint(): any {\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.reactiveHint));\n  }\n\n  setFromOpts(_others: U[]): void {\n    throw new Error(`ReactiveManyToMany ${this.entity}.${this.fieldName} cannot be set via opts`);\n  }\n\n  maybeCascadeDelete(): void {\n    if (this.#isCascadeDelete) {\n      const jr = getEmInternalApi(this.entity.em).joinRows(this);\n      (jr.getOthers(this.columnName, this.entity) as U[]).forEach((e) => this.entity.em.delete(e));\n    }\n  }\n\n  async cleanupOnEntityDeleted(): Promise<void> {\n    const existing = await this.load({ withDeleted: true });\n    const jr = getEmInternalApi(this.entity.em).joinRows(this);\n    for (const entity of existing) jr.addRemove(this, this.entity, entity);\n    this.#loaded = [];\n    this.#isLoaded = false;\n  }\n\n  // Properties needed for JoinRows/ManyToManyCollection compatibility\n  get meta(): EntityMetadata {\n    return getMetadataForField(getMetadata(this.entity), this.fieldName);\n  }\n\n  get fieldName(): string {\n    return this.#field.fieldName;\n  }\n\n  get otherMeta(): EntityMetadata {\n    return this.#field.otherMetadata();\n  }\n\n  get joinTableName(): string {\n    return this.#field.joinTableName;\n  }\n\n  get columnName(): string {\n    return this.#field.columnNames[0];\n  }\n\n  get otherColumnName(): string {\n    return this.#field.columnNames[1];\n  }\n\n  get hasJoinTableId(): boolean {\n    return this.#field.hasJoinTableId;\n  }\n\n  get otherFieldName(): string {\n    return this.#field.otherFieldName;\n  }\n\n  get hasBeenSet(): boolean {\n    return true;\n  }\n\n  get isPreloaded(): boolean {\n    return false;\n  }\n\n  preload(): void {\n    // No-op for now - could implement if needed\n  }\n\n  import(\n    other: ReactiveManyToManyImpl<T, U, H>,\n    _: unknown,\n    mapEntities: (e: U[] | undefined) => U[] | undefined,\n  ): void {\n    this.#loaded = mapEntities(other.#loaded);\n    this.#loadedMode = other.#loadedMode;\n    this.#isLoaded = other.#isLoaded ?? false;\n    // Don't set `#isCached b/c we're not registering ourselves with `isLoadedCache` yet; let\n    // the first caller to `#doGet` do that if needed.\n  }\n\n  public toString(): string {\n    return `ReactiveManyToMany(entity: ${this.entity}, fieldName: ${this.fieldName}, otherMeta: ${this.otherMeta.type})`;\n  }\n\n  get #isCascadeDelete(): boolean {\n    return isCascadeDelete(this, this.#field.fieldName);\n  }\n\n  async #loadFromJoinTable(): Promise<U[]> {\n    const { em } = this.entity;\n    const key = `${this.columnName}=${this.entity.id}`;\n    // Use the existing m2m loader by creating a compatible collection-like object\n    await manyToManyBatchLoader(em, this).load(key);\n    return getEmInternalApi(em).joinRows(this).getOthers(this.columnName, this.entity) as U[];\n  }\n\n  // This is like calling `setField` but for a m2m relation...\n  #syncJoinTableRows(newValue: U[]): void {\n    const jr = getEmInternalApi(this.entity.em).joinRows(this);\n    const newSet = new Set(newValue);\n    const oldSet = new Set(jr.getOthers(this.columnName, this.entity) as U[]);\n    // Find entities to add (in new but not in old)\n    for (const entity of newValue) {\n      if (!oldSet.has(entity)) {\n        jr.addNew(this, this.entity, entity);\n      }\n    }\n    // Find entities to remove (in old but not in new)\n    for (const entity of oldSet) {\n      if (!newSet.has(entity)) {\n        jr.addRemove(this, this.entity, entity);\n      }\n    }\n  }\n\n  #filterDeleted(entities: U[], opts?: { withDeleted?: boolean }): U[] {\n    return opts?.withDeleted === true\n      ? [...entities]\n      : entities.filter((e) => !e.isDeletedEntity && !(e as any).isSoftDeletedEntity);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveManyToMany. */\nexport function isReactiveManyToMany(\n  maybeReactiveManyToMany: any,\n): maybeReactiveManyToMany is ReactiveManyToMany<any, any> {\n  return maybeReactiveManyToMany instanceof ReactiveManyToManyImpl;\n}\n"],"mappings":"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"}

package/build/relations/ReactiveManyToMany.d.cts

@@ -0,0 +1,63 @@
+import { AbstractRelationImpl } from "./AbstractRelationImpl.cjs";
+import { RelationT, RelationU } from "./RelationSymbols.cjs";
+import { IsLoadedCachable } from "../loading/IsLoadedCache.cjs";
+import { ReadOnlyCollection } from "./ReadOnlyCollection.cjs";
+import { MaybeReactedEntity, Reacted, ReactiveHint } from "../reactivity/reactiveHints.cjs";
+import { EntityMetadata, ManyToManyField } from "../EntityMetadata.cjs";
+import "../index.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/relations/ReactiveManyToMany.d.ts
+/**
+ * A reactive, derived many-to-many collection.
+ *
+ * Similar to `ReactiveReference` but for collections--membership is calculated from a reactive
+ * function and persisted to the underlying join table.
+ */
+interface ReactiveManyToMany<T extends Entity, U extends Entity> extends ReadOnlyCollection<T, U> {
+  load(opts?: {
+    withDeleted?: boolean;
+    forceReload?: boolean;
+  }): Promise<readonly U[]>;
+}
+/** Creates a `ReactiveManyToMany`. */
+declare function hasReactiveManyToMany<T extends Entity, U extends Entity, const H extends ReactiveHint<T>>(hint: H, fn: (entity: Reacted<T, H>) => readonly MaybeReactedEntity<U>[]): ReactiveManyToMany<T, U>;
+/** Implements ReactiveManyToMany, initially a copy/paste of ReactiveReference but for m2m. */
+declare class ReactiveManyToManyImpl<T extends Entity, U extends Entity, H extends ReactiveHint<T>> extends AbstractRelationImpl<T, U[]> implements ReactiveManyToMany<T, U>, IsLoadedCachable {
+  #private;
+  reactiveHint: H;
+  private fn;
+  constructor(entity: T, field: ManyToManyField, reactiveHint: H, fn: (entity: Reacted<T, H>) => readonly MaybeReactedEntity<U>[]);
+  load(opts?: {
+    withDeleted?: boolean;
+    forceReload?: boolean;
+  }): Promise<ReadonlyArray<U>>;
+  get isLoaded(): boolean;
+  resetIsLoaded(): void;
+  get getWithDeleted(): U[];
+  get get(): U[];
+  set(): void;
+  get loadHint(): any;
+  setFromOpts(_others: U[]): void;
+  maybeCascadeDelete(): void;
+  cleanupOnEntityDeleted(): Promise<void>;
+  get meta(): EntityMetadata;
+  get fieldName(): string;
+  get otherMeta(): EntityMetadata;
+  get joinTableName(): string;
+  get columnName(): string;
+  get otherColumnName(): string;
+  get hasJoinTableId(): boolean;
+  get otherFieldName(): string;
+  get hasBeenSet(): boolean;
+  get isPreloaded(): boolean;
+  preload(): void;
+  import(other: ReactiveManyToManyImpl<T, U, H>, _: unknown, mapEntities: (e: U[] | undefined) => U[] | undefined): void;
+  toString(): string;
+  [RelationT]: T;
+  [RelationU]: U;
+}
+/** Type guard utility for determining if an entity field is a ReactiveManyToMany. */
+declare function isReactiveManyToMany(maybeReactiveManyToMany: any): maybeReactiveManyToMany is ReactiveManyToMany<any, any>;
+//#endregion
+export { ReactiveManyToMany, ReactiveManyToManyImpl, hasReactiveManyToMany, isReactiveManyToMany };
+//# sourceMappingURL=ReactiveManyToMany.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ReactiveManyToMany.d.cts","names":[],"sources":["../../src/relations/ReactiveManyToMany.ts"],"mappings":";;;;;;;;;;;;;;;UAgCiB,mBAAmB,UAAU,QAAQ,UAAU,gBAAgB,mBAAmB,GAAG;EACpG,KAAK;IAAS;IAAuB;MAA0B,iBAAiB;;;iBAIlE,sBAAsB,UAAU,QAAQ,UAAU,cAAc,UAAU,aAAa,IACrG,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,gBAAgB,mBAAmB,OAC1D,mBAAmB,GAAG;;cAQZ,uBAAuB,UAAU,QAAQ,UAAU,QAAQ,UAAU,aAAa,YACrF,qBAAqB,GAAG,gBACrB,mBAAmB,GAAG,IAAI;;EAkB5B,cAAc;UACb;EAJV,YACE,QAAQ,GACR,OAAO,iBACA,cAAc,GACb,KAAK,QAAQ,QAAQ,GAAG,gBAAgB,mBAAmB;EAO/D,KAAK;IAAS;IAAuB;MAA0B,QAAQ,cAAc;MAgCvF;EAiBJ;MAyCI,kBAAkB;MAIlB,OAAO;EAIX;MAII;EAKJ,YAAY,SAAS;EAIrB;EAOM,0BAA0B;MAS5B,QAAQ;MAIR;MAIA,aAAa;MAIb;MAIA;MAIA;MAIA;MAIA;MAIA;MAIA;EAIJ;EAIA,OACE,OAAO,uBAAuB,GAAG,GAAG,IACpC,YACA,cAAc,GAAG,oBAAoB;EAShC;GAyCN,YAAY;GACZ,YAAY;;;iBAIC,qBACd,+BACC,2BAA2B"}

package/build/relations/ReactiveManyToMany.d.mts

@@ -0,0 +1,63 @@
+import { AbstractRelationImpl } from "./AbstractRelationImpl.mjs";
+import { RelationT, RelationU } from "./RelationSymbols.mjs";
+import { IsLoadedCachable } from "../loading/IsLoadedCache.mjs";
+import { ReadOnlyCollection } from "./ReadOnlyCollection.mjs";
+import { MaybeReactedEntity, Reacted, ReactiveHint } from "../reactivity/reactiveHints.mjs";
+import { EntityMetadata, ManyToManyField } from "../EntityMetadata.mjs";
+import "../index.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/relations/ReactiveManyToMany.d.ts
+/**
+ * A reactive, derived many-to-many collection.
+ *
+ * Similar to `ReactiveReference` but for collections--membership is calculated from a reactive
+ * function and persisted to the underlying join table.
+ */
+interface ReactiveManyToMany<T extends Entity, U extends Entity> extends ReadOnlyCollection<T, U> {
+  load(opts?: {
+    withDeleted?: boolean;
+    forceReload?: boolean;
+  }): Promise<readonly U[]>;
+}
+/** Creates a `ReactiveManyToMany`. */
+declare function hasReactiveManyToMany<T extends Entity, U extends Entity, const H extends ReactiveHint<T>>(hint: H, fn: (entity: Reacted<T, H>) => readonly MaybeReactedEntity<U>[]): ReactiveManyToMany<T, U>;
+/** Implements ReactiveManyToMany, initially a copy/paste of ReactiveReference but for m2m. */
+declare class ReactiveManyToManyImpl<T extends Entity, U extends Entity, H extends ReactiveHint<T>> extends AbstractRelationImpl<T, U[]> implements ReactiveManyToMany<T, U>, IsLoadedCachable {
+  #private;
+  reactiveHint: H;
+  private fn;
+  constructor(entity: T, field: ManyToManyField, reactiveHint: H, fn: (entity: Reacted<T, H>) => readonly MaybeReactedEntity<U>[]);
+  load(opts?: {
+    withDeleted?: boolean;
+    forceReload?: boolean;
+  }): Promise<ReadonlyArray<U>>;
+  get isLoaded(): boolean;
+  resetIsLoaded(): void;
+  get getWithDeleted(): U[];
+  get get(): U[];
+  set(): void;
+  get loadHint(): any;
+  setFromOpts(_others: U[]): void;
+  maybeCascadeDelete(): void;
+  cleanupOnEntityDeleted(): Promise<void>;
+  get meta(): EntityMetadata;
+  get fieldName(): string;
+  get otherMeta(): EntityMetadata;
+  get joinTableName(): string;
+  get columnName(): string;
+  get otherColumnName(): string;
+  get hasJoinTableId(): boolean;
+  get otherFieldName(): string;
+  get hasBeenSet(): boolean;
+  get isPreloaded(): boolean;
+  preload(): void;
+  import(other: ReactiveManyToManyImpl<T, U, H>, _: unknown, mapEntities: (e: U[] | undefined) => U[] | undefined): void;
+  toString(): string;
+  [RelationT]: T;
+  [RelationU]: U;
+}
+/** Type guard utility for determining if an entity field is a ReactiveManyToMany. */
+declare function isReactiveManyToMany(maybeReactiveManyToMany: any): maybeReactiveManyToMany is ReactiveManyToMany<any, any>;
+//#endregion
+export { ReactiveManyToMany, ReactiveManyToManyImpl, hasReactiveManyToMany, isReactiveManyToMany };
+//# sourceMappingURL=ReactiveManyToMany.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ReactiveManyToMany.d.mts","names":[],"sources":["../../src/relations/ReactiveManyToMany.ts"],"mappings":";;;;;;;;;;;;;;;UAgCiB,mBAAmB,UAAU,QAAQ,UAAU,gBAAgB,mBAAmB,GAAG;EACpG,KAAK;IAAS;IAAuB;MAA0B,iBAAiB;;;iBAIlE,sBAAsB,UAAU,QAAQ,UAAU,cAAc,UAAU,aAAa,IACrG,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,gBAAgB,mBAAmB,OAC1D,mBAAmB,GAAG;;cAQZ,uBAAuB,UAAU,QAAQ,UAAU,QAAQ,UAAU,aAAa,YACrF,qBAAqB,GAAG,gBACrB,mBAAmB,GAAG,IAAI;;EAkB5B,cAAc;UACb;EAJV,YACE,QAAQ,GACR,OAAO,iBACA,cAAc,GACb,KAAK,QAAQ,QAAQ,GAAG,gBAAgB,mBAAmB;EAO/D,KAAK;IAAS;IAAuB;MAA0B,QAAQ,cAAc;MAgCvF;EAiBJ;MAyCI,kBAAkB;MAIlB,OAAO;EAIX;MAII;EAKJ,YAAY,SAAS;EAIrB;EAOM,0BAA0B;MAS5B,QAAQ;MAIR;MAIA,aAAa;MAIb;MAIA;MAIA;MAIA;MAIA;MAIA;MAIA;EAIJ;EAIA,OACE,OAAO,uBAAuB,GAAG,GAAG,IACpC,YACA,cAAc,GAAG,oBAAoB;EAShC;GAyCN,YAAY;GACZ,YAAY;;;iBAIC,qBACd,+BACC,2BAA2B"}