joist-core 2.3.0 → 2.4.0

package/build/relations/ManyToManyCollection.js

@@ -1,479 +1,419 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManyToManyCollection = void 0;
-exports.hasManyToMany = hasManyToMany;
-const __1 = require("../");
-const manyToManyBatchLoader_1 = require("../batchloaders/manyToManyBatchLoader");
-const manyToManyFindDataLoader_1 = require("../dataloaders/manyToManyFindDataLoader");
-const newEntity_1 = require("../newEntity");
-const utils_1 = require("../utils");
-const AbstractRelationImpl_1 = require("./AbstractRelationImpl");
-const Relation_1 = require("./Relation");
+import { AbstractRelationImpl } from "./AbstractRelationImpl.js";
+import { RelationT, RelationU } from "./RelationSymbols.js";
+import { toTaggedId } from "../keys.js";
+import { manyToManyBatchLoader } from "../batchloaders/manyToManyBatchLoader.js";
+import { manyToManyFindDataLoader } from "../dataloaders/manyToManyFindDataLoader.js";
+import { isCascadeDelete } from "./isCascadeDelete.js";
+import { maybeAdd, maybeRemove, remove } from "../utils.js";
+import { lazyField } from "../newEntity.js";
+import { getMetadata, getMetadataForField } from "../EntityMetadata.js";
+import { ensureNotDeleted } from "../index.js";
+import { appendStack, getEmInternalApi } from "../EntityManager.js";
+import { getInstanceData } from "../BaseEntity.js";
+//#region src/relations/ManyToManyCollection.ts
 /** An alias for creating `ManyToManyCollections`s. */
 function hasManyToMany() {
-    return (0, newEntity_1.lazyField)((entity, fieldName) => {
-        const m2m = (0, __1.getMetadata)(entity).allFields[fieldName];
-        return new ManyToManyCollection(entity, m2m);
-    });
+	return lazyField((entity, fieldName) => {
+		const m2m = getMetadata(entity).allFields[fieldName];
+		return new ManyToManyCollection(entity, m2m);
+	});
 }
