joist-core 2.4.0-next.4 → 2.4.0-next.41

package/build/relations/AsyncReactiveField.js.map

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

package/build/relations/Collection.d.cts

@@ -4,7 +4,7 @@ import { IdOf } from "../EntityManager.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/Collection.d.ts
 /** A collection of `U` within `T`, either one-to-many or many-to-many. */
-interface Collection<T extends Entity, U extends Entity> extends Relation<T, U> {
+export interface Collection<T extends Entity, U extends Entity> extends Relation<T, U> {
   load(opts?: {
     withDeleted: boolean;
   }): Promise<ReadonlyArray<U>>;
@@ -23,15 +23,14 @@ interface Collection<T extends Entity, U extends Entity> extends Relation<T, U>
   readonly isLoaded: boolean;
 }
 /** Adds a known-safe `get` accessor. */
-interface LoadedCollection<T extends Entity, U extends Entity> extends Collection<T, U> {
+export interface LoadedCollection<T extends Entity, U extends Entity> extends Collection<T, U> {
   get: ReadonlyArray<U>;
   getWithDeleted: ReadonlyArray<U>;
   removeAll(): void;
 }
 /** Type guard utility for determining if an entity field is a Collection. */
-declare function isCollection(maybeCollection: any): maybeCollection is Collection<any, any>;
+export declare function isCollection(maybeCollection: any): maybeCollection is Collection<any, any>;
 /** Type guard utility for determining if an entity field is a loaded Collection. */
-declare function isLoadedCollection(maybeCollection: any): maybeCollection is Collection<any, any> & LoadedCollection<any, any>;
+export declare function isLoadedCollection(maybeCollection: any): maybeCollection is Collection<any, any> & LoadedCollection<any, any>;
 //#endregion
-export { Collection, LoadedCollection, isCollection, isLoadedCollection };
 //# sourceMappingURL=Collection.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Collection.d.cts","names":[],"sources":["../../src/relations/Collection.ts"],"mappings":";;;;;;UAYiB,WAAW,UAAU,QAAQ,UAAU,gBAAgB,SAAS,GAAG;EAClF,KAAK;IAAS;MAAyB,QAAQ,cAAc;;EAG7D,KAAK,IAAI,KAAK,KAAK,QAAQ;;EAG3B,SAAS,OAAO,IAAI;EAEpB,IAAI,OAAO;EAEX,OAAO,OAAO;;;;;;EAOd,IAAI,QAAQ;WAEH;;;UAIM,iBAAiB,UAAU,QAAQ,UAAU,gBAAgB,WAAW,GAAG;EAC1F,KAAK,cAAc;EAEnB,gBAAgB,cAAc;EAE9B;;;iBAIc,aAAa,uBAAuB,mBAAmB;;iBAWvD,mBACd,uBACC,mBAAmB,uBAAuB"}
+{"version":3,"file":"Collection.d.cts","names":[],"sources":["../../src/relations/Collection.ts"],"mappings":";;;;;;iBAYiB,WAAW,UAAU,QAAQ,UAAU,gBAAgB,SAAS,GAAG;EAClF,KAAK;IAAS;MAAyB,QAAQ,cAAc;;EAG7D,KAAK,IAAI,KAAK,KAAK,QAAQ;;EAG3B,SAAS,OAAO,IAAI;EAEpB,IAAI,OAAO;EAEX,OAAO,OAAO;;;;;;EAOd,IAAI,QAAQ;WAEH;;;iBAIM,iBAAiB,UAAU,QAAQ,UAAU,gBAAgB,WAAW,GAAG;EAC1F,KAAK,cAAc;EAEnB,gBAAgB,cAAc;EAE9B;;;wBAIc,aAAa,uBAAuB,mBAAmB;;wBAWvD,mBACd,uBACC,mBAAmB,uBAAuB"}

package/build/relations/Collection.d.mts

@@ -4,7 +4,7 @@ import { IdOf } from "../EntityManager.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/Collection.d.ts
 /** A collection of `U` within `T`, either one-to-many or many-to-many. */
-interface Collection<T extends Entity, U extends Entity> extends Relation<T, U> {
+export interface Collection<T extends Entity, U extends Entity> extends Relation<T, U> {
   load(opts?: {
     withDeleted: boolean;
   }): Promise<ReadonlyArray<U>>;
@@ -23,15 +23,14 @@ interface Collection<T extends Entity, U extends Entity> extends Relation<T, U>
   readonly isLoaded: boolean;
 }
 /** Adds a known-safe `get` accessor. */
-interface LoadedCollection<T extends Entity, U extends Entity> extends Collection<T, U> {
+export interface LoadedCollection<T extends Entity, U extends Entity> extends Collection<T, U> {
   get: ReadonlyArray<U>;
   getWithDeleted: ReadonlyArray<U>;
   removeAll(): void;
 }
 /** Type guard utility for determining if an entity field is a Collection. */
-declare function isCollection(maybeCollection: any): maybeCollection is Collection<any, any>;
+export declare function isCollection(maybeCollection: any): maybeCollection is Collection<any, any>;
 /** Type guard utility for determining if an entity field is a loaded Collection. */
-declare function isLoadedCollection(maybeCollection: any): maybeCollection is Collection<any, any> & LoadedCollection<any, any>;
+export declare function isLoadedCollection(maybeCollection: any): maybeCollection is Collection<any, any> & LoadedCollection<any, any>;
 //#endregion
-export { Collection, LoadedCollection, isCollection, isLoadedCollection };
 //# sourceMappingURL=Collection.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Collection.d.mts","names":[],"sources":["../../src/relations/Collection.ts"],"mappings":";;;;;;UAYiB,WAAW,UAAU,QAAQ,UAAU,gBAAgB,SAAS,GAAG;EAClF,KAAK;IAAS;MAAyB,QAAQ,cAAc;;EAG7D,KAAK,IAAI,KAAK,KAAK,QAAQ;;EAG3B,SAAS,OAAO,IAAI;EAEpB,IAAI,OAAO;EAEX,OAAO,OAAO;;;;;;EAOd,IAAI,QAAQ;WAEH;;;UAIM,iBAAiB,UAAU,QAAQ,UAAU,gBAAgB,WAAW,GAAG;EAC1F,KAAK,cAAc;EAEnB,gBAAgB,cAAc;EAE9B;;;iBAIc,aAAa,uBAAuB,mBAAmB;;iBAWvD,mBACd,uBACC,mBAAmB,uBAAuB"}
+{"version":3,"file":"Collection.d.mts","names":[],"sources":["../../src/relations/Collection.ts"],"mappings":";;;;;;iBAYiB,WAAW,UAAU,QAAQ,UAAU,gBAAgB,SAAS,GAAG;EAClF,KAAK;IAAS;MAAyB,QAAQ,cAAc;;EAG7D,KAAK,IAAI,KAAK,KAAK,QAAQ;;EAG3B,SAAS,OAAO,IAAI;EAEpB,IAAI,OAAO;EAEX,OAAO,OAAO;;;;;;EAOd,IAAI,QAAQ;WAEH;;;iBAIM,iBAAiB,UAAU,QAAQ,UAAU,gBAAgB,WAAW,GAAG;EAC1F,KAAK,cAAc;EAEnB,gBAAgB,cAAc;EAE9B;;;wBAIc,aAAa,uBAAuB,mBAAmB;;wBAWvD,mBACd,uBACC,mBAAmB,uBAAuB"}

package/build/relations/CustomCollection.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"CustomCollection.cjs","names":["lazyField","AbstractRelationImpl","#isLoaded","#loadHint","#hasBeenSet","RelationT","RelationU"],"sources":["../../src/relations/CustomCollection.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type IdOf, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type Collection, type LoadHint, ensureNotDeleted, fail } 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\";\n\nexport type CustomCollectionOpts<T extends Entity, U extends Entity> = {\n  // We purposefully don't capture the return value of `load` b/c we want `get` to re-calc from `entity`\n  // each time it's invoked so that it reflects any changed values.\n  load: (entity: T, opts: { forceReload?: boolean }) => Promise<any>;\n  get: (entity: T) => readonly U[];\n  set?: (entity: T, other: U[]) => void;\n  find?: (entity: T, id: IdOf<U>) => U | undefined;\n  add?: (entity: T, other: U) => void;\n  remove?: (entity: T, other: U) => void;\n  /** Whether the reference is loaded, even w/o an explicit `.load` call, i.e. for DeepNew test instances. */\n  isLoaded: (entity: T) => boolean;\n  /**\n   * A load hint that can be used to speculatively traverse the dependencies of this collection.  Currently\n   * only used by em.importEntity and can be omitted if the collection isn't used with it.\n   */\n  loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;\n};\n\nexport function hasCustomCollection<T extends Entity, U extends Entity>(\n  opts: CustomCollectionOpts<T, U>,\n): CustomCollection<T, U> {\n  return lazyField((entity: T) => {\n    return new CustomCollection<T, U>(entity, opts);\n  });\n}\n\n/**\n * Allows user-defined collections that will work in `populate` / preload hints.\n *\n * This works because Joist's `populate`/preloading is not based on creating giant SQL joins,\n * but instead by just walking \"1 dataloader per level\". Given this, we don't really care\n * what happens at each \"level\" of resolution, as long as: a) it's a promise, and b) the\n * caller uses dataloader to be batch friendly.\n *\n * This `CustomCollection` API is fairly low-level; users should more likely prefer higher-level\n * abstractions like `hasManyThrough`, which are built on `CustomCollection`.\n */\nexport class CustomCollection<T extends Entity, U extends Entity>\n  extends AbstractRelationImpl<T, readonly U[]>\n  implements Collection<T, U>\n{\n  // We keep both a promise+loaded flag and not an actual `this.loaded = await load` because\n  // the values can become stale; we want to each `.get` call to repeatedly evaluate the latest values.\n  private loadPromise: Promise<any> | undefined;\n  #hasBeenSet = false;\n  #isLoaded: boolean | undefined = undefined;\n  #loadHint: LoadHint<T> | undefined;\n\n  constructor(\n    entity: T,\n    private opts: CustomCollectionOpts<T, U>,\n  ) {\n    super(entity);\n  }\n\n  get get(): readonly U[] {\n    return this.doGet({ withDeleted: false });\n  }\n\n  get getWithDeleted(): readonly U[] {\n    return this.doGet({ withDeleted: true });\n  }\n\n  get isLoaded(): boolean {\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.addNaive(this);\n    this.#isLoaded = this.opts.isLoaded(this.entity);\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n  }\n\n  get loadHint(): LoadHint<T> | undefined {\n    if (this.#loadHint === undefined && this.opts.loadHint !== undefined) {\n      const { loadHint } = this.opts;\n      this.#loadHint = typeof loadHint === \"function\" ? loadHint(this.entity) : loadHint;\n    }\n    return this.#loadHint;\n  }\n\n  async load(opts: { withDeleted?: boolean; forceReload?: boolean } = {}): Promise<readonly U[]> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.isLoaded || opts.forceReload) {\n      if (this.loadPromise === undefined) {\n        this.loadPromise = this.opts.load(this.entity, opts);\n        await this.loadPromise;\n        this.loadPromise = undefined;\n        this.#isLoaded = true;\n      } else {\n        await this.loadPromise;\n      }\n    }\n    return this.doGet(opts);\n  }\n\n  get isPreloaded(): boolean {\n    return false;\n  }\n\n  preload(): void {\n    throw new Error(\"Not implemented\");\n  }\n\n  set(values: U[]): void {\n    this.ensureNewOrLoaded();\n    const { set, add, remove } = this.opts;\n    if (set !== undefined) {\n      set(this.entity, values);\n      this.#hasBeenSet = true;\n    } else if (add !== undefined && remove !== undefined) {\n      const current = this.get;\n      current.filter((value) => !values.includes(value)).forEach((value) => this.remove(value));\n      values.filter((value) => !current.includes(value)).forEach((value) => this.add(value));\n      this.#hasBeenSet = true;\n    } else {\n      fail(`'set' not implemented and not inferrable from 'add'/'remove' on ${this}`);\n    }\n  }\n\n  setFromOpts(values: U[]): void {\n    this.set(values);\n  }\n\n  async find(id: IdOf<U>): Promise<U | undefined> {\n    if (!this.isLoaded) {\n      await this.load();\n    }\n    const { find } = this.opts;\n    if (find === undefined) {\n      return this.doGet().find((other) => other.id === id);\n    } else {\n      return find(this.entity, id);\n    }\n  }\n\n  async includes(other: U): Promise<boolean> {\n    throw new Error(\"Not implemented\");\n  }\n\n  add(other: U): void {\n    this.ensureNewOrLoaded();\n    const { add } = this.opts;\n    if (add === undefined) {\n      fail(`'add' not implemented on ${this}`);\n    }\n    add(this.entity, other);\n  }\n\n  remove(other: U): void {\n    this.ensureNewOrLoaded();\n    const { remove } = this.opts;\n    if (remove === undefined) {\n      fail(`'add' not implemented on ${this}`);\n    }\n    remove(this.entity, other);\n  }\n\n  // these callbacks should be no-ops as they ought to be handled by the underlying relations\n  async cleanupOnEntityDeleted(): Promise<void> {}\n  maybeCascadeDelete(): void {}\n\n  /** Finds this CustomCollections field name by looking in the entity for the key that we're assigned to. */\n  get fieldName(): string {\n    // Something about running with the transformations breaks the `[0][0]` and it can NPE\n    return Object.entries(this.entity).filter((e) => e[1] === this)[0]?.[0];\n  }\n\n  get hasBeenSet() {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `CustomCollection(entity: ${this.entity}, fieldName: ${this.fieldName})`;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): readonly U[] {\n    ensureNotDeleted(this.entity, \"pending\");\n    this.ensureNewOrLoaded();\n    return this.filterDeleted(this.opts.get(this.entity), opts);\n  }\n\n  private filterDeleted(entities: readonly U[], opts?: { withDeleted?: boolean }): readonly U[] {\n    return entities.filter((entity) => opts?.withDeleted === true || !entity.isDeletedEntity);\n  }\n\n  private ensureNewOrLoaded() {\n    // This should only be callable in the type system if we've already resolved this to an instance\n    if (this.isLoaded) {\n      return;\n    }\n    fail(`${this.entity}.${this.fieldName} was not loaded`);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n}\n"],"mappings":"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"}
+{"version":3,"file":"CustomCollection.cjs","names":["lazyField","AbstractRelationImpl","RelationT","RelationU"],"sources":["../../src/relations/CustomCollection.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type IdOf, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type Collection, type LoadHint, ensureNotDeleted, fail } 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\";\n\nexport type CustomCollectionOpts<T extends Entity, U extends Entity> = {\n  // We purposefully don't capture the return value of `load` b/c we want `get` to re-calc from `entity`\n  // each time it's invoked so that it reflects any changed values.\n  load: (entity: T, opts: { forceReload?: boolean }) => Promise<any>;\n  get: (entity: T) => readonly U[];\n  set?: (entity: T, other: U[]) => void;\n  find?: (entity: T, id: IdOf<U>) => U | undefined;\n  add?: (entity: T, other: U) => void;\n  remove?: (entity: T, other: U) => void;\n  /** Whether the reference is loaded, even w/o an explicit `.load` call, i.e. for DeepNew test instances. */\n  isLoaded: (entity: T) => boolean;\n  /**\n   * A load hint that can be used to speculatively traverse the dependencies of this collection.  Currently\n   * only used by em.importEntity and can be omitted if the collection isn't used with it.\n   */\n  loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;\n};\n\nexport function hasCustomCollection<T extends Entity, U extends Entity>(\n  opts: CustomCollectionOpts<T, U>,\n): CustomCollection<T, U> {\n  return lazyField((entity: T) => {\n    return new CustomCollection<T, U>(entity, opts);\n  });\n}\n\n/**\n * Allows user-defined collections that will work in `populate` / preload hints.\n *\n * This works because Joist's `populate`/preloading is not based on creating giant SQL joins,\n * but instead by just walking \"1 dataloader per level\". Given this, we don't really care\n * what happens at each \"level\" of resolution, as long as: a) it's a promise, and b) the\n * caller uses dataloader to be batch friendly.\n *\n * This `CustomCollection` API is fairly low-level; users should more likely prefer higher-level\n * abstractions like `hasManyThrough`, which are built on `CustomCollection`.\n */\nexport class CustomCollection<T extends Entity, U extends Entity>\n  extends AbstractRelationImpl<T, readonly U[]>\n  implements Collection<T, U>\n{\n  // We keep both a promise+loaded flag and not an actual `this.loaded = await load` because\n  // the values can become stale; we want to each `.get` call to repeatedly evaluate the latest values.\n  private loadPromise: Promise<any> | undefined;\n  #hasBeenSet = false;\n  #isLoaded: boolean | undefined = undefined;\n  #loadHint: LoadHint<T> | undefined;\n\n  constructor(\n    entity: T,\n    private opts: CustomCollectionOpts<T, U>,\n  ) {\n    super(entity);\n  }\n\n  get get(): readonly U[] {\n    return this.doGet({ withDeleted: false });\n  }\n\n  get getWithDeleted(): readonly U[] {\n    return this.doGet({ withDeleted: true });\n  }\n\n  get isLoaded(): boolean {\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.addNaive(this);\n    this.#isLoaded = this.opts.isLoaded(this.entity);\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n  }\n\n  get loadHint(): LoadHint<T> | undefined {\n    if (this.#loadHint === undefined && this.opts.loadHint !== undefined) {\n      const { loadHint } = this.opts;\n      this.#loadHint = typeof loadHint === \"function\" ? loadHint(this.entity) : loadHint;\n    }\n    return this.#loadHint;\n  }\n\n  async load(opts: { withDeleted?: boolean; forceReload?: boolean } = {}): Promise<readonly U[]> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.isLoaded || opts.forceReload) {\n      if (this.loadPromise === undefined) {\n        this.loadPromise = this.opts.load(this.entity, opts);\n        await this.loadPromise;\n        this.loadPromise = undefined;\n        this.#isLoaded = true;\n      } else {\n        await this.loadPromise;\n      }\n    }\n    return this.doGet(opts);\n  }\n\n  get isPreloaded(): boolean {\n    return false;\n  }\n\n  preload(): void {\n    throw new Error(\"Not implemented\");\n  }\n\n  set(values: U[]): void {\n    this.ensureNewOrLoaded();\n    const { set, add, remove } = this.opts;\n    if (set !== undefined) {\n      set(this.entity, values);\n      this.#hasBeenSet = true;\n    } else if (add !== undefined && remove !== undefined) {\n      const current = this.get;\n      current.filter((value) => !values.includes(value)).forEach((value) => this.remove(value));\n      values.filter((value) => !current.includes(value)).forEach((value) => this.add(value));\n      this.#hasBeenSet = true;\n    } else {\n      fail(`'set' not implemented and not inferrable from 'add'/'remove' on ${this}`);\n    }\n  }\n\n  setFromOpts(values: U[]): void {\n    this.set(values);\n  }\n\n  async find(id: IdOf<U>): Promise<U | undefined> {\n    if (!this.isLoaded) {\n      await this.load();\n    }\n    const { find } = this.opts;\n    if (find === undefined) {\n      return this.doGet().find((other) => other.id === id);\n    } else {\n      return find(this.entity, id);\n    }\n  }\n\n  async includes(other: U): Promise<boolean> {\n    throw new Error(\"Not implemented\");\n  }\n\n  add(other: U): void {\n    this.ensureNewOrLoaded();\n    const { add } = this.opts;\n    if (add === undefined) {\n      fail(`'add' not implemented on ${this}`);\n    }\n    add(this.entity, other);\n  }\n\n  remove(other: U): void {\n    this.ensureNewOrLoaded();\n    const { remove } = this.opts;\n    if (remove === undefined) {\n      fail(`'add' not implemented on ${this}`);\n    }\n    remove(this.entity, other);\n  }\n\n  // these callbacks should be no-ops as they ought to be handled by the underlying relations\n  async cleanupOnEntityDeleted(): Promise<void> {}\n  maybeCascadeDelete(): void {}\n\n  /** Finds this CustomCollections field name by looking in the entity for the key that we're assigned to. */\n  get fieldName(): string {\n    // Something about running with the transformations breaks the `[0][0]` and it can NPE\n    return Object.entries(this.entity).filter((e) => e[1] === this)[0]?.[0];\n  }\n\n  get hasBeenSet() {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `CustomCollection(entity: ${this.entity}, fieldName: ${this.fieldName})`;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): readonly U[] {\n    ensureNotDeleted(this.entity, \"pending\");\n    this.ensureNewOrLoaded();\n    return this.filterDeleted(this.opts.get(this.entity), opts);\n  }\n\n  private filterDeleted(entities: readonly U[], opts?: { withDeleted?: boolean }): readonly U[] {\n    return entities.filter((entity) => opts?.withDeleted === true || !entity.isDeletedEntity);\n  }\n\n  private ensureNewOrLoaded() {\n    // This should only be callable in the type system if we've already resolved this to an instance\n    if (this.isLoaded) {\n      return;\n    }\n    fail(`${this.entity}.${this.fieldName} was not loaded`);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n}\n"],"mappings":"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"}

package/build/relations/CustomCollection.d.cts

@@ -6,7 +6,7 @@ import "../index.cjs";
 import { IdOf } from "../EntityManager.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/CustomCollection.d.ts
-type CustomCollectionOpts<T extends Entity, U extends Entity> = {
+export type CustomCollectionOpts<T extends Entity, U extends Entity> = {
   load: (entity: T, opts: {
     forceReload?: boolean;
   }) => Promise<any>;
@@ -23,7 +23,7 @@ type CustomCollectionOpts<T extends Entity, U extends Entity> = {
    */
   loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;
 };
-declare function hasCustomCollection<T extends Entity, U extends Entity>(opts: CustomCollectionOpts<T, U>): CustomCollection<T, U>;
+export declare function hasCustomCollection<T extends Entity, U extends Entity>(opts: CustomCollectionOpts<T, U>): CustomCollection<T, U>;
 /**
  * Allows user-defined collections that will work in `populate` / preload hints.
  *
@@ -35,7 +35,7 @@ declare function hasCustomCollection<T extends Entity, U extends Entity>(opts: C
  * This `CustomCollection` API is fairly low-level; users should more likely prefer higher-level
  * abstractions like `hasManyThrough`, which are built on `CustomCollection`.
  */
-declare class CustomCollection<T extends Entity, U extends Entity> extends AbstractRelationImpl<T, readonly U[]> implements Collection<T, U> {
+export declare class CustomCollection<T extends Entity, U extends Entity> extends AbstractRelationImpl<T, readonly U[]> implements Collection<T, U> {
   #private;
   private opts;
   private loadPromise;
@@ -70,5 +70,4 @@ declare class CustomCollection<T extends Entity, U extends Entity> extends Abstr
   [RelationU]: U;
 }
 //#endregion
-export { CustomCollection, CustomCollectionOpts, hasCustomCollection };
 //# sourceMappingURL=CustomCollection.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"CustomCollection.d.cts","names":[],"sources":["../../src/relations/CustomCollection.ts"],"mappings":";;;;;;;;KAOY,qBAAqB,UAAU,QAAQ,UAAU;EAG3D,OAAO,QAAQ,GAAG;IAAQ;QAA4B;EACtD,MAAM,QAAQ,eAAe;EAC7B,OAAO,QAAQ,GAAG,OAAO;EACzB,QAAQ,QAAQ,GAAG,IAAI,KAAK,OAAO;EACnC,OAAO,QAAQ,GAAG,OAAO;EACzB,UAAU,QAAQ,GAAG,OAAO;;EAE5B,WAAW,QAAQ;;;;;EAKnB,aAAa,QAAQ,MAAM,SAAS,MAAM,SAAS;;iBAGrC,oBAAoB,UAAU,QAAQ,UAAU,QAC9D,MAAM,qBAAqB,GAAG,KAC7B,iBAAiB,GAAG;;;;;;;;;;;;cAiBV,iBAAiB,UAAU,QAAQ,UAAU,gBAChD,qBAAqB,YAAY,gBAC9B,WAAW,GAAG;;UAWf;UAPF;EAKR,YACE,QAAQ,GACA,MAAM,qBAAqB,GAAG;MAKpC,gBAAgB;MAIhB,2BAA2B;MAI3B;EAOJ;MAII,YAAY,SAAS;EAQnB,KAAK;IAAQ;IAAuB;MAA+B,iBAAiB;MAetF;EAIJ;EAIA,IAAI,QAAQ;EAgBZ,YAAY,QAAQ;EAId,KAAK,IAAI,KAAK,KAAK,QAAQ;EAY3B,SAAS,OAAO,IAAI;EAI1B,IAAI,OAAO;EASX,OAAO,OAAO;EAUR,0BAA0B;EAChC;;MAGI;MAKA;EAIJ;UAIQ;UAMA;UAIA;GAQP,YAAY;GACZ,YAAY"}
+{"version":3,"file":"CustomCollection.d.cts","names":[],"sources":["../../src/relations/CustomCollection.ts"],"mappings":";;;;;;;;YAOY,qBAAqB,UAAU,QAAQ,UAAU;EAG3D,OAAO,QAAQ,GAAG;IAAQ;QAA4B;EACtD,MAAM,QAAQ,eAAe;EAC7B,OAAO,QAAQ,GAAG,OAAO;EACzB,QAAQ,QAAQ,GAAG,IAAI,KAAK,OAAO;EACnC,OAAO,QAAQ,GAAG,OAAO;EACzB,UAAU,QAAQ,GAAG,OAAO;;EAE5B,WAAW,QAAQ;;;;;EAKnB,aAAa,QAAQ,MAAM,SAAS,MAAM,SAAS;;wBAGrC,oBAAoB,UAAU,QAAQ,UAAU,QAC9D,MAAM,qBAAqB,GAAG,KAC7B,iBAAiB,GAAG;;;;;;;;;;;;qBAiBV,iBAAiB,UAAU,QAAQ,UAAU,gBAChD,qBAAqB,YAAY,gBAC9B,WAAW,GAAG;;UAWf;UAPF;EAKR,YACE,QAAQ,GACA,MAAM,qBAAqB,GAAG;MAKpC,gBAAgB;MAIhB,2BAA2B;MAI3B;EAOJ;MAII,YAAY,SAAS;EAQnB,KAAK;IAAQ;IAAuB;MAA+B,iBAAiB;MAetF;EAIJ;EAIA,IAAI,QAAQ;EAgBZ,YAAY,QAAQ;EAId,KAAK,IAAI,KAAK,KAAK,QAAQ;EAY3B,SAAS,OAAO,IAAI;EAI1B,IAAI,OAAO;EASX,OAAO,OAAO;EAUR,0BAA0B;EAChC;;MAGI;MAKA;EAIJ;UAIQ;UAMA;UAIA;GAQP,YAAY;GACZ,YAAY"}

package/build/relations/CustomCollection.d.mts

@@ -6,7 +6,7 @@ import "../index.mjs";
 import { IdOf } from "../EntityManager.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/CustomCollection.d.ts
-type CustomCollectionOpts<T extends Entity, U extends Entity> = {
+export type CustomCollectionOpts<T extends Entity, U extends Entity> = {
   load: (entity: T, opts: {
     forceReload?: boolean;
   }) => Promise<any>;
@@ -23,7 +23,7 @@ type CustomCollectionOpts<T extends Entity, U extends Entity> = {
    */
   loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;
 };
-declare function hasCustomCollection<T extends Entity, U extends Entity>(opts: CustomCollectionOpts<T, U>): CustomCollection<T, U>;
+export declare function hasCustomCollection<T extends Entity, U extends Entity>(opts: CustomCollectionOpts<T, U>): CustomCollection<T, U>;
 /**
  * Allows user-defined collections that will work in `populate` / preload hints.
  *
@@ -35,7 +35,7 @@ declare function hasCustomCollection<T extends Entity, U extends Entity>(opts: C
  * This `CustomCollection` API is fairly low-level; users should more likely prefer higher-level
  * abstractions like `hasManyThrough`, which are built on `CustomCollection`.
  */
-declare class CustomCollection<T extends Entity, U extends Entity> extends AbstractRelationImpl<T, readonly U[]> implements Collection<T, U> {
+export declare class CustomCollection<T extends Entity, U extends Entity> extends AbstractRelationImpl<T, readonly U[]> implements Collection<T, U> {
   #private;
   private opts;
   private loadPromise;
@@ -70,5 +70,4 @@ declare class CustomCollection<T extends Entity, U extends Entity> extends Abstr
   [RelationU]: U;
 }
 //#endregion
-export { CustomCollection, CustomCollectionOpts, hasCustomCollection };
 //# sourceMappingURL=CustomCollection.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"CustomCollection.d.mts","names":[],"sources":["../../src/relations/CustomCollection.ts"],"mappings":";;;;;;;;KAOY,qBAAqB,UAAU,QAAQ,UAAU;EAG3D,OAAO,QAAQ,GAAG;IAAQ;QAA4B;EACtD,MAAM,QAAQ,eAAe;EAC7B,OAAO,QAAQ,GAAG,OAAO;EACzB,QAAQ,QAAQ,GAAG,IAAI,KAAK,OAAO;EACnC,OAAO,QAAQ,GAAG,OAAO;EACzB,UAAU,QAAQ,GAAG,OAAO;;EAE5B,WAAW,QAAQ;;;;;EAKnB,aAAa,QAAQ,MAAM,SAAS,MAAM,SAAS;;iBAGrC,oBAAoB,UAAU,QAAQ,UAAU,QAC9D,MAAM,qBAAqB,GAAG,KAC7B,iBAAiB,GAAG;;;;;;;;;;;;cAiBV,iBAAiB,UAAU,QAAQ,UAAU,gBAChD,qBAAqB,YAAY,gBAC9B,WAAW,GAAG;;UAWf;UAPF;EAKR,YACE,QAAQ,GACA,MAAM,qBAAqB,GAAG;MAKpC,gBAAgB;MAIhB,2BAA2B;MAI3B;EAOJ;MAII,YAAY,SAAS;EAQnB,KAAK;IAAQ;IAAuB;MAA+B,iBAAiB;MAetF;EAIJ;EAIA,IAAI,QAAQ;EAgBZ,YAAY,QAAQ;EAId,KAAK,IAAI,KAAK,KAAK,QAAQ;EAY3B,SAAS,OAAO,IAAI;EAI1B,IAAI,OAAO;EASX,OAAO,OAAO;EAUR,0BAA0B;EAChC;;MAGI;MAKA;EAIJ;UAIQ;UAMA;UAIA;GAQP,YAAY;GACZ,YAAY"}
+{"version":3,"file":"CustomCollection.d.mts","names":[],"sources":["../../src/relations/CustomCollection.ts"],"mappings":";;;;;;;;YAOY,qBAAqB,UAAU,QAAQ,UAAU;EAG3D,OAAO,QAAQ,GAAG;IAAQ;QAA4B;EACtD,MAAM,QAAQ,eAAe;EAC7B,OAAO,QAAQ,GAAG,OAAO;EACzB,QAAQ,QAAQ,GAAG,IAAI,KAAK,OAAO;EACnC,OAAO,QAAQ,GAAG,OAAO;EACzB,UAAU,QAAQ,GAAG,OAAO;;EAE5B,WAAW,QAAQ;;;;;EAKnB,aAAa,QAAQ,MAAM,SAAS,MAAM,SAAS;;wBAGrC,oBAAoB,UAAU,QAAQ,UAAU,QAC9D,MAAM,qBAAqB,GAAG,KAC7B,iBAAiB,GAAG;;;;;;;;;;;;qBAiBV,iBAAiB,UAAU,QAAQ,UAAU,gBAChD,qBAAqB,YAAY,gBAC9B,WAAW,GAAG;;UAWf;UAPF;EAKR,YACE,QAAQ,GACA,MAAM,qBAAqB,GAAG;MAKpC,gBAAgB;MAIhB,2BAA2B;MAI3B;EAOJ;MAII,YAAY,SAAS;EAQnB,KAAK;IAAQ;IAAuB;MAA+B,iBAAiB;MAetF;EAIJ;EAIA,IAAI,QAAQ;EAgBZ,YAAY,QAAQ;EAId,KAAK,IAAI,KAAK,KAAK,QAAQ;EAY3B,SAAS,OAAO,IAAI;EAI1B,IAAI,OAAO;EASX,OAAO,OAAO;EAUR,0BAA0B;EAChC;;MAGI;MAKA;EAIJ;UAIQ;UAMA;UAIA;GAQP,YAAY;GACZ,YAAY"}

package/build/relations/CustomCollection.js.map

@@ -1 +1 @@
-{"version":3,"file":"CustomCollection.js","names":["#isLoaded","#loadHint","#hasBeenSet"],"sources":["../../src/relations/CustomCollection.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type IdOf, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type Collection, type LoadHint, ensureNotDeleted, fail } 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\";\n\nexport type CustomCollectionOpts<T extends Entity, U extends Entity> = {\n  // We purposefully don't capture the return value of `load` b/c we want `get` to re-calc from `entity`\n  // each time it's invoked so that it reflects any changed values.\n  load: (entity: T, opts: { forceReload?: boolean }) => Promise<any>;\n  get: (entity: T) => readonly U[];\n  set?: (entity: T, other: U[]) => void;\n  find?: (entity: T, id: IdOf<U>) => U | undefined;\n  add?: (entity: T, other: U) => void;\n  remove?: (entity: T, other: U) => void;\n  /** Whether the reference is loaded, even w/o an explicit `.load` call, i.e. for DeepNew test instances. */\n  isLoaded: (entity: T) => boolean;\n  /**\n   * A load hint that can be used to speculatively traverse the dependencies of this collection.  Currently\n   * only used by em.importEntity and can be omitted if the collection isn't used with it.\n   */\n  loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;\n};\n\nexport function hasCustomCollection<T extends Entity, U extends Entity>(\n  opts: CustomCollectionOpts<T, U>,\n): CustomCollection<T, U> {\n  return lazyField((entity: T) => {\n    return new CustomCollection<T, U>(entity, opts);\n  });\n}\n\n/**\n * Allows user-defined collections that will work in `populate` / preload hints.\n *\n * This works because Joist's `populate`/preloading is not based on creating giant SQL joins,\n * but instead by just walking \"1 dataloader per level\". Given this, we don't really care\n * what happens at each \"level\" of resolution, as long as: a) it's a promise, and b) the\n * caller uses dataloader to be batch friendly.\n *\n * This `CustomCollection` API is fairly low-level; users should more likely prefer higher-level\n * abstractions like `hasManyThrough`, which are built on `CustomCollection`.\n */\nexport class CustomCollection<T extends Entity, U extends Entity>\n  extends AbstractRelationImpl<T, readonly U[]>\n  implements Collection<T, U>\n{\n  // We keep both a promise+loaded flag and not an actual `this.loaded = await load` because\n  // the values can become stale; we want to each `.get` call to repeatedly evaluate the latest values.\n  private loadPromise: Promise<any> | undefined;\n  #hasBeenSet = false;\n  #isLoaded: boolean | undefined = undefined;\n  #loadHint: LoadHint<T> | undefined;\n\n  constructor(\n    entity: T,\n    private opts: CustomCollectionOpts<T, U>,\n  ) {\n    super(entity);\n  }\n\n  get get(): readonly U[] {\n    return this.doGet({ withDeleted: false });\n  }\n\n  get getWithDeleted(): readonly U[] {\n    return this.doGet({ withDeleted: true });\n  }\n\n  get isLoaded(): boolean {\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.addNaive(this);\n    this.#isLoaded = this.opts.isLoaded(this.entity);\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n  }\n\n  get loadHint(): LoadHint<T> | undefined {\n    if (this.#loadHint === undefined && this.opts.loadHint !== undefined) {\n      const { loadHint } = this.opts;\n      this.#loadHint = typeof loadHint === \"function\" ? loadHint(this.entity) : loadHint;\n    }\n    return this.#loadHint;\n  }\n\n  async load(opts: { withDeleted?: boolean; forceReload?: boolean } = {}): Promise<readonly U[]> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.isLoaded || opts.forceReload) {\n      if (this.loadPromise === undefined) {\n        this.loadPromise = this.opts.load(this.entity, opts);\n        await this.loadPromise;\n        this.loadPromise = undefined;\n        this.#isLoaded = true;\n      } else {\n        await this.loadPromise;\n      }\n    }\n    return this.doGet(opts);\n  }\n\n  get isPreloaded(): boolean {\n    return false;\n  }\n\n  preload(): void {\n    throw new Error(\"Not implemented\");\n  }\n\n  set(values: U[]): void {\n    this.ensureNewOrLoaded();\n    const { set, add, remove } = this.opts;\n    if (set !== undefined) {\n      set(this.entity, values);\n      this.#hasBeenSet = true;\n    } else if (add !== undefined && remove !== undefined) {\n      const current = this.get;\n      current.filter((value) => !values.includes(value)).forEach((value) => this.remove(value));\n      values.filter((value) => !current.includes(value)).forEach((value) => this.add(value));\n      this.#hasBeenSet = true;\n    } else {\n      fail(`'set' not implemented and not inferrable from 'add'/'remove' on ${this}`);\n    }\n  }\n\n  setFromOpts(values: U[]): void {\n    this.set(values);\n  }\n\n  async find(id: IdOf<U>): Promise<U | undefined> {\n    if (!this.isLoaded) {\n      await this.load();\n    }\n    const { find } = this.opts;\n    if (find === undefined) {\n      return this.doGet().find((other) => other.id === id);\n    } else {\n      return find(this.entity, id);\n    }\n  }\n\n  async includes(other: U): Promise<boolean> {\n    throw new Error(\"Not implemented\");\n  }\n\n  add(other: U): void {\n    this.ensureNewOrLoaded();\n    const { add } = this.opts;\n    if (add === undefined) {\n      fail(`'add' not implemented on ${this}`);\n    }\n    add(this.entity, other);\n  }\n\n  remove(other: U): void {\n    this.ensureNewOrLoaded();\n    const { remove } = this.opts;\n    if (remove === undefined) {\n      fail(`'add' not implemented on ${this}`);\n    }\n    remove(this.entity, other);\n  }\n\n  // these callbacks should be no-ops as they ought to be handled by the underlying relations\n  async cleanupOnEntityDeleted(): Promise<void> {}\n  maybeCascadeDelete(): void {}\n\n  /** Finds this CustomCollections field name by looking in the entity for the key that we're assigned to. */\n  get fieldName(): string {\n    // Something about running with the transformations breaks the `[0][0]` and it can NPE\n    return Object.entries(this.entity).filter((e) => e[1] === this)[0]?.[0];\n  }\n\n  get hasBeenSet() {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `CustomCollection(entity: ${this.entity}, fieldName: ${this.fieldName})`;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): readonly U[] {\n    ensureNotDeleted(this.entity, \"pending\");\n    this.ensureNewOrLoaded();\n    return this.filterDeleted(this.opts.get(this.entity), opts);\n  }\n\n  private filterDeleted(entities: readonly U[], opts?: { withDeleted?: boolean }): readonly U[] {\n    return entities.filter((entity) => opts?.withDeleted === true || !entity.isDeletedEntity);\n  }\n\n  private ensureNewOrLoaded() {\n    // This should only be callable in the type system if we've already resolved this to an instance\n    if (this.isLoaded) {\n      return;\n    }\n    fail(`${this.entity}.${this.fieldName} was not loaded`);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n}\n"],"mappings":";;;;;;;;AAyBA,SAAgB,oBACd,MACwB;CACxB,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,iBAAuB,QAAQ,IAAI;CAChD,CAAC;AACH;;;;;;;;;;;;AAaA,IAAa,mBAAb,cACU,qBAEV;CAUY;CAPV;CACA,cAAc;CACd,YAAiC,KAAA;CACjC;CAEA,YACE,QACA,MACA;EACA,MAAM,MAAM;EAFJ,KAAA,OAAA;CAGV;CAEA,IAAI,MAAoB;EACtB,OAAO,KAAK,MAAM,EAAE,aAAa,MAAM,CAAC;CAC1C;CAEA,IAAI,iBAA+B;EACjC,OAAO,KAAK,MAAM,EAAE,aAAa,KAAK,CAAC;CACzC;CAEA,IAAI,WAAoB;EACtB,IAAI,KAAKA,cAAc,KAAA,GAAW,OAAO,KAAKA;EAC9C,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,SAAS,IAAI;EAC5D,KAAKA,YAAY,KAAK,KAAK,SAAS,KAAK,MAAM;EAC/C,OAAO,KAAKA;CACd;CAEA,gBAAsB;EACpB,KAAKA,YAAY,KAAA;CACnB;CAEA,IAAI,WAAoC;EACtC,IAAI,KAAKC,cAAc,KAAA,KAAa,KAAK,KAAK,aAAa,KAAA,GAAW;GACpE,MAAM,EAAE,aAAa,KAAK;GAC1B,KAAKA,YAAY,OAAO,aAAa,aAAa,SAAS,KAAK,MAAM,IAAI;EAC5E;EACA,OAAO,KAAKA;CACd;CAEA,MAAM,KAAK,OAAyD,CAAC,GAA0B;EAC7F,iBAAiB,KAAK,QAAQ,SAAS;EACvC,IAAI,CAAC,KAAK,YAAY,KAAK,aAAa;GACtC,IAAI,KAAK,gBAAgB,KAAA,GAAW;IAClC,KAAK,cAAc,KAAK,KAAK,KAAK,KAAK,QAAQ,IAAI;IACnD,MAAM,KAAK;IACX,KAAK,cAAc,KAAA;IACnB,KAAKD,YAAY;GACnB,OACE,MAAM,KAAK;EAEf;EACA,OAAO,KAAK,MAAM,IAAI;CACxB;CAEA,IAAI,cAAuB;EACzB,OAAO;CACT;CAEA,UAAgB;EACd,MAAM,IAAI,MAAM,iBAAiB;CACnC;CAEA,IAAI,QAAmB;EACrB,KAAK,kBAAkB;EACvB,MAAM,EAAE,KAAK,KAAK,WAAW,KAAK;EAClC,IAAI,QAAQ,KAAA,GAAW;GACrB,IAAI,KAAK,QAAQ,MAAM;GACvB,KAAKE,cAAc;EACrB,OAAO,IAAI,QAAQ,KAAA,KAAa,WAAW,KAAA,GAAW;GACpD,MAAM,UAAU,KAAK;GACrB,QAAQ,QAAQ,UAAU,CAAC,OAAO,SAAS,KAAK,CAAC,CAAC,CAAC,SAAS,UAAU,KAAK,OAAO,KAAK,CAAC;GACxF,OAAO,QAAQ,UAAU,CAAC,QAAQ,SAAS,KAAK,CAAC,CAAC,CAAC,SAAS,UAAU,KAAK,IAAI,KAAK,CAAC;GACrF,KAAKA,cAAc;EACrB,OACE,KAAK,mEAAmE,MAAM;CAElF;CAEA,YAAY,QAAmB;EAC7B,KAAK,IAAI,MAAM;CACjB;CAEA,MAAM,KAAK,IAAqC;EAC9C,IAAI,CAAC,KAAK,UACR,MAAM,KAAK,KAAK;EAElB,MAAM,EAAE,SAAS,KAAK;EACtB,IAAI,SAAS,KAAA,GACX,OAAO,KAAK,MAAM,CAAC,CAAC,MAAM,UAAU,MAAM,OAAO,EAAE;OAEnD,OAAO,KAAK,KAAK,QAAQ,EAAE;CAE/B;CAEA,MAAM,SAAS,OAA4B;EACzC,MAAM,IAAI,MAAM,iBAAiB;CACnC;CAEA,IAAI,OAAgB;EAClB,KAAK,kBAAkB;EACvB,MAAM,EAAE,QAAQ,KAAK;EACrB,IAAI,QAAQ,KAAA,GACV,KAAK,4BAA4B,MAAM;EAEzC,IAAI,KAAK,QAAQ,KAAK;CACxB;CAEA,OAAO,OAAgB;EACrB,KAAK,kBAAkB;EACvB,MAAM,EAAE,WAAW,KAAK;EACxB,IAAI,WAAW,KAAA,GACb,KAAK,4BAA4B,MAAM;EAEzC,OAAO,KAAK,QAAQ,KAAK;CAC3B;CAGA,MAAM,yBAAwC,CAAC;CAC/C,qBAA2B,CAAC;;CAG5B,IAAI,YAAoB;EAEtB,OAAO,OAAO,QAAQ,KAAK,MAAM,CAAC,CAAC,QAAQ,MAAM,EAAE,OAAO,IAAI,CAAC,CAAC,EAAE,GAAG;CACvE;CAEA,IAAI,aAAa;EACf,OAAO,KAAKA;CACd;CAEA,WAAmB;EACjB,OAAO,4BAA4B,KAAK,OAAO,eAAe,KAAK,UAAU;CAC/E;CAEA,MAAc,MAAgD;EAC5D,iBAAiB,KAAK,QAAQ,SAAS;EACvC,KAAK,kBAAkB;EACvB,OAAO,KAAK,cAAc,KAAK,KAAK,IAAI,KAAK,MAAM,GAAG,IAAI;CAC5D;CAEA,cAAsB,UAAwB,MAAgD;EAC5F,OAAO,SAAS,QAAQ,WAAW,MAAM,gBAAgB,QAAQ,CAAC,OAAO,eAAe;CAC1F;CAEA,oBAA4B;EAE1B,IAAI,KAAK,UACP;EAEF,KAAK,GAAG,KAAK,OAAO,GAAG,KAAK,UAAU,gBAAgB;CACxD;CAEA,CAAC,aAAgB;CACjB,CAAC,aAAgB;AACnB"}
+{"version":3,"file":"CustomCollection.js","names":[],"sources":["../../src/relations/CustomCollection.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type IdOf, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type Collection, type LoadHint, ensureNotDeleted, fail } 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\";\n\nexport type CustomCollectionOpts<T extends Entity, U extends Entity> = {\n  // We purposefully don't capture the return value of `load` b/c we want `get` to re-calc from `entity`\n  // each time it's invoked so that it reflects any changed values.\n  load: (entity: T, opts: { forceReload?: boolean }) => Promise<any>;\n  get: (entity: T) => readonly U[];\n  set?: (entity: T, other: U[]) => void;\n  find?: (entity: T, id: IdOf<U>) => U | undefined;\n  add?: (entity: T, other: U) => void;\n  remove?: (entity: T, other: U) => void;\n  /** Whether the reference is loaded, even w/o an explicit `.load` call, i.e. for DeepNew test instances. */\n  isLoaded: (entity: T) => boolean;\n  /**\n   * A load hint that can be used to speculatively traverse the dependencies of this collection.  Currently\n   * only used by em.importEntity and can be omitted if the collection isn't used with it.\n   */\n  loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;\n};\n\nexport function hasCustomCollection<T extends Entity, U extends Entity>(\n  opts: CustomCollectionOpts<T, U>,\n): CustomCollection<T, U> {\n  return lazyField((entity: T) => {\n    return new CustomCollection<T, U>(entity, opts);\n  });\n}\n\n/**\n * Allows user-defined collections that will work in `populate` / preload hints.\n *\n * This works because Joist's `populate`/preloading is not based on creating giant SQL joins,\n * but instead by just walking \"1 dataloader per level\". Given this, we don't really care\n * what happens at each \"level\" of resolution, as long as: a) it's a promise, and b) the\n * caller uses dataloader to be batch friendly.\n *\n * This `CustomCollection` API is fairly low-level; users should more likely prefer higher-level\n * abstractions like `hasManyThrough`, which are built on `CustomCollection`.\n */\nexport class CustomCollection<T extends Entity, U extends Entity>\n  extends AbstractRelationImpl<T, readonly U[]>\n  implements Collection<T, U>\n{\n  // We keep both a promise+loaded flag and not an actual `this.loaded = await load` because\n  // the values can become stale; we want to each `.get` call to repeatedly evaluate the latest values.\n  private loadPromise: Promise<any> | undefined;\n  #hasBeenSet = false;\n  #isLoaded: boolean | undefined = undefined;\n  #loadHint: LoadHint<T> | undefined;\n\n  constructor(\n    entity: T,\n    private opts: CustomCollectionOpts<T, U>,\n  ) {\n    super(entity);\n  }\n\n  get get(): readonly U[] {\n    return this.doGet({ withDeleted: false });\n  }\n\n  get getWithDeleted(): readonly U[] {\n    return this.doGet({ withDeleted: true });\n  }\n\n  get isLoaded(): boolean {\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.addNaive(this);\n    this.#isLoaded = this.opts.isLoaded(this.entity);\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n  }\n\n  get loadHint(): LoadHint<T> | undefined {\n    if (this.#loadHint === undefined && this.opts.loadHint !== undefined) {\n      const { loadHint } = this.opts;\n      this.#loadHint = typeof loadHint === \"function\" ? loadHint(this.entity) : loadHint;\n    }\n    return this.#loadHint;\n  }\n\n  async load(opts: { withDeleted?: boolean; forceReload?: boolean } = {}): Promise<readonly U[]> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.isLoaded || opts.forceReload) {\n      if (this.loadPromise === undefined) {\n        this.loadPromise = this.opts.load(this.entity, opts);\n        await this.loadPromise;\n        this.loadPromise = undefined;\n        this.#isLoaded = true;\n      } else {\n        await this.loadPromise;\n      }\n    }\n    return this.doGet(opts);\n  }\n\n  get isPreloaded(): boolean {\n    return false;\n  }\n\n  preload(): void {\n    throw new Error(\"Not implemented\");\n  }\n\n  set(values: U[]): void {\n    this.ensureNewOrLoaded();\n    const { set, add, remove } = this.opts;\n    if (set !== undefined) {\n      set(this.entity, values);\n      this.#hasBeenSet = true;\n    } else if (add !== undefined && remove !== undefined) {\n      const current = this.get;\n      current.filter((value) => !values.includes(value)).forEach((value) => this.remove(value));\n      values.filter((value) => !current.includes(value)).forEach((value) => this.add(value));\n      this.#hasBeenSet = true;\n    } else {\n      fail(`'set' not implemented and not inferrable from 'add'/'remove' on ${this}`);\n    }\n  }\n\n  setFromOpts(values: U[]): void {\n    this.set(values);\n  }\n\n  async find(id: IdOf<U>): Promise<U | undefined> {\n    if (!this.isLoaded) {\n      await this.load();\n    }\n    const { find } = this.opts;\n    if (find === undefined) {\n      return this.doGet().find((other) => other.id === id);\n    } else {\n      return find(this.entity, id);\n    }\n  }\n\n  async includes(other: U): Promise<boolean> {\n    throw new Error(\"Not implemented\");\n  }\n\n  add(other: U): void {\n    this.ensureNewOrLoaded();\n    const { add } = this.opts;\n    if (add === undefined) {\n      fail(`'add' not implemented on ${this}`);\n    }\n    add(this.entity, other);\n  }\n\n  remove(other: U): void {\n    this.ensureNewOrLoaded();\n    const { remove } = this.opts;\n    if (remove === undefined) {\n      fail(`'add' not implemented on ${this}`);\n    }\n    remove(this.entity, other);\n  }\n\n  // these callbacks should be no-ops as they ought to be handled by the underlying relations\n  async cleanupOnEntityDeleted(): Promise<void> {}\n  maybeCascadeDelete(): void {}\n\n  /** Finds this CustomCollections field name by looking in the entity for the key that we're assigned to. */\n  get fieldName(): string {\n    // Something about running with the transformations breaks the `[0][0]` and it can NPE\n    return Object.entries(this.entity).filter((e) => e[1] === this)[0]?.[0];\n  }\n\n  get hasBeenSet() {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `CustomCollection(entity: ${this.entity}, fieldName: ${this.fieldName})`;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): readonly U[] {\n    ensureNotDeleted(this.entity, \"pending\");\n    this.ensureNewOrLoaded();\n    return this.filterDeleted(this.opts.get(this.entity), opts);\n  }\n\n  private filterDeleted(entities: readonly U[], opts?: { withDeleted?: boolean }): readonly U[] {\n    return entities.filter((entity) => opts?.withDeleted === true || !entity.isDeletedEntity);\n  }\n\n  private ensureNewOrLoaded() {\n    // This should only be callable in the type system if we've already resolved this to an instance\n    if (this.isLoaded) {\n      return;\n    }\n    fail(`${this.entity}.${this.fieldName} was not loaded`);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n}\n"],"mappings":";;;;;;;;AAyBA,SAAgB,oBACd,MACwB;CACxB,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,iBAAuB,QAAQ,IAAI;CAChD,CAAC;AACH;;;;;;;;;;;;AAaA,IAAa,mBAAb,cACU,qBAEV;CAUY;CAPV;CACA,cAAc;CACd,YAAiC,KAAA;CACjC;CAEA,YACE,QACA,MACA;EACA,MAAM,MAAM;EAFJ,KAAA,OAAA;CAGV;CAEA,IAAI,MAAoB;EACtB,OAAO,KAAK,MAAM,EAAE,aAAa,MAAM,CAAC;CAC1C;CAEA,IAAI,iBAA+B;EACjC,OAAO,KAAK,MAAM,EAAE,aAAa,KAAK,CAAC;CACzC;CAEA,IAAI,WAAoB;EACtB,IAAI,KAAK,cAAc,KAAA,GAAW,OAAO,KAAK;EAC9C,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,SAAS,IAAI;EAC5D,KAAK,YAAY,KAAK,KAAK,SAAS,KAAK,MAAM;EAC/C,OAAO,KAAK;CACd;CAEA,gBAAsB;EACpB,KAAK,YAAY,KAAA;CACnB;CAEA,IAAI,WAAoC;EACtC,IAAI,KAAK,cAAc,KAAA,KAAa,KAAK,KAAK,aAAa,KAAA,GAAW;GACpE,MAAM,EAAE,aAAa,KAAK;GAC1B,KAAK,YAAY,OAAO,aAAa,aAAa,SAAS,KAAK,MAAM,IAAI;EAC5E;EACA,OAAO,KAAK;CACd;CAEA,MAAM,KAAK,OAAyD,CAAC,GAA0B;EAC7F,iBAAiB,KAAK,QAAQ,SAAS;EACvC,IAAI,CAAC,KAAK,YAAY,KAAK,aAAa;GACtC,IAAI,KAAK,gBAAgB,KAAA,GAAW;IAClC,KAAK,cAAc,KAAK,KAAK,KAAK,KAAK,QAAQ,IAAI;IACnD,MAAM,KAAK;IACX,KAAK,cAAc,KAAA;IACnB,KAAK,YAAY;GACnB,OACE,MAAM,KAAK;EAEf;EACA,OAAO,KAAK,MAAM,IAAI;CACxB;CAEA,IAAI,cAAuB;EACzB,OAAO;CACT;CAEA,UAAgB;EACd,MAAM,IAAI,MAAM,iBAAiB;CACnC;CAEA,IAAI,QAAmB;EACrB,KAAK,kBAAkB;EACvB,MAAM,EAAE,KAAK,KAAK,WAAW,KAAK;EAClC,IAAI,QAAQ,KAAA,GAAW;GACrB,IAAI,KAAK,QAAQ,MAAM;GACvB,KAAK,cAAc;EACrB,OAAO,IAAI,QAAQ,KAAA,KAAa,WAAW,KAAA,GAAW;GACpD,MAAM,UAAU,KAAK;GACrB,QAAQ,QAAQ,UAAU,CAAC,OAAO,SAAS,KAAK,CAAC,CAAC,CAAC,SAAS,UAAU,KAAK,OAAO,KAAK,CAAC;GACxF,OAAO,QAAQ,UAAU,CAAC,QAAQ,SAAS,KAAK,CAAC,CAAC,CAAC,SAAS,UAAU,KAAK,IAAI,KAAK,CAAC;GACrF,KAAK,cAAc;EACrB,OACE,KAAK,mEAAmE,MAAM;CAElF;CAEA,YAAY,QAAmB;EAC7B,KAAK,IAAI,MAAM;CACjB;CAEA,MAAM,KAAK,IAAqC;EAC9C,IAAI,CAAC,KAAK,UACR,MAAM,KAAK,KAAK;EAElB,MAAM,EAAE,SAAS,KAAK;EACtB,IAAI,SAAS,KAAA,GACX,OAAO,KAAK,MAAM,CAAC,CAAC,MAAM,UAAU,MAAM,OAAO,EAAE;OAEnD,OAAO,KAAK,KAAK,QAAQ,EAAE;CAE/B;CAEA,MAAM,SAAS,OAA4B;EACzC,MAAM,IAAI,MAAM,iBAAiB;CACnC;CAEA,IAAI,OAAgB;EAClB,KAAK,kBAAkB;EACvB,MAAM,EAAE,QAAQ,KAAK;EACrB,IAAI,QAAQ,KAAA,GACV,KAAK,4BAA4B,MAAM;EAEzC,IAAI,KAAK,QAAQ,KAAK;CACxB;CAEA,OAAO,OAAgB;EACrB,KAAK,kBAAkB;EACvB,MAAM,EAAE,WAAW,KAAK;EACxB,IAAI,WAAW,KAAA,GACb,KAAK,4BAA4B,MAAM;EAEzC,OAAO,KAAK,QAAQ,KAAK;CAC3B;CAGA,MAAM,yBAAwC,CAAC;CAC/C,qBAA2B,CAAC;;CAG5B,IAAI,YAAoB;EAEtB,OAAO,OAAO,QAAQ,KAAK,MAAM,CAAC,CAAC,QAAQ,MAAM,EAAE,OAAO,IAAI,CAAC,CAAC,EAAE,GAAG;CACvE;CAEA,IAAI,aAAa;EACf,OAAO,KAAK;CACd;CAEA,WAAmB;EACjB,OAAO,4BAA4B,KAAK,OAAO,eAAe,KAAK,UAAU;CAC/E;CAEA,MAAc,MAAgD;EAC5D,iBAAiB,KAAK,QAAQ,SAAS;EACvC,KAAK,kBAAkB;EACvB,OAAO,KAAK,cAAc,KAAK,KAAK,IAAI,KAAK,MAAM,GAAG,IAAI;CAC5D;CAEA,cAAsB,UAAwB,MAAgD;EAC5F,OAAO,SAAS,QAAQ,WAAW,MAAM,gBAAgB,QAAQ,CAAC,OAAO,eAAe;CAC1F;CAEA,oBAA4B;EAE1B,IAAI,KAAK,UACP;EAEF,KAAK,GAAG,KAAK,OAAO,GAAG,KAAK,UAAU,gBAAgB;CACxD;CAEA,CAAC,aAAgB;CACjB,CAAC,aAAgB;AACnB"}

package/build/relations/CustomReference.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"CustomReference.cjs","names":["lazyField","AbstractRelationImpl","#isLoaded","#loadHint","fail","#hasBeenSet","getProperties","getMetadata","RelationT","RelationU","ReferenceN"],"sources":["../../src/relations/CustomReference.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type IdOf, type TaggedId, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type LoadHint, type Reference, ensureNotDeleted, fail, getMetadata, getProperties } from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractRelationImpl } from \"src/relations/AbstractRelationImpl.ts\";\nimport { ReferenceN } from \"src/relations/ReferenceSymbols.ts\";\nimport { RelationT, RelationU } from \"src/relations/RelationSymbols.ts\";\n\n/** An alias for creating `CustomReference`s. */\nexport function hasCustomReference<T extends Entity, U extends Entity, N extends never | undefined>(\n  opts: CustomReferenceOpts<T, U, N>,\n): CustomReference<T, U, N> {\n  return lazyField((entity: T) => {\n    return new CustomReference<T, U, N>(entity, opts);\n  });\n}\n\nexport type CustomReferenceOpts<T extends Entity, U extends Entity, N extends never | undefined> = {\n  // We purposefully don't capture the return value of `load` b/c we want `get` to re-calc from `entity`\n  // each time it's invoked so that it reflects any changed values.\n  load: (entity: T, opts: { forceReload?: boolean }) => Promise<unknown>;\n  get: (entity: T) => U | N;\n  set?: (entity: T, other: U) => void;\n  /** Whether the reference is loaded, even w/o an explicit `.load` call, i.e. for DeepNew test instances. */\n  isLoaded: (entity: T) => boolean;\n  /**\n   * A load hint that can be used to speculatively traverse the dependencies of this reference.  Currently\n   * only used by em.importEntity and can be omitted if the reference isn't used with it.\n   */\n  loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;\n};\n\n/**\n * Allows user-defined references that will work in `populate` / preload hints.\n *\n * This works because Joist's `populate`/preloading is not based on creating giant SQL joins,\n * but instead by just walking \"1 dataloader per level\". Given this, we don't really care\n * what happens at each \"level\" of resolution, as long as: a) it's a promise, and b) the\n * caller uses dataloader to be batch friendly.\n *\n * This `CustomReference` API is fairly low-level; users should more likely prefer higher-level\n * abstractions like `hasOneThrough`, which are built on `CustomReference.\n */\nexport class CustomReference<T extends Entity, U extends Entity, N extends never | undefined>\n  extends AbstractRelationImpl<T, U>\n  implements Reference<T, U, N>\n{\n  // We keep both a promise+loaded flag and not an actual `this.loaded = await load` because\n  // the value can become stale; we want to each `.get` call to repeatedly evaluate the latest value.\n  private loadPromise: Promise<unknown> | undefined;\n  #hasBeenSet = false;\n  #isLoaded: boolean | undefined;\n  #loadHint: LoadHint<T> | undefined;\n\n  constructor(\n    entity: T,\n    private opts: CustomReferenceOpts<T, U, N>,\n  ) {\n    super(entity);\n  }\n\n  get get(): U | N {\n    return this.doGet({ withDeleted: false });\n  }\n\n  get getWithDeleted(): U | N {\n    return this.doGet({ withDeleted: true });\n  }\n\n  get isLoaded(): boolean {\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.addNaive(this);\n    this.#isLoaded = this.opts.isLoaded(this.entity);\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n  }\n\n  get loadHint(): LoadHint<T> | undefined {\n    if (this.#loadHint === undefined && this.opts.loadHint !== undefined) {\n      const { loadHint } = this.opts;\n      this.#loadHint = typeof loadHint === \"function\" ? loadHint(this.entity) : loadHint;\n    }\n    return this.#loadHint;\n  }\n\n  async load(opts: { withDeleted?: boolean; forceReload?: boolean } = {}): Promise<U | N> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.isLoaded || opts.forceReload) {\n      if (this.loadPromise === undefined) {\n        this.loadPromise = this.opts.load(this.entity, opts);\n        await this.loadPromise;\n        this.loadPromise = undefined;\n        this.#isLoaded = true;\n      } else {\n        await this.loadPromise;\n      }\n    }\n    return this.doGet(opts);\n  }\n\n  get isPreloaded(): boolean {\n    return false;\n  }\n\n  preload(): void {\n    throw new Error(\"Not implemented\");\n  }\n\n  get id(): IdOf<U> {\n    return fail(`CustomReference cannot resolve 'id'`);\n  }\n\n  get idMaybe(): IdOf<U> | undefined {\n    return fail(`CustomReference cannot resolve 'idMaybe'`);\n  }\n\n  get idTaggedMaybe(): TaggedId | undefined {\n    return fail(`CustomReference cannot resolve 'idTaggedMaybe'`);\n  }\n\n  get idUntagged(): string {\n    return fail(`CustomReference cannot resolve 'idUntagged'`);\n  }\n\n  get idUntaggedMaybe(): string | undefined {\n    return fail(`CustomReference cannot resolve 'idUntaggedMaybe'`);\n  }\n\n  get isSet(): boolean {\n    this.ensureNewOrLoaded();\n    const { get } = this.opts;\n    return get(this.entity) !== undefined;\n  }\n\n  set(value: U): void {\n    // We allow setting CustomReferences on new entities w/o being loaded\n    if (!this.entity.isNewEntity) {\n      this.ensureNewOrLoaded();\n    }\n    const { set } = this.opts;\n    if (set === undefined) {\n      throw new Error(`'set' not implemented on ${this}`);\n    }\n    set(this.entity, value);\n    this.#hasBeenSet = true;\n  }\n\n  setFromOpts(value: U): void {\n    this.set(value);\n  }\n\n  // these callbacks should be no-ops as they ought to be handled by the underlying relations\n  async cleanupOnEntityDeleted(): Promise<void> {}\n  maybeCascadeDelete(): void {}\n\n  /** Finds this CustomReferences field name by looking in the entity for the key that we're assigned to. */\n  get fieldName(): string {\n    return Object.entries(getProperties(getMetadata(this.entity))).filter(\n      ([key]) => (this.entity as any)[key] === this,\n    )[0][0];\n  }\n\n  get hasBeenSet() {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `CustomReference(entity: ${this.entity}, fieldName: ${this.fieldName})`;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): U | N {\n    ensureNotDeleted(this.entity, \"pending\");\n    this.ensureNewOrLoaded();\n    return this.filterDeleted(this.opts.get(this.entity), opts);\n  }\n\n  private filterDeleted(entity: U | N, opts?: { withDeleted?: boolean }): U | N {\n    return opts?.withDeleted === true || entity === undefined || !entity.isDeletedEntity ? entity : (undefined as N);\n  }\n\n  private ensureNewOrLoaded() {\n    // This should only be callable in the type system if we've already resolved this to an instance\n    if (this.isLoaded) {\n      return;\n    }\n    fail(`${this.entity}.${this.fieldName} was not loaded`);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n  [ReferenceN]: N = null!;\n}\n"],"mappings":"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"}
+{"version":3,"file":"CustomReference.cjs","names":["lazyField","AbstractRelationImpl","fail","getProperties","getMetadata","RelationT","RelationU","ReferenceN"],"sources":["../../src/relations/CustomReference.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type IdOf, type TaggedId, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type LoadHint, type Reference, ensureNotDeleted, fail, getMetadata, getProperties } from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractRelationImpl } from \"src/relations/AbstractRelationImpl.ts\";\nimport { ReferenceN } from \"src/relations/ReferenceSymbols.ts\";\nimport { RelationT, RelationU } from \"src/relations/RelationSymbols.ts\";\n\n/** An alias for creating `CustomReference`s. */\nexport function hasCustomReference<T extends Entity, U extends Entity, N extends never | undefined>(\n  opts: CustomReferenceOpts<T, U, N>,\n): CustomReference<T, U, N> {\n  return lazyField((entity: T) => {\n    return new CustomReference<T, U, N>(entity, opts);\n  });\n}\n\nexport type CustomReferenceOpts<T extends Entity, U extends Entity, N extends never | undefined> = {\n  // We purposefully don't capture the return value of `load` b/c we want `get` to re-calc from `entity`\n  // each time it's invoked so that it reflects any changed values.\n  load: (entity: T, opts: { forceReload?: boolean }) => Promise<unknown>;\n  get: (entity: T) => U | N;\n  set?: (entity: T, other: U) => void;\n  /** Whether the reference is loaded, even w/o an explicit `.load` call, i.e. for DeepNew test instances. */\n  isLoaded: (entity: T) => boolean;\n  /**\n   * A load hint that can be used to speculatively traverse the dependencies of this reference.  Currently\n   * only used by em.importEntity and can be omitted if the reference isn't used with it.\n   */\n  loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;\n};\n\n/**\n * Allows user-defined references that will work in `populate` / preload hints.\n *\n * This works because Joist's `populate`/preloading is not based on creating giant SQL joins,\n * but instead by just walking \"1 dataloader per level\". Given this, we don't really care\n * what happens at each \"level\" of resolution, as long as: a) it's a promise, and b) the\n * caller uses dataloader to be batch friendly.\n *\n * This `CustomReference` API is fairly low-level; users should more likely prefer higher-level\n * abstractions like `hasOneThrough`, which are built on `CustomReference.\n */\nexport class CustomReference<T extends Entity, U extends Entity, N extends never | undefined>\n  extends AbstractRelationImpl<T, U>\n  implements Reference<T, U, N>\n{\n  // We keep both a promise+loaded flag and not an actual `this.loaded = await load` because\n  // the value can become stale; we want to each `.get` call to repeatedly evaluate the latest value.\n  private loadPromise: Promise<unknown> | undefined;\n  #hasBeenSet = false;\n  #isLoaded: boolean | undefined;\n  #loadHint: LoadHint<T> | undefined;\n\n  constructor(\n    entity: T,\n    private opts: CustomReferenceOpts<T, U, N>,\n  ) {\n    super(entity);\n  }\n\n  get get(): U | N {\n    return this.doGet({ withDeleted: false });\n  }\n\n  get getWithDeleted(): U | N {\n    return this.doGet({ withDeleted: true });\n  }\n\n  get isLoaded(): boolean {\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.addNaive(this);\n    this.#isLoaded = this.opts.isLoaded(this.entity);\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n  }\n\n  get loadHint(): LoadHint<T> | undefined {\n    if (this.#loadHint === undefined && this.opts.loadHint !== undefined) {\n      const { loadHint } = this.opts;\n      this.#loadHint = typeof loadHint === \"function\" ? loadHint(this.entity) : loadHint;\n    }\n    return this.#loadHint;\n  }\n\n  async load(opts: { withDeleted?: boolean; forceReload?: boolean } = {}): Promise<U | N> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.isLoaded || opts.forceReload) {\n      if (this.loadPromise === undefined) {\n        this.loadPromise = this.opts.load(this.entity, opts);\n        await this.loadPromise;\n        this.loadPromise = undefined;\n        this.#isLoaded = true;\n      } else {\n        await this.loadPromise;\n      }\n    }\n    return this.doGet(opts);\n  }\n\n  get isPreloaded(): boolean {\n    return false;\n  }\n\n  preload(): void {\n    throw new Error(\"Not implemented\");\n  }\n\n  get id(): IdOf<U> {\n    return fail(`CustomReference cannot resolve 'id'`);\n  }\n\n  get idMaybe(): IdOf<U> | undefined {\n    return fail(`CustomReference cannot resolve 'idMaybe'`);\n  }\n\n  get idTaggedMaybe(): TaggedId | undefined {\n    return fail(`CustomReference cannot resolve 'idTaggedMaybe'`);\n  }\n\n  get idUntagged(): string {\n    return fail(`CustomReference cannot resolve 'idUntagged'`);\n  }\n\n  get idUntaggedMaybe(): string | undefined {\n    return fail(`CustomReference cannot resolve 'idUntaggedMaybe'`);\n  }\n\n  get isSet(): boolean {\n    this.ensureNewOrLoaded();\n    const { get } = this.opts;\n    return get(this.entity) !== undefined;\n  }\n\n  set(value: U): void {\n    // We allow setting CustomReferences on new entities w/o being loaded\n    if (!this.entity.isNewEntity) {\n      this.ensureNewOrLoaded();\n    }\n    const { set } = this.opts;\n    if (set === undefined) {\n      throw new Error(`'set' not implemented on ${this}`);\n    }\n    set(this.entity, value);\n    this.#hasBeenSet = true;\n  }\n\n  setFromOpts(value: U): void {\n    this.set(value);\n  }\n\n  // these callbacks should be no-ops as they ought to be handled by the underlying relations\n  async cleanupOnEntityDeleted(): Promise<void> {}\n  maybeCascadeDelete(): void {}\n\n  /** Finds this CustomReferences field name by looking in the entity for the key that we're assigned to. */\n  get fieldName(): string {\n    return Object.entries(getProperties(getMetadata(this.entity))).filter(\n      ([key]) => (this.entity as any)[key] === this,\n    )[0][0];\n  }\n\n  get hasBeenSet() {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `CustomReference(entity: ${this.entity}, fieldName: ${this.fieldName})`;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): U | N {\n    ensureNotDeleted(this.entity, \"pending\");\n    this.ensureNewOrLoaded();\n    return this.filterDeleted(this.opts.get(this.entity), opts);\n  }\n\n  private filterDeleted(entity: U | N, opts?: { withDeleted?: boolean }): U | N {\n    return opts?.withDeleted === true || entity === undefined || !entity.isDeletedEntity ? entity : (undefined as N);\n  }\n\n  private ensureNewOrLoaded() {\n    // This should only be callable in the type system if we've already resolved this to an instance\n    if (this.isLoaded) {\n      return;\n    }\n    fail(`${this.entity}.${this.fieldName} was not loaded`);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n  [ReferenceN]: N = null!;\n}\n"],"mappings":"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"}

package/build/relations/CustomReference.d.cts

@@ -8,8 +8,8 @@ import { IdOf, TaggedId } from "../EntityManager.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/CustomReference.d.ts
 /** An alias for creating `CustomReference`s. */
-declare function hasCustomReference<T extends Entity, U extends Entity, N extends never | undefined>(opts: CustomReferenceOpts<T, U, N>): CustomReference<T, U, N>;
-type CustomReferenceOpts<T extends Entity, U extends Entity, N extends never | undefined> = {
+export declare function hasCustomReference<T extends Entity, U extends Entity, N extends never | undefined>(opts: CustomReferenceOpts<T, U, N>): CustomReference<T, U, N>;
+export type CustomReferenceOpts<T extends Entity, U extends Entity, N extends never | undefined> = {
   load: (entity: T, opts: {
     forceReload?: boolean;
   }) => Promise<unknown>;
@@ -34,7 +34,7 @@ type CustomReferenceOpts<T extends Entity, U extends Entity, N extends never | u
  * This `CustomReference` API is fairly low-level; users should more likely prefer higher-level
  * abstractions like `hasOneThrough`, which are built on `CustomReference.
  */
-declare class CustomReference<T extends Entity, U extends Entity, N extends never | undefined> extends AbstractRelationImpl<T, U> implements Reference<T, U, N> {
+export declare class CustomReference<T extends Entity, U extends Entity, N extends never | undefined> extends AbstractRelationImpl<T, U> implements Reference<T, U, N> {
   #private;
   private opts;
   private loadPromise;
@@ -72,5 +72,4 @@ declare class CustomReference<T extends Entity, U extends Entity, N extends neve
   [ReferenceN]: N;
 }
 //#endregion
-export { CustomReference, CustomReferenceOpts, hasCustomReference };
 //# sourceMappingURL=CustomReference.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"CustomReference.d.cts","names":[],"sources":["../../src/relations/CustomReference.ts"],"mappings":";;;;;;;;;;iBASgB,mBAAmB,UAAU,QAAQ,UAAU,QAAQ,6BACrE,MAAM,oBAAoB,GAAG,GAAG,KAC/B,gBAAgB,GAAG,GAAG;KAMb,oBAAoB,UAAU,QAAQ,UAAU,QAAQ;EAGlE,OAAO,QAAQ,GAAG;IAAQ;QAA4B;EACtD,MAAM,QAAQ,MAAM,IAAI;EACxB,OAAO,QAAQ,GAAG,OAAO;;EAEzB,WAAW,QAAQ;;;;;EAKnB,aAAa,QAAQ,MAAM,SAAS,MAAM,SAAS;;;;;;;;;;;;;cAcxC,gBAAgB,UAAU,QAAQ,UAAU,QAAQ,qCACvD,qBAAqB,GAAG,cACrB,UAAU,GAAG,GAAG;;UAWjB;UAPF;EAKR,YACE,QAAQ,GACA,MAAM,oBAAoB,GAAG,GAAG;MAKtC,OAAO,IAAI;MAIX,kBAAkB,IAAI;MAItB;EAOJ;MAII,YAAY,SAAS;EAQnB,KAAK;IAAQ;IAAuB;MAA+B,QAAQ,IAAI;MAejF;EAIJ;MAII,MAAM,KAAK;MAIX,WAAW,KAAK;MAIhB,iBAAiB;MAIjB;MAIA;MAIA;EAMJ,IAAI,OAAO;EAaX,YAAY,OAAO;EAKb,0BAA0B;EAChC;;MAGI;MAMA;EAIJ;UAIQ;UAMA;UAIA;GAQP,YAAY;GACZ,YAAY;GACZ,aAAa"}
+{"version":3,"file":"CustomReference.d.cts","names":[],"sources":["../../src/relations/CustomReference.ts"],"mappings":";;;;;;;;;;wBASgB,mBAAmB,UAAU,QAAQ,UAAU,QAAQ,6BACrE,MAAM,oBAAoB,GAAG,GAAG,KAC/B,gBAAgB,GAAG,GAAG;YAMb,oBAAoB,UAAU,QAAQ,UAAU,QAAQ;EAGlE,OAAO,QAAQ,GAAG;IAAQ;QAA4B;EACtD,MAAM,QAAQ,MAAM,IAAI;EACxB,OAAO,QAAQ,GAAG,OAAO;;EAEzB,WAAW,QAAQ;;;;;EAKnB,aAAa,QAAQ,MAAM,SAAS,MAAM,SAAS;;;;;;;;;;;;;qBAcxC,gBAAgB,UAAU,QAAQ,UAAU,QAAQ,qCACvD,qBAAqB,GAAG,cACrB,UAAU,GAAG,GAAG;;UAWjB;UAPF;EAKR,YACE,QAAQ,GACA,MAAM,oBAAoB,GAAG,GAAG;MAKtC,OAAO,IAAI;MAIX,kBAAkB,IAAI;MAItB;EAOJ;MAII,YAAY,SAAS;EAQnB,KAAK;IAAQ;IAAuB;MAA+B,QAAQ,IAAI;MAejF;EAIJ;MAII,MAAM,KAAK;MAIX,WAAW,KAAK;MAIhB,iBAAiB;MAIjB;MAIA;MAIA;EAMJ,IAAI,OAAO;EAaX,YAAY,OAAO;EAKb,0BAA0B;EAChC;;MAGI;MAMA;EAIJ;UAIQ;UAMA;UAIA;GAQP,YAAY;GACZ,YAAY;GACZ,aAAa"}

package/build/relations/CustomReference.d.mts

@@ -8,8 +8,8 @@ import { IdOf, TaggedId } from "../EntityManager.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/CustomReference.d.ts
 /** An alias for creating `CustomReference`s. */
-declare function hasCustomReference<T extends Entity, U extends Entity, N extends never | undefined>(opts: CustomReferenceOpts<T, U, N>): CustomReference<T, U, N>;
-type CustomReferenceOpts<T extends Entity, U extends Entity, N extends never | undefined> = {
+export declare function hasCustomReference<T extends Entity, U extends Entity, N extends never | undefined>(opts: CustomReferenceOpts<T, U, N>): CustomReference<T, U, N>;
+export type CustomReferenceOpts<T extends Entity, U extends Entity, N extends never | undefined> = {
   load: (entity: T, opts: {
     forceReload?: boolean;
   }) => Promise<unknown>;
@@ -34,7 +34,7 @@ type CustomReferenceOpts<T extends Entity, U extends Entity, N extends never | u
  * This `CustomReference` API is fairly low-level; users should more likely prefer higher-level
  * abstractions like `hasOneThrough`, which are built on `CustomReference.
  */
-declare class CustomReference<T extends Entity, U extends Entity, N extends never | undefined> extends AbstractRelationImpl<T, U> implements Reference<T, U, N> {
+export declare class CustomReference<T extends Entity, U extends Entity, N extends never | undefined> extends AbstractRelationImpl<T, U> implements Reference<T, U, N> {
   #private;
   private opts;
   private loadPromise;
@@ -72,5 +72,4 @@ declare class CustomReference<T extends Entity, U extends Entity, N extends neve
   [ReferenceN]: N;
 }
 //#endregion
-export { CustomReference, CustomReferenceOpts, hasCustomReference };
 //# sourceMappingURL=CustomReference.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"CustomReference.d.mts","names":[],"sources":["../../src/relations/CustomReference.ts"],"mappings":";;;;;;;;;;iBASgB,mBAAmB,UAAU,QAAQ,UAAU,QAAQ,6BACrE,MAAM,oBAAoB,GAAG,GAAG,KAC/B,gBAAgB,GAAG,GAAG;KAMb,oBAAoB,UAAU,QAAQ,UAAU,QAAQ;EAGlE,OAAO,QAAQ,GAAG;IAAQ;QAA4B;EACtD,MAAM,QAAQ,MAAM,IAAI;EACxB,OAAO,QAAQ,GAAG,OAAO;;EAEzB,WAAW,QAAQ;;;;;EAKnB,aAAa,QAAQ,MAAM,SAAS,MAAM,SAAS;;;;;;;;;;;;;cAcxC,gBAAgB,UAAU,QAAQ,UAAU,QAAQ,qCACvD,qBAAqB,GAAG,cACrB,UAAU,GAAG,GAAG;;UAWjB;UAPF;EAKR,YACE,QAAQ,GACA,MAAM,oBAAoB,GAAG,GAAG;MAKtC,OAAO,IAAI;MAIX,kBAAkB,IAAI;MAItB;EAOJ;MAII,YAAY,SAAS;EAQnB,KAAK;IAAQ;IAAuB;MAA+B,QAAQ,IAAI;MAejF;EAIJ;MAII,MAAM,KAAK;MAIX,WAAW,KAAK;MAIhB,iBAAiB;MAIjB;MAIA;MAIA;EAMJ,IAAI,OAAO;EAaX,YAAY,OAAO;EAKb,0BAA0B;EAChC;;MAGI;MAMA;EAIJ;UAIQ;UAMA;UAIA;GAQP,YAAY;GACZ,YAAY;GACZ,aAAa"}
+{"version":3,"file":"CustomReference.d.mts","names":[],"sources":["../../src/relations/CustomReference.ts"],"mappings":";;;;;;;;;;wBASgB,mBAAmB,UAAU,QAAQ,UAAU,QAAQ,6BACrE,MAAM,oBAAoB,GAAG,GAAG,KAC/B,gBAAgB,GAAG,GAAG;YAMb,oBAAoB,UAAU,QAAQ,UAAU,QAAQ;EAGlE,OAAO,QAAQ,GAAG;IAAQ;QAA4B;EACtD,MAAM,QAAQ,MAAM,IAAI;EACxB,OAAO,QAAQ,GAAG,OAAO;;EAEzB,WAAW,QAAQ;;;;;EAKnB,aAAa,QAAQ,MAAM,SAAS,MAAM,SAAS;;;;;;;;;;;;;qBAcxC,gBAAgB,UAAU,QAAQ,UAAU,QAAQ,qCACvD,qBAAqB,GAAG,cACrB,UAAU,GAAG,GAAG;;UAWjB;UAPF;EAKR,YACE,QAAQ,GACA,MAAM,oBAAoB,GAAG,GAAG;MAKtC,OAAO,IAAI;MAIX,kBAAkB,IAAI;MAItB;EAOJ;MAII,YAAY,SAAS;EAQnB,KAAK;IAAQ;IAAuB;MAA+B,QAAQ,IAAI;MAejF;EAIJ;MAII,MAAM,KAAK;MAIX,WAAW,KAAK;MAIhB,iBAAiB;MAIjB;MAIA;MAIA;EAMJ,IAAI,OAAO;EAaX,YAAY,OAAO;EAKb,0BAA0B;EAChC;;MAGI;MAMA;EAIJ;UAIQ;UAMA;UAIA;GAQP,YAAY;GACZ,YAAY;GACZ,aAAa"}

package/build/relations/CustomReference.js.map

@@ -1 +1 @@
-{"version":3,"file":"CustomReference.js","names":["#isLoaded","#loadHint","#hasBeenSet"],"sources":["../../src/relations/CustomReference.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type IdOf, type TaggedId, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type LoadHint, type Reference, ensureNotDeleted, fail, getMetadata, getProperties } from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractRelationImpl } from \"src/relations/AbstractRelationImpl.ts\";\nimport { ReferenceN } from \"src/relations/ReferenceSymbols.ts\";\nimport { RelationT, RelationU } from \"src/relations/RelationSymbols.ts\";\n\n/** An alias for creating `CustomReference`s. */\nexport function hasCustomReference<T extends Entity, U extends Entity, N extends never | undefined>(\n  opts: CustomReferenceOpts<T, U, N>,\n): CustomReference<T, U, N> {\n  return lazyField((entity: T) => {\n    return new CustomReference<T, U, N>(entity, opts);\n  });\n}\n\nexport type CustomReferenceOpts<T extends Entity, U extends Entity, N extends never | undefined> = {\n  // We purposefully don't capture the return value of `load` b/c we want `get` to re-calc from `entity`\n  // each time it's invoked so that it reflects any changed values.\n  load: (entity: T, opts: { forceReload?: boolean }) => Promise<unknown>;\n  get: (entity: T) => U | N;\n  set?: (entity: T, other: U) => void;\n  /** Whether the reference is loaded, even w/o an explicit `.load` call, i.e. for DeepNew test instances. */\n  isLoaded: (entity: T) => boolean;\n  /**\n   * A load hint that can be used to speculatively traverse the dependencies of this reference.  Currently\n   * only used by em.importEntity and can be omitted if the reference isn't used with it.\n   */\n  loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;\n};\n\n/**\n * Allows user-defined references that will work in `populate` / preload hints.\n *\n * This works because Joist's `populate`/preloading is not based on creating giant SQL joins,\n * but instead by just walking \"1 dataloader per level\". Given this, we don't really care\n * what happens at each \"level\" of resolution, as long as: a) it's a promise, and b) the\n * caller uses dataloader to be batch friendly.\n *\n * This `CustomReference` API is fairly low-level; users should more likely prefer higher-level\n * abstractions like `hasOneThrough`, which are built on `CustomReference.\n */\nexport class CustomReference<T extends Entity, U extends Entity, N extends never | undefined>\n  extends AbstractRelationImpl<T, U>\n  implements Reference<T, U, N>\n{\n  // We keep both a promise+loaded flag and not an actual `this.loaded = await load` because\n  // the value can become stale; we want to each `.get` call to repeatedly evaluate the latest value.\n  private loadPromise: Promise<unknown> | undefined;\n  #hasBeenSet = false;\n  #isLoaded: boolean | undefined;\n  #loadHint: LoadHint<T> | undefined;\n\n  constructor(\n    entity: T,\n    private opts: CustomReferenceOpts<T, U, N>,\n  ) {\n    super(entity);\n  }\n\n  get get(): U | N {\n    return this.doGet({ withDeleted: false });\n  }\n\n  get getWithDeleted(): U | N {\n    return this.doGet({ withDeleted: true });\n  }\n\n  get isLoaded(): boolean {\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.addNaive(this);\n    this.#isLoaded = this.opts.isLoaded(this.entity);\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n  }\n\n  get loadHint(): LoadHint<T> | undefined {\n    if (this.#loadHint === undefined && this.opts.loadHint !== undefined) {\n      const { loadHint } = this.opts;\n      this.#loadHint = typeof loadHint === \"function\" ? loadHint(this.entity) : loadHint;\n    }\n    return this.#loadHint;\n  }\n\n  async load(opts: { withDeleted?: boolean; forceReload?: boolean } = {}): Promise<U | N> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.isLoaded || opts.forceReload) {\n      if (this.loadPromise === undefined) {\n        this.loadPromise = this.opts.load(this.entity, opts);\n        await this.loadPromise;\n        this.loadPromise = undefined;\n        this.#isLoaded = true;\n      } else {\n        await this.loadPromise;\n      }\n    }\n    return this.doGet(opts);\n  }\n\n  get isPreloaded(): boolean {\n    return false;\n  }\n\n  preload(): void {\n    throw new Error(\"Not implemented\");\n  }\n\n  get id(): IdOf<U> {\n    return fail(`CustomReference cannot resolve 'id'`);\n  }\n\n  get idMaybe(): IdOf<U> | undefined {\n    return fail(`CustomReference cannot resolve 'idMaybe'`);\n  }\n\n  get idTaggedMaybe(): TaggedId | undefined {\n    return fail(`CustomReference cannot resolve 'idTaggedMaybe'`);\n  }\n\n  get idUntagged(): string {\n    return fail(`CustomReference cannot resolve 'idUntagged'`);\n  }\n\n  get idUntaggedMaybe(): string | undefined {\n    return fail(`CustomReference cannot resolve 'idUntaggedMaybe'`);\n  }\n\n  get isSet(): boolean {\n    this.ensureNewOrLoaded();\n    const { get } = this.opts;\n    return get(this.entity) !== undefined;\n  }\n\n  set(value: U): void {\n    // We allow setting CustomReferences on new entities w/o being loaded\n    if (!this.entity.isNewEntity) {\n      this.ensureNewOrLoaded();\n    }\n    const { set } = this.opts;\n    if (set === undefined) {\n      throw new Error(`'set' not implemented on ${this}`);\n    }\n    set(this.entity, value);\n    this.#hasBeenSet = true;\n  }\n\n  setFromOpts(value: U): void {\n    this.set(value);\n  }\n\n  // these callbacks should be no-ops as they ought to be handled by the underlying relations\n  async cleanupOnEntityDeleted(): Promise<void> {}\n  maybeCascadeDelete(): void {}\n\n  /** Finds this CustomReferences field name by looking in the entity for the key that we're assigned to. */\n  get fieldName(): string {\n    return Object.entries(getProperties(getMetadata(this.entity))).filter(\n      ([key]) => (this.entity as any)[key] === this,\n    )[0][0];\n  }\n\n  get hasBeenSet() {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `CustomReference(entity: ${this.entity}, fieldName: ${this.fieldName})`;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): U | N {\n    ensureNotDeleted(this.entity, \"pending\");\n    this.ensureNewOrLoaded();\n    return this.filterDeleted(this.opts.get(this.entity), opts);\n  }\n\n  private filterDeleted(entity: U | N, opts?: { withDeleted?: boolean }): U | N {\n    return opts?.withDeleted === true || entity === undefined || !entity.isDeletedEntity ? entity : (undefined as N);\n  }\n\n  private ensureNewOrLoaded() {\n    // This should only be callable in the type system if we've already resolved this to an instance\n    if (this.isLoaded) {\n      return;\n    }\n    fail(`${this.entity}.${this.fieldName} was not loaded`);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n  [ReferenceN]: N = null!;\n}\n"],"mappings":"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"}
+{"version":3,"file":"CustomReference.js","names":[],"sources":["../../src/relations/CustomReference.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type IdOf, type TaggedId, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type LoadHint, type Reference, ensureNotDeleted, fail, getMetadata, getProperties } from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractRelationImpl } from \"src/relations/AbstractRelationImpl.ts\";\nimport { ReferenceN } from \"src/relations/ReferenceSymbols.ts\";\nimport { RelationT, RelationU } from \"src/relations/RelationSymbols.ts\";\n\n/** An alias for creating `CustomReference`s. */\nexport function hasCustomReference<T extends Entity, U extends Entity, N extends never | undefined>(\n  opts: CustomReferenceOpts<T, U, N>,\n): CustomReference<T, U, N> {\n  return lazyField((entity: T) => {\n    return new CustomReference<T, U, N>(entity, opts);\n  });\n}\n\nexport type CustomReferenceOpts<T extends Entity, U extends Entity, N extends never | undefined> = {\n  // We purposefully don't capture the return value of `load` b/c we want `get` to re-calc from `entity`\n  // each time it's invoked so that it reflects any changed values.\n  load: (entity: T, opts: { forceReload?: boolean }) => Promise<unknown>;\n  get: (entity: T) => U | N;\n  set?: (entity: T, other: U) => void;\n  /** Whether the reference is loaded, even w/o an explicit `.load` call, i.e. for DeepNew test instances. */\n  isLoaded: (entity: T) => boolean;\n  /**\n   * A load hint that can be used to speculatively traverse the dependencies of this reference.  Currently\n   * only used by em.importEntity and can be omitted if the reference isn't used with it.\n   */\n  loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;\n};\n\n/**\n * Allows user-defined references that will work in `populate` / preload hints.\n *\n * This works because Joist's `populate`/preloading is not based on creating giant SQL joins,\n * but instead by just walking \"1 dataloader per level\". Given this, we don't really care\n * what happens at each \"level\" of resolution, as long as: a) it's a promise, and b) the\n * caller uses dataloader to be batch friendly.\n *\n * This `CustomReference` API is fairly low-level; users should more likely prefer higher-level\n * abstractions like `hasOneThrough`, which are built on `CustomReference.\n */\nexport class CustomReference<T extends Entity, U extends Entity, N extends never | undefined>\n  extends AbstractRelationImpl<T, U>\n  implements Reference<T, U, N>\n{\n  // We keep both a promise+loaded flag and not an actual `this.loaded = await load` because\n  // the value can become stale; we want to each `.get` call to repeatedly evaluate the latest value.\n  private loadPromise: Promise<unknown> | undefined;\n  #hasBeenSet = false;\n  #isLoaded: boolean | undefined;\n  #loadHint: LoadHint<T> | undefined;\n\n  constructor(\n    entity: T,\n    private opts: CustomReferenceOpts<T, U, N>,\n  ) {\n    super(entity);\n  }\n\n  get get(): U | N {\n    return this.doGet({ withDeleted: false });\n  }\n\n  get getWithDeleted(): U | N {\n    return this.doGet({ withDeleted: true });\n  }\n\n  get isLoaded(): boolean {\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.addNaive(this);\n    this.#isLoaded = this.opts.isLoaded(this.entity);\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n  }\n\n  get loadHint(): LoadHint<T> | undefined {\n    if (this.#loadHint === undefined && this.opts.loadHint !== undefined) {\n      const { loadHint } = this.opts;\n      this.#loadHint = typeof loadHint === \"function\" ? loadHint(this.entity) : loadHint;\n    }\n    return this.#loadHint;\n  }\n\n  async load(opts: { withDeleted?: boolean; forceReload?: boolean } = {}): Promise<U | N> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.isLoaded || opts.forceReload) {\n      if (this.loadPromise === undefined) {\n        this.loadPromise = this.opts.load(this.entity, opts);\n        await this.loadPromise;\n        this.loadPromise = undefined;\n        this.#isLoaded = true;\n      } else {\n        await this.loadPromise;\n      }\n    }\n    return this.doGet(opts);\n  }\n\n  get isPreloaded(): boolean {\n    return false;\n  }\n\n  preload(): void {\n    throw new Error(\"Not implemented\");\n  }\n\n  get id(): IdOf<U> {\n    return fail(`CustomReference cannot resolve 'id'`);\n  }\n\n  get idMaybe(): IdOf<U> | undefined {\n    return fail(`CustomReference cannot resolve 'idMaybe'`);\n  }\n\n  get idTaggedMaybe(): TaggedId | undefined {\n    return fail(`CustomReference cannot resolve 'idTaggedMaybe'`);\n  }\n\n  get idUntagged(): string {\n    return fail(`CustomReference cannot resolve 'idUntagged'`);\n  }\n\n  get idUntaggedMaybe(): string | undefined {\n    return fail(`CustomReference cannot resolve 'idUntaggedMaybe'`);\n  }\n\n  get isSet(): boolean {\n    this.ensureNewOrLoaded();\n    const { get } = this.opts;\n    return get(this.entity) !== undefined;\n  }\n\n  set(value: U): void {\n    // We allow setting CustomReferences on new entities w/o being loaded\n    if (!this.entity.isNewEntity) {\n      this.ensureNewOrLoaded();\n    }\n    const { set } = this.opts;\n    if (set === undefined) {\n      throw new Error(`'set' not implemented on ${this}`);\n    }\n    set(this.entity, value);\n    this.#hasBeenSet = true;\n  }\n\n  setFromOpts(value: U): void {\n    this.set(value);\n  }\n\n  // these callbacks should be no-ops as they ought to be handled by the underlying relations\n  async cleanupOnEntityDeleted(): Promise<void> {}\n  maybeCascadeDelete(): void {}\n\n  /** Finds this CustomReferences field name by looking in the entity for the key that we're assigned to. */\n  get fieldName(): string {\n    return Object.entries(getProperties(getMetadata(this.entity))).filter(\n      ([key]) => (this.entity as any)[key] === this,\n    )[0][0];\n  }\n\n  get hasBeenSet() {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `CustomReference(entity: ${this.entity}, fieldName: ${this.fieldName})`;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): U | N {\n    ensureNotDeleted(this.entity, \"pending\");\n    this.ensureNewOrLoaded();\n    return this.filterDeleted(this.opts.get(this.entity), opts);\n  }\n\n  private filterDeleted(entity: U | N, opts?: { withDeleted?: boolean }): U | N {\n    return opts?.withDeleted === true || entity === undefined || !entity.isDeletedEntity ? entity : (undefined as N);\n  }\n\n  private ensureNewOrLoaded() {\n    // This should only be callable in the type system if we've already resolved this to an instance\n    if (this.isLoaded) {\n      return;\n    }\n    fail(`${this.entity}.${this.fieldName} was not loaded`);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n  [ReferenceN]: N = null!;\n}\n"],"mappings":";;;;;;;;;;;;AASA,SAAgB,mBACd,MAC0B;CAC1B,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,gBAAyB,QAAQ,IAAI;CAClD,CAAC;AACH;;;;;;;;;;;;AA4BA,IAAa,kBAAb,cACU,qBAEV;CAUY;CAPV;CACA,cAAc;CACd;CACA;CAEA,YACE,QACA,MACA;EACA,MAAM,MAAM;EAFJ,KAAA,OAAA;CAGV;CAEA,IAAI,MAAa;EACf,OAAO,KAAK,MAAM,EAAE,aAAa,MAAM,CAAC;CAC1C;CAEA,IAAI,iBAAwB;EAC1B,OAAO,KAAK,MAAM,EAAE,aAAa,KAAK,CAAC;CACzC;CAEA,IAAI,WAAoB;EACtB,IAAI,KAAK,cAAc,KAAA,GAAW,OAAO,KAAK;EAC9C,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,SAAS,IAAI;EAC5D,KAAK,YAAY,KAAK,KAAK,SAAS,KAAK,MAAM;EAC/C,OAAO,KAAK;CACd;CAEA,gBAAsB;EACpB,KAAK,YAAY,KAAA;CACnB;CAEA,IAAI,WAAoC;EACtC,IAAI,KAAK,cAAc,KAAA,KAAa,KAAK,KAAK,aAAa,KAAA,GAAW;GACpE,MAAM,EAAE,aAAa,KAAK;GAC1B,KAAK,YAAY,OAAO,aAAa,aAAa,SAAS,KAAK,MAAM,IAAI;EAC5E;EACA,OAAO,KAAK;CACd;CAEA,MAAM,KAAK,OAAyD,CAAC,GAAmB;EACtF,iBAAiB,KAAK,QAAQ,SAAS;EACvC,IAAI,CAAC,KAAK,YAAY,KAAK,aAAa;GACtC,IAAI,KAAK,gBAAgB,KAAA,GAAW;IAClC,KAAK,cAAc,KAAK,KAAK,KAAK,KAAK,QAAQ,IAAI;IACnD,MAAM,KAAK;IACX,KAAK,cAAc,KAAA;IACnB,KAAK,YAAY;GACnB,OACE,MAAM,KAAK;EAEf;EACA,OAAO,KAAK,MAAM,IAAI;CACxB;CAEA,IAAI,cAAuB;EACzB,OAAO;CACT;CAEA,UAAgB;EACd,MAAM,IAAI,MAAM,iBAAiB;CACnC;CAEA,IAAI,KAAc;EAChB,OAAO,KAAK,qCAAqC;CACnD;CAEA,IAAI,UAA+B;EACjC,OAAO,KAAK,0CAA0C;CACxD;CAEA,IAAI,gBAAsC;EACxC,OAAO,KAAK,gDAAgD;CAC9D;CAEA,IAAI,aAAqB;EACvB,OAAO,KAAK,6CAA6C;CAC3D;CAEA,IAAI,kBAAsC;EACxC,OAAO,KAAK,kDAAkD;CAChE;CAEA,IAAI,QAAiB;EACnB,KAAK,kBAAkB;EACvB,MAAM,EAAE,QAAQ,KAAK;EACrB,OAAO,IAAI,KAAK,MAAM,MAAM,KAAA;CAC9B;CAEA,IAAI,OAAgB;EAElB,IAAI,CAAC,KAAK,OAAO,aACf,KAAK,kBAAkB;EAEzB,MAAM,EAAE,QAAQ,KAAK;EACrB,IAAI,QAAQ,KAAA,GACV,MAAM,IAAI,MAAM,4BAA4B,MAAM;EAEpD,IAAI,KAAK,QAAQ,KAAK;EACtB,KAAK,cAAc;CACrB;CAEA,YAAY,OAAgB;EAC1B,KAAK,IAAI,KAAK;CAChB;CAGA,MAAM,yBAAwC,CAAC;CAC/C,qBAA2B,CAAC;;CAG5B,IAAI,YAAoB;EACtB,OAAO,OAAO,QAAQ,cAAc,YAAY,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,QAC5D,CAAC,SAAU,KAAK,OAAe,SAAS,IAC3C,CAAC,CAAC,EAAE,CAAC;CACP;CAEA,IAAI,aAAa;EACf,OAAO,KAAK;CACd;CAEA,WAAmB;EACjB,OAAO,2BAA2B,KAAK,OAAO,eAAe,KAAK,UAAU;CAC9E;CAEA,MAAc,MAAyC;EACrD,iBAAiB,KAAK,QAAQ,SAAS;EACvC,KAAK,kBAAkB;EACvB,OAAO,KAAK,cAAc,KAAK,KAAK,IAAI,KAAK,MAAM,GAAG,IAAI;CAC5D;CAEA,cAAsB,QAAe,MAAyC;EAC5E,OAAO,MAAM,gBAAgB,QAAQ,WAAW,KAAA,KAAa,CAAC,OAAO,kBAAkB,SAAU,KAAA;CACnG;CAEA,oBAA4B;EAE1B,IAAI,KAAK,UACP;EAEF,KAAK,GAAG,KAAK,OAAO,GAAG,KAAK,UAAU,gBAAgB;CACxD;CAEA,CAAC,aAAgB;CACjB,CAAC,aAAgB;CACjB,CAAC,cAAiB;AACpB"}

package/build/relations/EnumCollection.cjs.map

@@ -1 +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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"}
+{"version":3,"file":"EnumCollection.cjs","names":["lazyField","getMetadata","AbstractRelationImpl","getInstanceData","enumCollectionBatchLoader","appendStack","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

@@ -14,7 +14,7 @@ declare const enumCollectionTag: unique symbol;
  * 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> {
+export interface EnumCollection<T extends Entity, E> {
   [enumCollectionTag]: true;
   [RelationT]: T;
   [RelationU]: E;
@@ -35,13 +35,13 @@ interface EnumCollection<T extends Entity, E> {
   readonly hasBeenSet: boolean;
 }
 /** Adds a known-safe `get` accessor. */
-interface LoadedEnumCollection<T extends Entity, E> extends EnumCollection<T, E> {
+export 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 {
+export declare function hasEnumCollection<T extends Entity, E>(): EnumCollection<T, E>;
+export 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?: {
@@ -82,5 +82,5 @@ declare class EnumCollectionImpl<T extends Entity, E> extends AbstractRelationIm
   [RelationU]: E;
 }
 //#endregion
-export { EnumCollection, EnumCollectionImpl, LoadedEnumCollection, hasEnumCollection };
+export {};
 //# sourceMappingURL=EnumCollection.d.cts.map

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

@@ -1 +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"}
+{"version":3,"file":"EnumCollection.d.cts","names":[],"sources":["../../src/relations/EnumCollection.ts"],"mappings":";;;;;;;;;cAoBc;;;;;;;iBAQG,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;;;iBAIM,qBAAqB,UAAU,QAAQ,WAAW,eAAe,GAAG;EACnF,KAAK,cAAc;EAEnB;;;wBAIc,kBAAkB,UAAU,QAAQ,MAAM,eAAe,GAAG;qBAO/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"}