joist-core 2.3.0 → 2.4.0-next.2

package/build/relations/EnumCollection.cjs

@@ -0,0 +1,178 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_AbstractRelationImpl = require("./AbstractRelationImpl.cjs");
+const require_relations_RelationSymbols = require("./RelationSymbols.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_batchloaders_enumCollectionBatchLoader = require("../batchloaders/enumCollectionBatchLoader.cjs");
+const require_EntityManager = require("../EntityManager.cjs");
+const require_BaseEntity = require("../BaseEntity.cjs");
+//#region src/relations/EnumCollection.ts
+/** An alias for creating `EnumCollection`s. */
+function hasEnumCollection() {
+	return require_newEntity.lazyField((entity, fieldName) => {
+		const field = require_EntityMetadata.getMetadata(entity).allFields[fieldName];
+		return new EnumCollectionImpl(entity, field);
+	});
+}
+var EnumCollectionImpl = class extends require_relations_AbstractRelationImpl.AbstractRelationImpl {
+	#field;
+	#loaded;
+	#loadPromise;
+	#hasBeenSet = false;
+	/** Holds a pending `set()` when called on an unloaded collection, resolved at load. */
+	#pendingSet;
+	constructor(entity, field) {
+		super(entity);
+		this.#field = field;
+		this.#loaded = require_BaseEntity.getInstanceData(entity).isOrWasNew;
+	}
+	async load(opts = {}) {
+		require_index.ensureNotDeleted(this.entity, "pending");
+		if (!this.#loaded || opts.forceReload && !this.entity.isNewEntity) {
+			if (this.#getPreloaded() !== void 0) this.#loaded = true;
+			else await (this.#loadPromise ??= require_batchloaders_enumCollectionBatchLoader.enumCollectionBatchLoader(this.entity.em, this).load(this.entity.idTagged)).then(() => {
+				this.#loaded = true;
+			}).catch(function load(err) {
+				throw require_EntityManager.appendStack(err, /* @__PURE__ */ new Error());
+			}).finally(() => {
+				this.#loadPromise = void 0;
+			});
+			if (this.#pendingSet) {
+				const pending = this.#pendingSet;
+				this.#pendingSet = void 0;
+				this.#applySet(pending);
+			}
+		}
+		return this.get;
+	}
+	add(code) {
+		require_index.ensureNotDeleted(this.entity);
+		if (this.#pendingSet) {
+			if (!this.#pendingSet.includes(code)) this.#pendingSet.push(code);
+			return;
+		}
+		if (this.#loaded && this.get.includes(code)) return;
+		this.#joinRows.addNew(this, this.entity, this.#idOf(code));
+	}
+	remove(code) {
+		require_index.ensureNotDeleted(this.entity, "pending");
+		if (this.#pendingSet) {
+			require_utils.remove(this.#pendingSet, code);
+			return;
+		}
+		this.#joinRows.addRemove(this, this.entity, this.#idOf(code));
+	}
+	set(codes) {
+		require_index.ensureNotDeleted(this.entity);
+		this.#hasBeenSet = true;
+		if (!this.#loaded) {
+			this.#pendingSet = [...codes];
+			require_EntityManager.getEmInternalApi(this.entity.em).pendingLoads.add(this);
+			return;
+		}
+		this.#applySet(codes);
+	}
+	async includes(code) {
+		require_index.ensureNotDeleted(this.entity, "pending");
+		if (this.#pendingSet) return this.#pendingSet.includes(code);
+		if (this.#loaded) return this.get.includes(code);
+		if (this.entity.isNewEntity) return false;
+		await this.load();
+		return this.get.includes(code);
+	}
+	removeAll() {
+		require_index.ensureNotDeleted(this.entity);
+		if (!this.#loaded) throw new Error("removeAll was called when not loaded");
+		for (const code of [...this.get]) this.remove(code);
+	}
+	get get() {
+		require_index.ensureNotDeleted(this.entity, "pending");
+		if (!this.#loaded) throw new Error(`${this.entity}.${this.fieldName}.get was called when not loaded`);
+		return this.#codesFor(this.entity);
+	}
+	get isLoaded() {
+		return this.#loaded;
+	}
+	get isPreloaded() {
+		return this.#getPreloaded() !== void 0;
+	}
+	preload() {
+		if (this.#getPreloaded() !== void 0) this.#loaded = true;
+	}
+	setFromOpts(codes) {
+		this.#loaded = true;
+		for (const code of codes ?? []) this.add(code);
+	}
+	/**
+	* Mirrors `other`'s codes into us for `em.fork`/`importEntity`.
+	*
+	* Enum codes have no entity identity to remap, and we copy them as already-persisted rows (not
+	* pending adds) so the receiving em doesn't think it has spurious inserts to flush.
+	*/
+	import(other) {
+		if (!other.isLoaded) return;
+		this.#loaded = true;
+		for (const code of other.get) this.#joinRows.addPreloadedRow(this, void 0, this.entity, this.#idOf(code));
+	}
+	maybeCascadeDelete() {}
+	async cleanupOnEntityDeleted() {
+		this.#joinRows.removeAllFor(this.columnName, this.entity);
+	}
+	get fieldName() {
+		return this.#field.fieldName;
+	}
+	get hasBeenSet() {
+		return this.#hasBeenSet;
+	}
+	toString() {
+		return `EnumCollection(entity: ${this.entity}, fieldName: ${this.fieldName}, enum: ${this.#field.enumDetailType.name})`;
+	}
+	#applySet(codes) {
+		const current = this.get;
+		for (const code of current) if (!codes.includes(code)) this.remove(code);
+		for (const code of codes) if (!current.includes(code)) this.add(code);
+	}
+	/** The current (non-deleted) codes for `entity`, sorted by enum id for a stable order. */
+	#codesFor(entity) {
+		return this.#joinRows.getOthers(this.columnName, entity).sort((a, b) => a - b).map((id) => this.#field.enumDetailType.findById(id).code);
+	}
+	#idOf(code) {
+		return this.#field.enumDetailType.getByCode(code).id;
+	}
+	#getPreloaded() {
+		if (this.entity.isNewEntity) return void 0;
+		return require_EntityManager.getEmInternalApi(this.entity.em).getPreloadedRelation(this.entity.idTagged, this.fieldName);
+	}
+	get #joinRows() {
+		return require_EntityManager.getEmInternalApi(this.entity.em).joinRows(this);
+	}
+	get joinTableName() {
+		return this.#field.joinTableName;
+	}
+	get columnName() {
+		return this.#field.columnNames[0];
+	}
+	get otherColumnName() {
+		return this.#field.columnNames[1];
+	}
+	get meta() {
+		return require_EntityMetadata.getMetadataForField(require_EntityMetadata.getMetadata(this.entity), this.#field.fieldName);
+	}
+	get otherEnum() {
+		return this.#field.enumDetailType;
+	}
+	get otherMeta() {}
+	get otherFieldName() {}
+	get hasJoinTableId() {
+		return this.#field.hasJoinTableId;
+	}
+	[require_relations_RelationSymbols.RelationT] = null;
+	[require_relations_RelationSymbols.RelationU] = null;
+};
+//#endregion
+exports.EnumCollectionImpl = EnumCollectionImpl;
+exports.hasEnumCollection = hasEnumCollection;
+
+//# sourceMappingURL=EnumCollection.cjs.map

package/build/relations/EnumCollection.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnumCollection.cjs","names":["lazyField","getMetadata","AbstractRelationImpl","#field","#loaded","getInstanceData","#getPreloaded","#loadPromise","enumCollectionBatchLoader","appendStack","#pendingSet","#applySet","#joinRows","#idOf","#hasBeenSet","#codesFor","getEmInternalApi","getMetadataForField","RelationT","RelationU"],"sources":["../../src/relations/EnumCollection.ts"],"sourcesContent":["import { enumCollectionBatchLoader } from \"src/batchloaders/enumCollectionBatchLoader.ts\";\nimport { type EnumMetadata } from \"src/EnumMetadata.ts\";\nimport {\n  type Entity,\n  type EntityMetadata,\n  type ManyToManyEnumField,\n  type ManyToManyLike,\n  appendStack,\n  ensureNotDeleted,\n  getEmInternalApi,\n  getInstanceData,\n  getMetadata,\n  getMetadataForField,\n} from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractRelationImpl } from \"src/relations/AbstractRelationImpl.ts\";\nimport { RelationT, RelationU } from \"src/relations/RelationSymbols.ts\";\nimport { remove } from \"src/utils.ts\";\n\n/** A nominal brand so `EnumCollection` is not structurally confused with a regular `Collection`. */\ndeclare const enumCollectionTag: unique symbol;\n\n/**\n * A collection of enum codes `E` within `T`, backed by a m2m join table to an enum \"table\".\n *\n * To the user it looks like an array of enum codes (e.g. `Color[]`), but unlike an enum-array\n * column it is lazy and so needs a load hint, like any other relation.\n */\nexport interface EnumCollection<T extends Entity, E> {\n  [enumCollectionTag]: true;\n  [RelationT]: T;\n  [RelationU]: E;\n\n  load(opts?: { forceReload?: boolean }): Promise<ReadonlyArray<E>>;\n\n  add(code: E): void;\n\n  remove(code: E): void;\n\n  /**\n   * Sets the collection to `codes`.\n   *\n   * Can be called on unloaded collections - the diff will be resolved at load or flush time.\n   */\n  set(codes: readonly E[]): void;\n\n  includes(code: E): Promise<boolean>;\n\n  readonly isLoaded: boolean;\n  readonly entity: Entity;\n  readonly hasBeenSet: boolean;\n}\n\n/** Adds a known-safe `get` accessor. */\nexport interface LoadedEnumCollection<T extends Entity, E> extends EnumCollection<T, E> {\n  get: ReadonlyArray<E>;\n\n  removeAll(): void;\n}\n\n/** An alias for creating `EnumCollection`s. */\nexport function hasEnumCollection<T extends Entity, E>(): EnumCollection<T, E> {\n  return lazyField((entity: T, fieldName) => {\n    const field = getMetadata(entity).allFields[fieldName] as ManyToManyEnumField;\n    return new EnumCollectionImpl<T, E>(entity, field);\n  });\n}\n\nexport class EnumCollectionImpl<T extends Entity, E>\n  extends AbstractRelationImpl<T, E[]>\n  implements EnumCollection<T, E>, LoadedEnumCollection<T, E>, ManyToManyLike\n{\n  readonly #field: ManyToManyEnumField;\n  #loaded: boolean;\n  #loadPromise: any;\n  #hasBeenSet = false;\n  /** Holds a pending `set()` when called on an unloaded collection, resolved at load. */\n  #pendingSet: E[] | undefined;\n\n  constructor(entity: T, field: ManyToManyEnumField) {\n    super(entity);\n    this.#field = field;\n    this.#loaded = getInstanceData(entity).isOrWasNew;\n  }\n\n  async load(opts: { forceReload?: boolean } = {}): Promise<ReadonlyArray<E>> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.#loaded || (opts.forceReload && !this.entity.isNewEntity)) {\n      if (this.#getPreloaded() !== undefined) {\n        this.#loaded = true;\n      } else {\n        await (this.#loadPromise ??= enumCollectionBatchLoader(this.entity.em, this).load(this.entity.idTagged!))\n          .then(() => {\n            this.#loaded = true;\n          })\n          .catch(function load(err: any) {\n            throw appendStack(err, new Error());\n          })\n          .finally(() => {\n            this.#loadPromise = undefined;\n          });\n      }\n      if (this.#pendingSet) {\n        const pending = this.#pendingSet;\n        this.#pendingSet = undefined;\n        this.#applySet(pending);\n      }\n    }\n    return this.get;\n  }\n\n  add(code: E): void {\n    ensureNotDeleted(this.entity);\n    if (this.#pendingSet) {\n      if (!this.#pendingSet.includes(code)) this.#pendingSet.push(code);\n      return;\n    }\n    if (this.#loaded && this.get.includes(code)) return;\n    this.#joinRows.addNew(this, this.entity, this.#idOf(code));\n  }\n\n  remove(code: E): void {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (this.#pendingSet) {\n      remove(this.#pendingSet, code);\n      return;\n    }\n    this.#joinRows.addRemove(this, this.entity, this.#idOf(code));\n  }\n\n  set(codes: readonly E[]): void {\n    ensureNotDeleted(this.entity);\n    this.#hasBeenSet = true;\n    if (!this.#loaded) {\n      this.#pendingSet = [...codes];\n      getEmInternalApi(this.entity.em).pendingLoads.add(this as any);\n      return;\n    }\n    this.#applySet(codes);\n  }\n\n  async includes(code: E): Promise<boolean> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (this.#pendingSet) return this.#pendingSet.includes(code);\n    if (this.#loaded) return this.get.includes(code);\n    if (this.entity.isNewEntity) return false;\n    await this.load();\n    return this.get.includes(code);\n  }\n\n  removeAll(): void {\n    ensureNotDeleted(this.entity);\n    if (!this.#loaded) throw new Error(\"removeAll was called when not loaded\");\n    for (const code of [...this.get]) this.remove(code);\n  }\n\n  get get(): E[] {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.#loaded) {\n      throw new Error(`${this.entity}.${this.fieldName}.get was called when not loaded`);\n    }\n    return this.#codesFor(this.entity);\n  }\n\n  get isLoaded(): boolean {\n    return this.#loaded;\n  }\n\n  get isPreloaded(): boolean {\n    return this.#getPreloaded() !== undefined;\n  }\n\n  preload(): void {\n    if (this.#getPreloaded() !== undefined) this.#loaded = true;\n  }\n\n  setFromOpts(codes: E[]): void {\n    this.#loaded = true;\n    for (const code of codes ?? []) this.add(code);\n  }\n\n  /**\n   * Mirrors `other`'s codes into us for `em.fork`/`importEntity`.\n   *\n   * Enum codes have no entity identity to remap, and we copy them as already-persisted rows (not\n   * pending adds) so the receiving em doesn't think it has spurious inserts to flush.\n   */\n  import(other: EnumCollectionImpl<T, E>): void {\n    if (!other.isLoaded) return;\n    this.#loaded = true;\n    for (const code of other.get) {\n      this.#joinRows.addPreloadedRow(this, undefined, this.entity, this.#idOf(code));\n    }\n  }\n\n  maybeCascadeDelete(): void {\n    // The join table FK cascades on the db side, so there's nothing to cascade in memory.\n  }\n\n  async cleanupOnEntityDeleted(): Promise<void> {\n    // The db cascade-deletes our join rows, so just drop any pending in-memory changes for us.\n    this.#joinRows.removeAllFor(this.columnName, this.entity);\n  }\n\n  get fieldName(): string {\n    return this.#field.fieldName;\n  }\n\n  get hasBeenSet(): boolean {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `EnumCollection(entity: ${this.entity}, fieldName: ${this.fieldName}, enum: ${this.#field.enumDetailType.name})`;\n  }\n\n  #applySet(codes: readonly E[]): void {\n    const current = this.get;\n    for (const code of current) if (!codes.includes(code)) this.remove(code);\n    for (const code of codes) if (!current.includes(code)) this.add(code);\n  }\n\n  /** The current (non-deleted) codes for `entity`, sorted by enum id for a stable order. */\n  #codesFor(entity: Entity): E[] {\n    return (this.#joinRows.getOthers(this.columnName, entity) as number[])\n      .sort((a, b) => a - b)\n      .map((id) => this.#field.enumDetailType.findById(id)!.code as E);\n  }\n\n  #idOf(code: E): number {\n    return this.#field.enumDetailType.getByCode(code).id;\n  }\n\n  #getPreloaded(): E[] | undefined {\n    if (this.entity.isNewEntity) return undefined;\n    return getEmInternalApi(this.entity.em).getPreloadedRelation<E>(this.entity.idTagged, this.fieldName);\n  }\n\n  get #joinRows() {\n    return getEmInternalApi(this.entity.em).joinRows(this);\n  }\n\n  // The `ManyToManyLike` surface, so JoinRows/batch loaders can use us directly. There is no\n  // `otherMeta`/`otherFieldName` because the \"other\" side is an enum table, not an entity.\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 meta(): EntityMetadata {\n    return getMetadataForField(getMetadata(this.entity), this.#field.fieldName);\n  }\n\n  get otherEnum(): EnumMetadata<any, any, number> {\n    return this.#field.enumDetailType;\n  }\n\n  get otherMeta(): undefined {\n    return undefined;\n  }\n\n  get otherFieldName(): undefined {\n    return undefined;\n  }\n\n  get hasJoinTableId(): boolean {\n    return this.#field.hasJoinTableId;\n  }\n\n  declare [enumCollectionTag]: true;\n  [RelationT]: T = null!;\n  [RelationU]: E = null!;\n}\n"],"mappings":"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"}

package/build/relations/EnumCollection.d.cts

@@ -0,0 +1,86 @@
+import { AbstractRelationImpl } from "./AbstractRelationImpl.cjs";
+import { RelationT, RelationU } from "./RelationSymbols.cjs";
+import { EnumMetadata } from "../EnumMetadata.cjs";
+import { ManyToManyLike } from "../flush/JoinRows.cjs";
+import { EntityMetadata, ManyToManyEnumField } from "../EntityMetadata.cjs";
+import "../index.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/relations/EnumCollection.d.ts
+/** A nominal brand so `EnumCollection` is not structurally confused with a regular `Collection`. */
+declare const enumCollectionTag: unique symbol;
+/**
+ * A collection of enum codes `E` within `T`, backed by a m2m join table to an enum "table".
+ *
+ * To the user it looks like an array of enum codes (e.g. `Color[]`), but unlike an enum-array
+ * column it is lazy and so needs a load hint, like any other relation.
+ */
+interface EnumCollection<T extends Entity, E> {
+  [enumCollectionTag]: true;
+  [RelationT]: T;
+  [RelationU]: E;
+  load(opts?: {
+    forceReload?: boolean;
+  }): Promise<ReadonlyArray<E>>;
+  add(code: E): void;
+  remove(code: E): void;
+  /**
+   * Sets the collection to `codes`.
+   *
+   * Can be called on unloaded collections - the diff will be resolved at load or flush time.
+   */
+  set(codes: readonly E[]): void;
+  includes(code: E): Promise<boolean>;
+  readonly isLoaded: boolean;
+  readonly entity: Entity;
+  readonly hasBeenSet: boolean;
+}
+/** Adds a known-safe `get` accessor. */
+interface LoadedEnumCollection<T extends Entity, E> extends EnumCollection<T, E> {
+  get: ReadonlyArray<E>;
+  removeAll(): void;
+}
+/** An alias for creating `EnumCollection`s. */
+declare function hasEnumCollection<T extends Entity, E>(): EnumCollection<T, E>;
+declare class EnumCollectionImpl<T extends Entity, E> extends AbstractRelationImpl<T, E[]> implements EnumCollection<T, E>, LoadedEnumCollection<T, E>, ManyToManyLike {
+  #private;
+  constructor(entity: T, field: ManyToManyEnumField);
+  load(opts?: {
+    forceReload?: boolean;
+  }): Promise<ReadonlyArray<E>>;
+  add(code: E): void;
+  remove(code: E): void;
+  set(codes: readonly E[]): void;
+  includes(code: E): Promise<boolean>;
+  removeAll(): void;
+  get get(): E[];
+  get isLoaded(): boolean;
+  get isPreloaded(): boolean;
+  preload(): void;
+  setFromOpts(codes: E[]): void;
+  /**
+   * Mirrors `other`'s codes into us for `em.fork`/`importEntity`.
+   *
+   * Enum codes have no entity identity to remap, and we copy them as already-persisted rows (not
+   * pending adds) so the receiving em doesn't think it has spurious inserts to flush.
+   */
+  import(other: EnumCollectionImpl<T, E>): void;
+  maybeCascadeDelete(): void;
+  cleanupOnEntityDeleted(): Promise<void>;
+  get fieldName(): string;
+  get hasBeenSet(): boolean;
+  toString(): string;
+  get joinTableName(): string;
+  get columnName(): string;
+  get otherColumnName(): string;
+  get meta(): EntityMetadata;
+  get otherEnum(): EnumMetadata<any, any, number>;
+  get otherMeta(): undefined;
+  get otherFieldName(): undefined;
+  get hasJoinTableId(): boolean;
+  [enumCollectionTag]: true;
+  [RelationT]: T;
+  [RelationU]: E;
+}
+//#endregion
+export { EnumCollection, EnumCollectionImpl, LoadedEnumCollection, hasEnumCollection };
+//# sourceMappingURL=EnumCollection.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EnumCollection.d.cts","names":[],"sources":["../../src/relations/EnumCollection.ts"],"mappings":";;;;;;;;;cAoBc;;;;;;;UAQG,eAAe,UAAU,QAAQ;GAC/C;GACA,YAAY;GACZ,YAAY;EAEb,KAAK;IAAS;MAA0B,QAAQ,cAAc;EAE9D,IAAI,MAAM;EAEV,OAAO,MAAM;;;;;;EAOb,IAAI,gBAAgB;EAEpB,SAAS,MAAM,IAAI;WAEV;WACA,QAAQ;WACR;;;UAIM,qBAAqB,UAAU,QAAQ,WAAW,eAAe,GAAG;EACnF,KAAK,cAAc;EAEnB;;;iBAIc,kBAAkB,UAAU,QAAQ,MAAM,eAAe,GAAG;cAO/D,mBAAmB,UAAU,QAAQ,WACxC,qBAAqB,GAAG,gBACrB,eAAe,GAAG,IAAI,qBAAqB,GAAG,IAAI;;EAS7D,YAAY,QAAQ,GAAG,OAAO;EAMxB,KAAK;IAAQ;MAA+B,QAAQ,cAAc;EA0BxE,IAAI,MAAM;EAUV,OAAO,MAAM;EASb,IAAI,gBAAgB;EAWd,SAAS,MAAM,IAAI;EASzB;MAMI,OAAO;MAQP;MAIA;EAIJ;EAIA,YAAY,OAAO;;;;;;;EAWnB,OAAO,OAAO,mBAAmB,GAAG;EAQpC;EAIM,0BAA0B;MAK5B;MAIA;EAIJ;MAiCI;MAIA;MAIA;MAIA,QAAQ;MAIR,aAAa;MAIb;MAIA;MAIA;GAIK;GACR,YAAY;GACZ,YAAY"}

package/build/relations/EnumCollection.d.mts

@@ -0,0 +1,86 @@
+import { AbstractRelationImpl } from "./AbstractRelationImpl.mjs";
+import { RelationT, RelationU } from "./RelationSymbols.mjs";
+import { EnumMetadata } from "../EnumMetadata.mjs";
+import { ManyToManyLike } from "../flush/JoinRows.mjs";
+import { EntityMetadata, ManyToManyEnumField } from "../EntityMetadata.mjs";
+import "../index.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/relations/EnumCollection.d.ts
+/** A nominal brand so `EnumCollection` is not structurally confused with a regular `Collection`. */
+declare const enumCollectionTag: unique symbol;
+/**
+ * A collection of enum codes `E` within `T`, backed by a m2m join table to an enum "table".
+ *
+ * To the user it looks like an array of enum codes (e.g. `Color[]`), but unlike an enum-array
+ * column it is lazy and so needs a load hint, like any other relation.
+ */
+interface EnumCollection<T extends Entity, E> {
+  [enumCollectionTag]: true;
+  [RelationT]: T;
+  [RelationU]: E;
+  load(opts?: {
+    forceReload?: boolean;
+  }): Promise<ReadonlyArray<E>>;
+  add(code: E): void;
+  remove(code: E): void;
+  /**
+   * Sets the collection to `codes`.
+   *
+   * Can be called on unloaded collections - the diff will be resolved at load or flush time.
+   */
+  set(codes: readonly E[]): void;
+  includes(code: E): Promise<boolean>;
+  readonly isLoaded: boolean;
+  readonly entity: Entity;
+  readonly hasBeenSet: boolean;
+}
+/** Adds a known-safe `get` accessor. */
+interface LoadedEnumCollection<T extends Entity, E> extends EnumCollection<T, E> {
+  get: ReadonlyArray<E>;
+  removeAll(): void;
+}
+/** An alias for creating `EnumCollection`s. */
+declare function hasEnumCollection<T extends Entity, E>(): EnumCollection<T, E>;
+declare class EnumCollectionImpl<T extends Entity, E> extends AbstractRelationImpl<T, E[]> implements EnumCollection<T, E>, LoadedEnumCollection<T, E>, ManyToManyLike {
+  #private;
+  constructor(entity: T, field: ManyToManyEnumField);
+  load(opts?: {
+    forceReload?: boolean;
+  }): Promise<ReadonlyArray<E>>;
+  add(code: E): void;
+  remove(code: E): void;
+  set(codes: readonly E[]): void;
+  includes(code: E): Promise<boolean>;
+  removeAll(): void;
+  get get(): E[];
+  get isLoaded(): boolean;
+  get isPreloaded(): boolean;
+  preload(): void;
+  setFromOpts(codes: E[]): void;
+  /**
+   * Mirrors `other`'s codes into us for `em.fork`/`importEntity`.
+   *
+   * Enum codes have no entity identity to remap, and we copy them as already-persisted rows (not
+   * pending adds) so the receiving em doesn't think it has spurious inserts to flush.
+   */
+  import(other: EnumCollectionImpl<T, E>): void;
+  maybeCascadeDelete(): void;
+  cleanupOnEntityDeleted(): Promise<void>;
+  get fieldName(): string;
+  get hasBeenSet(): boolean;
+  toString(): string;
+  get joinTableName(): string;
+  get columnName(): string;
+  get otherColumnName(): string;
+  get meta(): EntityMetadata;
+  get otherEnum(): EnumMetadata<any, any, number>;
+  get otherMeta(): undefined;
+  get otherFieldName(): undefined;
+  get hasJoinTableId(): boolean;
+  [enumCollectionTag]: true;
+  [RelationT]: T;
+  [RelationU]: E;
+}
+//#endregion
+export { EnumCollection, EnumCollectionImpl, LoadedEnumCollection, hasEnumCollection };
+//# sourceMappingURL=EnumCollection.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EnumCollection.d.mts","names":[],"sources":["../../src/relations/EnumCollection.ts"],"mappings":";;;;;;;;;cAoBc;;;;;;;UAQG,eAAe,UAAU,QAAQ;GAC/C;GACA,YAAY;GACZ,YAAY;EAEb,KAAK;IAAS;MAA0B,QAAQ,cAAc;EAE9D,IAAI,MAAM;EAEV,OAAO,MAAM;;;;;;EAOb,IAAI,gBAAgB;EAEpB,SAAS,MAAM,IAAI;WAEV;WACA,QAAQ;WACR;;;UAIM,qBAAqB,UAAU,QAAQ,WAAW,eAAe,GAAG;EACnF,KAAK,cAAc;EAEnB;;;iBAIc,kBAAkB,UAAU,QAAQ,MAAM,eAAe,GAAG;cAO/D,mBAAmB,UAAU,QAAQ,WACxC,qBAAqB,GAAG,gBACrB,eAAe,GAAG,IAAI,qBAAqB,GAAG,IAAI;;EAS7D,YAAY,QAAQ,GAAG,OAAO;EAMxB,KAAK;IAAQ;MAA+B,QAAQ,cAAc;EA0BxE,IAAI,MAAM;EAUV,OAAO,MAAM;EASb,IAAI,gBAAgB;EAWd,SAAS,MAAM,IAAI;EASzB;MAMI,OAAO;MAQP;MAIA;EAIJ;EAIA,YAAY,OAAO;;;;;;;EAWnB,OAAO,OAAO,mBAAmB,GAAG;EAQpC;EAIM,0BAA0B;MAK5B;MAIA;EAIJ;MAiCI;MAIA;MAIA;MAIA,QAAQ;MAIR,aAAa;MAIb;MAIA;MAIA;GAIK;GACR,YAAY;GACZ,YAAY"}