-class ManyToManyCollection extends AbstractRelationImpl_1.AbstractRelationImpl {
-    #field;
-    #loadPromise;
-    #state;
-    // I.e. when entity = Book:
-    // fieldName == tags, because it's our collection to tags
-    // columnName = book_id, what we use as the `where book_id = us` to find our join table rows
-    // otherFieldName = books, how tags points to us
-    // otherColumnName = tag_id, how the other side finds its join table rows
-    constructor(entity, field) {
-        super(entity);
-        this.#field = field;
-        if ((0, __1.getInstanceData)(entity).isOrWasNew) {
-            this.#state = new LoadedState(this, [], false);
-        }
-        else {
-            this.#state = new UnloadedPristineState(this);
-        }
-    }
-    /** @internal */
-    percolateAdd(other) {
-        other[this.otherFieldName].add(this.entity, true);
-    }
-    /** @internal */
-    percolateRemove(other) {
-        other[this.otherFieldName].remove(this.entity, true);
-    }
-    /** @internal */
-    registerJoinRowAdd(other) {
-        (0, __1.getEmInternalApi)(this.entity.em).joinRows(this).addNew(this, this.entity, other);
-    }
-    /** @internal */
-    registerJoinRowRemove(other) {
-        (0, __1.getEmInternalApi)(this.entity.em).joinRows(this).addRemove(this, this.entity, other);
-    }
-    /** Removes pending-hard-delete or soft-deleted entities, unless explicitly asked for. */
-    filterDeleted(entities, opts) {
-        return opts?.withDeleted === true
-            ? [...entities]
-            : entities.filter((e) => !e.isDeletedEntity && !e.isSoftDeletedEntity);
-    }
-    async load(opts = {}) {
-        (0, __1.ensureNotDeleted)(this.entity, "pending");
-        if (!this.#state.isLoaded || (opts.forceReload && !this.entity.isNewEntity)) {
-            const key = `${this.columnName}=${this.entity.id}`;
-            const maybePreloaded = this.#getPreloaded();
-            if (maybePreloaded) {
-                this.#state = this.#state.applyLoad(maybePreloaded);
-            }
-            else {
-                await (this.#loadPromise ??= (0, manyToManyBatchLoader_1.manyToManyBatchLoader)(this.entity.em, this).load(key))
-                    .then(() => this.preload())
-                    .catch(function load(err) {
-                    throw (0, __1.appendStack)(err, new Error());
-                })
-                    .finally(() => {
-                    this.#loadPromise = undefined;
-                });
-            }
-        }
-        return this.filterDeleted(this.#state.doGet(), opts);
-    }
-    async find(id) {
-        (0, __1.ensureNotDeleted)(this.entity, "pending");
-        const inMemory = this.#state.find(id);
-        if (inMemory)
-            return inMemory;
-        if (this.#state.isLoaded)
-            return undefined;
-        const key = `${this.columnName}=${this.entity.id},${this.otherColumnName}=${id}`;
-        const includes = await (0, manyToManyFindDataLoader_1.manyToManyFindDataLoader)(this.entity.em, this)
-            .load(key)
-            .catch(function load(err) {
-            throw (0, __1.appendStack)(err, new Error());
-        });
-        const taggedId = (0, __1.toTaggedId)(this.otherMeta, id);
-        return includes ? this.entity.em.load(taggedId) : undefined;
-    }
-    async includes(other) {
-        (0, __1.ensureNotDeleted)(this.entity, "pending");
-        const inMemory = this.#state.includesInMemory(other);
-        if (inMemory !== undefined)
-            return inMemory;
-        if (other.isNewEntity)
-            return false;
-        const key = `${this.columnName}=${this.entity.id},${this.otherColumnName}=${other.id}`;
-        return (0, manyToManyFindDataLoader_1.manyToManyFindDataLoader)(this.entity.em, this)
-            .load(key)
-            .catch(function includes(err) {
-            throw (0, __1.appendStack)(err, new Error());
-        });
-    }
-    add(other, percolated = false) {
-        (0, __1.ensureNotDeleted)(this.entity);
-        this.#state = this.#state.add(other, percolated);
-    }
-    remove(other, percolated = false) {
-        (0, __1.ensureNotDeleted)(this.entity, "pending");
-        this.#state = this.#state.remove(other, percolated);
-    }
-    get isLoaded() {
-        return this.#state.isLoaded;
-    }
-    get isPreloaded() {
-        return !!this.#getPreloaded();
-    }
-    preload() {
-        const preloaded = this.#getPreloaded();
-        if (preloaded) {
-            this.#state = this.#state.applyLoad(preloaded);
-        }
-    }
-    import(other, _, mapEntities) {
-        this.#state = other.#state.import(this, mapEntities);
-    }
-    doGet() {
-        (0, __1.ensureNotDeleted)(this.entity, "pending");
-        return this.#state.doGet();
-    }
-    get getWithDeleted() {
-        return this.filterDeleted(this.doGet(), { withDeleted: true });
-    }
-    get get() {
-        return this.filterDeleted(this.doGet(), { withDeleted: false });
-    }
-    set(values) {
-        (0, __1.ensureNotDeleted)(this.entity);
-        this.#state = this.#state.set(values);
-    }
-    removeAll() {
-        (0, __1.ensureNotDeleted)(this.entity);
-        if (!this.#state.isLoaded) {
-            throw new Error("removeAll was called when not loaded");
-        }
-        for (const other of [...this.#state.doGet()]) {
-            this.remove(other);
-        }
-    }
-    // impl details
-    setFromOpts(others) {
-        this.#state = new LoadedState(this, [], false);
-        others.forEach((o) => this.add(o));
-    }
-    maybeCascadeDelete() {
-        if (this.#isCascadeDelete) {
-            this.filterDeleted(this.#state.current({ withDeleted: true }), { withDeleted: true }).forEach((e) => this.entity.em.delete(e));
-        }
-    }
-    async cleanupOnEntityDeleted() {
-        if (this.#isCascadeDelete)
-            return;
-        const entities = await this.load({ withDeleted: true });
-        entities.forEach((other) => {
-            const m2m = other[this.otherFieldName];
-            m2m.remove(this.entity);
-        });
-        if (this.#state instanceof LoadedState) {
-            this.#state.setLoaded([]);
-        }
-    }
-    get meta() {
-        return (0, __1.getMetadataForField)((0, __1.getMetadata)(this.entity), this.fieldName);
-    }
-    get otherMeta() {
-        return this.#field.otherMetadata();
-    }
-    get joinTableName() {
-        return this.#field.joinTableName;
-    }
-    get fieldName() {
-        return this.#field.fieldName;
-    }
-    get otherFieldName() {
-        return this.#field.otherFieldName;
-    }
-    get columnName() {
-        return this.#field.columnNames[0];
-    }
-    get otherColumnName() {
-        return this.#field.columnNames[1];
-    }
-    get hasJoinTableId() {
-        return this.#field.hasJoinTableId;
-    }
-    get #isCascadeDelete() {
-        return (0, AbstractRelationImpl_1.isCascadeDelete)(this, this.fieldName);
-    }
-    get hasBeenSet() {
-        return this.#state.hasBeenSet;
-    }
-    toString() {
-        return `OneToManyCollection(entity: ${this.entity}, fieldName: ${this.fieldName}, otherType: ${this.otherMeta.type}, otherFieldName: ${this.otherFieldName})`;
-    }
-    #getPreloaded() {
-        if (this.entity.isNewEntity)
-            return undefined;
-        return (0, __1.getEmInternalApi)(this.entity.em).getPreloadedRelation(this.entity.idTagged, this.fieldName);
-    }
-    [Relation_1.RelationT] = null;
-    [Relation_1.RelationU] = null;
-}
-exports.ManyToManyCollection = ManyToManyCollection;
+var ManyToManyCollection = class extends AbstractRelationImpl {
+	#field;
+	#loadPromise;
+	#state;
+	constructor(entity, field) {
+		super(entity);
+		this.#field = field;
+		if (getInstanceData(entity).isOrWasNew) this.#state = new LoadedState(this, [], false);
+		else this.#state = new UnloadedPristineState(this);
+	}
+	/** @internal */
+	percolateAdd(other) {
+		other[this.otherFieldName].add(this.entity, true);
+	}
+	/** @internal */
+	percolateRemove(other) {
+		other[this.otherFieldName].remove(this.entity, true);
+	}
+	/** @internal */
+	registerJoinRowAdd(other) {
+		getEmInternalApi(this.entity.em).joinRows(this).addNew(this, this.entity, other);
+	}
+	/** @internal */
+	registerJoinRowRemove(other) {
+		getEmInternalApi(this.entity.em).joinRows(this).addRemove(this, this.entity, other);
+	}
+	/** Removes pending-hard-delete or soft-deleted entities, unless explicitly asked for. */
+	filterDeleted(entities, opts) {
+		if (opts?.withDeleted === true) return [...entities];
+		const includeSoftDeleted = this.#field.softDeletes === "include";
+		return entities.filter((e) => !e.isDeletedEntity && (includeSoftDeleted || !e.isSoftDeletedEntity));
+	}
+	async load(opts = {}) {
+		ensureNotDeleted(this.entity, "pending");
+		if (!this.#state.isLoaded || opts.forceReload && !this.entity.isNewEntity) {
+			const key = `${this.columnName}=${this.entity.id}`;
+			const maybePreloaded = this.#getPreloaded();
+			if (maybePreloaded) this.#state = this.#state.applyLoad(maybePreloaded);
+			else await (this.#loadPromise ??= manyToManyBatchLoader(this.entity.em, this).load(key)).then(() => this.preload()).catch(function load(err) {
+				throw appendStack(err, /* @__PURE__ */ new Error());
+			}).finally(() => {
+				this.#loadPromise = void 0;
+			});
+		}
+		return this.filterDeleted(this.#state.doGet(), opts);
+	}
+	async find(id) {
+		ensureNotDeleted(this.entity, "pending");
+		const inMemory = this.#state.find(id);
+		if (inMemory) return inMemory;
+		if (this.#state.isLoaded) return void 0;
+		const key = `${this.columnName}=${this.entity.id},${this.otherColumnName}=${id}`;
+		const includes = await manyToManyFindDataLoader(this.entity.em, this).load(key).catch(function load(err) {
+			throw appendStack(err, /* @__PURE__ */ new Error());
+		});
+		const taggedId = toTaggedId(this.otherMeta, id);
+		return includes ? this.entity.em.load(taggedId) : void 0;
+	}
+	async includes(other) {
+		ensureNotDeleted(this.entity, "pending");
+		const inMemory = this.#state.includesInMemory(other);
+		if (inMemory !== void 0) return inMemory;
+		if (other.isNewEntity) return false;
+		const key = `${this.columnName}=${this.entity.id},${this.otherColumnName}=${other.id}`;
+		return manyToManyFindDataLoader(this.entity.em, this).load(key).catch(function includes(err) {
+			throw appendStack(err, /* @__PURE__ */ new Error());
+		});
+	}
+	add(other, percolated = false) {
+		ensureNotDeleted(this.entity);
+		this.#state = this.#state.add(other, percolated);
+	}
+	remove(other, percolated = false) {
+		ensureNotDeleted(this.entity, "pending");
+		this.#state = this.#state.remove(other, percolated);
+	}
+	get isLoaded() {
+		return this.#state.isLoaded;
+	}
+	get isPreloaded() {
+		return !!this.#getPreloaded();
+	}
+	preload() {
+		const preloaded = this.#getPreloaded();
+		if (preloaded) this.#state = this.#state.applyLoad(preloaded);
+	}
+	import(other, _, mapEntities) {
+		this.#state = other.#state.import(this, mapEntities);
+	}
+	doGet() {
+		ensureNotDeleted(this.entity, "pending");
+		return this.#state.doGet();
+	}
+	get getWithDeleted() {
+		return this.filterDeleted(this.doGet(), { withDeleted: true });
+	}
+	get get() {
+		return this.filterDeleted(this.doGet(), { withDeleted: false });
+	}
+	set(values) {
+		ensureNotDeleted(this.entity);
+		this.#state = this.#state.set(values);
+	}
+	removeAll() {
+		ensureNotDeleted(this.entity);
+		if (!this.#state.isLoaded) throw new Error("removeAll was called when not loaded");
+		for (const other of [...this.#state.doGet()]) this.remove(other);
+	}
+	setFromOpts(others) {
+		this.#state = new LoadedState(this, [], false);
+		others.forEach((o) => this.add(o));
+	}
+	maybeCascadeDelete() {
+		if (this.#isCascadeDelete) this.filterDeleted(this.#state.current({ withDeleted: true }), { withDeleted: true }).forEach((e) => this.entity.em.delete(e));
+	}
+	async cleanupOnEntityDeleted() {
+		if (this.#isCascadeDelete) return;
+		(await this.load({ withDeleted: true })).forEach((other) => {
+			other[this.otherFieldName].remove(this.entity);
+		});
+		if (this.#state instanceof LoadedState) this.#state.setLoaded([]);
+	}
+	get meta() {
+		return getMetadataForField(getMetadata(this.entity), this.fieldName);
+	}
+	get otherMeta() {
+		return this.#field.otherMetadata();
+	}
+	get joinTableName() {
+		return this.#field.joinTableName;
+	}
+	get fieldName() {
+		return this.#field.fieldName;
+	}
+	get otherFieldName() {
+		return this.#field.otherFieldName;
+	}
+	get columnName() {
+		return this.#field.columnNames[0];
+	}
+	get otherColumnName() {
+		return this.#field.columnNames[1];
+	}
+	get hasJoinTableId() {
+		return this.#field.hasJoinTableId;
+	}
+	get #isCascadeDelete() {
+		return isCascadeDelete(this, this.fieldName);
+	}
+	get hasBeenSet() {
+		return this.#state.hasBeenSet;
+	}
+	toString() {
+		return `OneToManyCollection(entity: ${this.entity}, fieldName: ${this.fieldName}, otherType: ${this.otherMeta.type}, otherFieldName: ${this.otherFieldName})`;
+	}
+	#getPreloaded() {
+		if (this.entity.isNewEntity) return void 0;
+		return getEmInternalApi(this.entity.em).getPreloadedRelation(this.entity.idTagged, this.fieldName);
+	}
+	[RelationT] = null;
+	[RelationU] = null;
+};
 /** Initial state for existing entities - no data loaded yet. */
-class UnloadedPristineState {
-    isLoaded = false;
-    hasBeenSet = false;
-    #m2m;
-    constructor(m2m) {
-        this.#m2m = m2m;
-    }
-    add(other, percolated) {
-        const newState = new UnloadedAddedRemovedState(this.#m2m, [other], []);
-        if (!percolated) {
-            this.#m2m.registerJoinRowAdd(other);
-            this.#m2m.percolateAdd(other);
-        }
-        return newState;
-    }
-    remove(other, percolated) {
-        if (!percolated) {
-            this.#m2m.registerJoinRowRemove(other);
-            this.#m2m.percolateRemove(other);
-        }
-        return new UnloadedAddedRemovedState(this.#m2m, [], [other]);
-    }
-    set(values) {
-        return new PendingSetState(this.#m2m, [...values]);
-    }
-    doGet() {
-        throw new Error(`${this.#m2m.entity}.${this.#m2m.fieldName}.get was called when not loaded`);
-    }
-    find(_id) {
-        return undefined;
-    }
-    includesInMemory(_other) {
-        return undefined;
-    }
-    applyLoad(dbEntities) {
-        return new LoadedState(this.#m2m, dbEntities, false);
-    }
-    current(_opts) {
-        return [];
-    }
-    import(m2m, _mapEntities) {
-        return new UnloadedPristineState(m2m);
-    }
-}
+var UnloadedPristineState = class UnloadedPristineState {
+	isLoaded = false;
+	hasBeenSet = false;
+	#m2m;
+	constructor(m2m) {
+		this.#m2m = m2m;
+	}
+	add(other, percolated) {
+		const newState = new UnloadedAddedRemovedState(this.#m2m, [other], []);
+		if (!percolated) {
+			this.#m2m.registerJoinRowAdd(other);
+			this.#m2m.percolateAdd(other);
+		}
+		return newState;
+	}
+	remove(other, percolated) {
+		if (!percolated) {
+			this.#m2m.registerJoinRowRemove(other);
+			this.#m2m.percolateRemove(other);
+		}
+		return new UnloadedAddedRemovedState(this.#m2m, [], [other]);
+	}
+	set(values) {
+		return new PendingSetState(this.#m2m, [...values]);
+	}
+	doGet() {
+		throw new Error(`${this.#m2m.entity}.${this.#m2m.fieldName}.get was called when not loaded`);
+	}
+	find(_id) {}
+	includesInMemory(_other) {}
+	applyLoad(dbEntities) {
+		return new LoadedState(this.#m2m, dbEntities, false);
+	}
+	current(_opts) {
+		return [];
+	}
+	import(m2m, _mapEntities) {
+		return new UnloadedPristineState(m2m);
+	}
+};
 /** State when add/remove called before load - tracks changes to merge later. */
-class UnloadedAddedRemovedState {
-    isLoaded = false;
-    hasBeenSet = false;
-    #m2m;
-    #added;
-    #removed;
-    constructor(m2m, added, removed) {
-        this.#m2m = m2m;
-        this.#added = added;
-        this.#removed = removed;
-    }
-    add(other, percolated) {
-        (0, utils_1.maybeRemove)(this.#removed, other);
-        if (!this.#added.includes(other)) {
-            this.#added.push(other);
-        }
-        if (!percolated) {
-            this.#m2m.registerJoinRowAdd(other);
-            this.#m2m.percolateAdd(other);
-        }
-        return this;
-    }
-    remove(other, percolated) {
-        if (!percolated) {
-            this.#m2m.registerJoinRowRemove(other);
-            this.#m2m.percolateRemove(other);
-        }
-        (0, utils_1.maybeRemove)(this.#added, other);
-        (0, utils_1.maybeAdd)(this.#removed, other);
-        return this;
-    }
-    set(values) {
-        return new PendingSetState(this.#m2m, [...values]);
-    }
-    doGet() {
-        throw new Error(`${this.#m2m.entity}.${this.#m2m.fieldName}.get was called when not loaded`);
-    }
-    find(id) {
-        return this.#added.find((u) => u.id === id);
-    }
-    includesInMemory(other) {
-        if (this.#added.includes(other))
-            return true;
-        return undefined;
-    }
-    applyLoad(dbEntities) {
-        const loaded = [...dbEntities];
-        for (const e of this.#added) {
-            if (!loaded.includes(e)) {
-                loaded.unshift(e);
-                this.#m2m.registerJoinRowAdd(e);
-            }
-        }
-        for (const e of this.#removed) {
-            (0, utils_1.remove)(loaded, e);
-            this.#m2m.registerJoinRowRemove(e);
-        }
-        return new LoadedState(this.#m2m, loaded, false);
-    }
-    current(_opts) {
-        return this.#added;
-    }
-    import(m2m, mapEntities) {
-        const added = mapEntities(this.#added);
-        const removed = mapEntities(this.#removed);
-        return new UnloadedAddedRemovedState(m2m, added ?? [], removed ?? []);
-    }
-}
+var UnloadedAddedRemovedState = class UnloadedAddedRemovedState {
+	isLoaded = false;
+	hasBeenSet = false;
+	#m2m;
+	#added;
+	#removed;
+	constructor(m2m, added, removed) {
+		this.#m2m = m2m;
+		this.#added = added;
+		this.#removed = removed;
+	}
+	add(other, percolated) {
+		maybeRemove(this.#removed, other);
+		if (!this.#added.includes(other)) this.#added.push(other);
+		if (!percolated) {
+			this.#m2m.registerJoinRowAdd(other);
+			this.#m2m.percolateAdd(other);
+		}
+		return this;
+	}
+	remove(other, percolated) {
+		if (!percolated) {
+			this.#m2m.registerJoinRowRemove(other);
+			this.#m2m.percolateRemove(other);
+		}
+		maybeRemove(this.#added, other);
+		maybeAdd(this.#removed, other);
+		return this;
+	}
+	set(values) {
+		return new PendingSetState(this.#m2m, [...values]);
+	}
+	doGet() {
+		throw new Error(`${this.#m2m.entity}.${this.#m2m.fieldName}.get was called when not loaded`);
+	}
+	find(id) {
+		return this.#added.find((u) => u.id === id);
+	}
+	includesInMemory(other) {
+		if (this.#added.includes(other)) return true;
+	}
+	applyLoad(dbEntities) {
+		const loaded = [...dbEntities];
+		for (const e of this.#added) if (!loaded.includes(e)) {
+			loaded.unshift(e);
+			this.#m2m.registerJoinRowAdd(e);
+		}
+		for (const e of this.#removed) {
+			remove(loaded, e);
+			this.#m2m.registerJoinRowRemove(e);
+		}
+		return new LoadedState(this.#m2m, loaded, false);
+	}
+	current(_opts) {
+		return this.#added;
+	}
+	import(m2m, mapEntities) {
+		const added = mapEntities(this.#added);
+		const removed = mapEntities(this.#removed);
+		return new UnloadedAddedRemovedState(m2m, added ?? [], removed ?? []);
+	}
+};
 /** State when set() called before load - holds pending values to diff on load. */
-class PendingSetState {
-    isLoaded = false;
-    hasBeenSet = true;
-    #m2m;
-    #pendingSet;
-    constructor(m2m, pendingSet) {
-        this.#m2m = m2m;
-        this.#pendingSet = pendingSet;
-        (0, __1.getEmInternalApi)(m2m.entity.em).pendingLoads.add(m2m);
-    }
-    add(other, percolated) {
-        if (!this.#pendingSet.includes(other)) {
-            this.#pendingSet.push(other);
-        }
-        if (!percolated) {
-            this.#m2m.registerJoinRowAdd(other);
-            this.#m2m.percolateAdd(other);
-        }
-        return this;
-    }
-    remove(other, percolated) {
-        if (!percolated) {
-            this.#m2m.registerJoinRowRemove(other);
-            this.#m2m.percolateRemove(other);
-        }
-        (0, utils_1.remove)(this.#pendingSet, other);
-        return this;
-    }
-    set(values) {
-        this.#pendingSet = [...values];
-        return this;
-    }
-    doGet() {
-        return this.#pendingSet;
-    }
-    find(id) {
-        return this.#pendingSet.find((u) => u.id === id);
-    }
-    includesInMemory(other) {
-        return this.#pendingSet.includes(other);
-    }
-    applyLoad(dbEntities) {
-        const loaded = [...dbEntities];
-        const pending = this.#pendingSet;
-        for (const other of [...loaded]) {
-            if (!pending.includes(other)) {
-                (0, utils_1.remove)(loaded, other);
-                this.#m2m.registerJoinRowRemove(other);
-                this.#m2m.percolateRemove(other);
-            }
-        }
-        for (const other of pending) {
-            if (!loaded.includes(other)) {
-                loaded.push(other);
-                this.#m2m.registerJoinRowAdd(other);
-                this.#m2m.percolateAdd(other);
-            }
-        }
-        return new LoadedState(this.#m2m, loaded, true);
-    }
-    current(_opts) {
-        return this.#pendingSet;
-    }
-    import(m2m, mapEntities) {
-        const pendingSet = mapEntities(this.#pendingSet);
-        return new PendingSetState(m2m, pendingSet ?? []);
-    }
-}
+var PendingSetState = class PendingSetState {
+	isLoaded = false;
+	hasBeenSet = true;
+	#m2m;
+	#pendingSet;
+	constructor(m2m, pendingSet) {
+		this.#m2m = m2m;
+		this.#pendingSet = pendingSet;
+		getEmInternalApi(m2m.entity.em).pendingLoads.add(m2m);
+	}
+	add(other, percolated) {
+		if (!this.#pendingSet.includes(other)) this.#pendingSet.push(other);
+		if (!percolated) {
+			this.#m2m.registerJoinRowAdd(other);
+			this.#m2m.percolateAdd(other);
+		}
+		return this;
+	}
+	remove(other, percolated) {
+		if (!percolated) {
+			this.#m2m.registerJoinRowRemove(other);
+			this.#m2m.percolateRemove(other);
+		}
+		remove(this.#pendingSet, other);
+		return this;
+	}
+	set(values) {
+		this.#pendingSet = [...values];
+		return this;
+	}
+	doGet() {
+		return this.#pendingSet;
+	}
+	find(id) {
+		return this.#pendingSet.find((u) => u.id === id);
+	}
+	includesInMemory(other) {
+		return this.#pendingSet.includes(other);
+	}
+	applyLoad(dbEntities) {
+		const loaded = [...dbEntities];
+		const pending = this.#pendingSet;
+		for (const other of [...loaded]) if (!pending.includes(other)) {
+			remove(loaded, other);
+			this.#m2m.registerJoinRowRemove(other);
+			this.#m2m.percolateRemove(other);
+		}
+		for (const other of pending) if (!loaded.includes(other)) {
+			loaded.push(other);
+			this.#m2m.registerJoinRowAdd(other);
+			this.#m2m.percolateAdd(other);
+		}
+		return new LoadedState(this.#m2m, loaded, true);
+	}
+	current(_opts) {
+		return this.#pendingSet;
+	}
+	import(m2m, mapEntities) {
+		const pendingSet = mapEntities(this.#pendingSet);
+		return new PendingSetState(m2m, pendingSet ?? []);
+	}
+};
 /** State when collection is loaded - all operations work directly on loaded array. */
-class LoadedState {
-    isLoaded = true;
-    #m2m;
-    #loaded;
-    #hasBeenSet;
-    constructor(m2m, loaded, hasBeenSet) {
-        this.#m2m = m2m;
-        this.#loaded = loaded;
-        this.#hasBeenSet = hasBeenSet;
-    }
-    get hasBeenSet() {
-        return this.#hasBeenSet;
-    }
-    add(other, percolated) {
-        if (this.#loaded.includes(other))
-            return this;
-        this.#loaded.push(other);
-        if (!percolated) {
-            this.#m2m.registerJoinRowAdd(other);
-            this.#m2m.percolateAdd(other);
-        }
-        return this;
-    }
-    remove(other, percolated) {
-        if (!percolated) {
-            this.#m2m.registerJoinRowRemove(other);
-            this.#m2m.percolateRemove(other);
-        }
-        (0, utils_1.remove)(this.#loaded, other);
-        return this;
-    }
-    set(values) {
-        this.#hasBeenSet = true;
-        const loaded = new Set([...this.#loaded]);
-        const valuesSet = new Set(values);
-        for (const other of loaded) {
-            if (!valuesSet.has(other)) {
-                this.remove(other, false);
-            }
-        }
-        for (const other of values) {
-            if (!loaded.has(other)) {
-                this.add(other, false);
-            }
-        }
-        return this;
-    }
-    doGet() {
-        return this.#loaded;
-    }
-    find(id) {
-        return this.#loaded.find((u) => u.id === id);
-    }
-    includesInMemory(other) {
-        return this.#loaded.includes(other);
-    }
-    applyLoad(dbEntities) {
-        this.#loaded = dbEntities;
-        return this;
-    }
-    current(_opts) {
-        return this.#loaded;
-    }
-    import(m2m, mapEntities) {
-        const loaded = mapEntities(this.#loaded);
-        return new LoadedState(m2m, loaded ?? [], this.#hasBeenSet);
-    }
-    getLoaded() {
-        return this.#loaded;
-    }
-    setLoaded(entities) {
-        this.#loaded = entities;
-    }
-}
+var LoadedState = class LoadedState {
+	isLoaded = true;
+	#m2m;
+	#loaded;
+	#hasBeenSet;
+	constructor(m2m, loaded, hasBeenSet) {
+		this.#m2m = m2m;
+		this.#loaded = loaded;
+		this.#hasBeenSet = hasBeenSet;
+	}
+	get hasBeenSet() {
+		return this.#hasBeenSet;
+	}
+	add(other, percolated) {
+		if (this.#loaded.includes(other)) return this;
+		this.#loaded.push(other);
+		if (!percolated) {
+			this.#m2m.registerJoinRowAdd(other);
+			this.#m2m.percolateAdd(other);
+		}
+		return this;
+	}
+	remove(other, percolated) {
+		if (!percolated) {
+			this.#m2m.registerJoinRowRemove(other);
+			this.#m2m.percolateRemove(other);
+		}
+		remove(this.#loaded, other);
+		return this;
+	}
+	set(values) {
+		this.#hasBeenSet = true;
+		const loaded = new Set(this.#loaded);
+		const valuesSet = new Set(values);
+		for (const other of loaded) if (!valuesSet.has(other)) this.remove(other, false);
+		for (const other of values) if (!loaded.has(other)) this.add(other, false);
+		return this;
+	}
+	doGet() {
+		return this.#loaded;
+	}
+	find(id) {
+		return this.#loaded.find((u) => u.id === id);
+	}
+	includesInMemory(other) {
+		return this.#loaded.includes(other);
+	}
+	applyLoad(dbEntities) {
+		this.#loaded = dbEntities;
+		return this;
+	}
+	current(_opts) {
+		return this.#loaded;
+	}
+	import(m2m, mapEntities) {
+		const loaded = mapEntities(this.#loaded);
+		return new LoadedState(m2m, loaded ?? [], this.#hasBeenSet);
+	}
+	getLoaded() {
+		return this.#loaded;
+	}
+	setLoaded(entities) {
+		this.#loaded = entities;
+	}
+};
+//#endregion
+export { ManyToManyCollection, hasManyToMany };
+
 //# sourceMappingURL=ManyToManyCollection.js.map