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

package/build/relations/Reference.d.mts

@@ -12,7 +12,7 @@ import { Entity } from "../Entity.mjs";
  * `U | undefined`. If it is not optional, `N` will be `never`, making the return types
  * `U | never` which becomes just `U`.
  */
-interface Reference<T extends Entity, U extends Entity, N extends never | undefined> extends Relation<T, U> {
+export interface Reference<T extends Entity, U extends Entity, N extends never | undefined> extends Relation<T, U> {
   [ReferenceN]: N;
   readonly isLoaded: boolean;
   load(opts?: {
@@ -24,16 +24,16 @@ interface Reference<T extends Entity, U extends Entity, N extends never | undefi
   idTaggedMaybe: TaggedId | undefined;
 }
 /** Adds a known-safe `get` accessor. */
-interface LoadedReference<T extends Entity, U extends Entity, N extends never | undefined> extends Reference<T, U, N> {
+export interface LoadedReference<T extends Entity, U extends Entity, N extends never | undefined> extends Reference<T, U, N> {
   id: IdOf<U> | N;
   get: U | N;
   getWithDeleted: U | N;
   isSet: boolean;
 }
 /** Type guard utility for determining if an entity field is a Reference. */
-declare function isReference(maybeReference: any): maybeReference is Reference<any, any, any>;
+export declare function isReference(maybeReference: any): maybeReference is Reference<any, any, any>;
 /** Type guard utility for determining if an entity field is a loaded Reference. */
-declare function isLoadedReference(maybeReference: any): maybeReference is Reference<any, any, any> & LoadedReference<any, any, any>;
+export declare function isLoadedReference(maybeReference: any): maybeReference is Reference<any, any, any> & LoadedReference<any, any, any>;
 //#endregion
-export { LoadedReference, Reference, ReferenceN, isLoadedReference, isReference };
+export { ReferenceN };
 //# sourceMappingURL=Reference.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Reference.d.mts","names":[],"sources":["../../src/relations/Reference.ts"],"mappings":";;;;;;;;;;;;;;UAsBiB,UAAU,UAAU,QAAQ,UAAU,QAAQ,qCAAqC,SAAS,GAAG;GAC7G,aAAa;WAGL;EAET,KAAK;IAAS;IAAuB;MAAuB,QAAQ,IAAI;EAExE,IAAI,OAAO,IAAI;;EAGf,eAAe;;;UAIA,gBAAgB,UAAU,QAAQ,UAAU,QAAQ,qCAAqC,UACxG,GACA,GACA;EASA,IAAI,KAAK,KAAK;EAEd,KAAK,IAAI;EAET,gBAAgB,IAAI;EAIpB;;;iBAIc,YAAY,sBAAsB,kBAAkB;;iBAWpD,kBACd,sBACC,kBAAkB,2BAA2B"}
+{"version":3,"file":"Reference.d.mts","names":[],"sources":["../../src/relations/Reference.ts"],"mappings":";;;;;;;;;;;;;;iBAsBiB,UAAU,UAAU,QAAQ,UAAU,QAAQ,qCAAqC,SAAS,GAAG;GAC7G,aAAa;WAGL;EAET,KAAK;IAAS;IAAuB;MAAuB,QAAQ,IAAI;EAExE,IAAI,OAAO,IAAI;;EAGf,eAAe;;;iBAIA,gBAAgB,UAAU,QAAQ,UAAU,QAAQ,qCAAqC,UACxG,GACA,GACA;EASA,IAAI,KAAK,KAAK;EAEd,KAAK,IAAI;EAET,gBAAgB,IAAI;EAIpB;;;wBAIc,YAAY,sBAAsB,kBAAkB;;wBAWpD,kBACd,sBACC,kBAAkB,2BAA2B"}

package/build/relations/ReferenceSymbols.d.cts

@@ -1,5 +1,4 @@
 //#region src/relations/ReferenceSymbols.d.ts
-declare const ReferenceN: unique symbol;
+export declare const ReferenceN: unique symbol;
 //#endregion
-export { ReferenceN };
 //# sourceMappingURL=ReferenceSymbols.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ReferenceSymbols.d.cts","names":[],"sources":["../../src/relations/ReferenceSymbols.ts"],"mappings":";cACa"}
+{"version":3,"file":"ReferenceSymbols.d.cts","names":[],"sources":["../../src/relations/ReferenceSymbols.ts"],"mappings":";qBACa"}

package/build/relations/ReferenceSymbols.d.mts

@@ -1,5 +1,4 @@
 //#region src/relations/ReferenceSymbols.d.ts
-declare const ReferenceN: unique symbol;
+export declare const ReferenceN: unique symbol;
 //#endregion
-export { ReferenceN };
 //# sourceMappingURL=ReferenceSymbols.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ReferenceSymbols.d.mts","names":[],"sources":["../../src/relations/ReferenceSymbols.ts"],"mappings":";cACa"}
+{"version":3,"file":"ReferenceSymbols.d.mts","names":[],"sources":["../../src/relations/ReferenceSymbols.ts"],"mappings":";qBACa"}

package/build/relations/Relation.d.cts

@@ -2,7 +2,7 @@ import { RelationT, RelationU } from "./RelationSymbols.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/Relation.d.ts
 /** A relationship from `T` to `U`, could be any of many-to-one, one-to-many, or many-to-many. */
-interface Relation<T extends Entity, U extends Entity> {
+export interface Relation<T extends Entity, U extends Entity> {
   [RelationT]: T;
   [RelationU]: U;
   isLoaded: boolean;
@@ -10,7 +10,7 @@ interface Relation<T extends Entity, U extends Entity> {
   hasBeenSet: boolean;
 }
 /** Type guard utility for determining if an entity field is a Relation. */
-declare function isRelation(maybeRelation: any): maybeRelation is Relation<any, any>;
+export declare function isRelation(maybeRelation: any): maybeRelation is Relation<any, any>;
 //#endregion
-export { Relation, RelationT, RelationU, isRelation };
+export { RelationT, RelationU };
 //# sourceMappingURL=Relation.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Relation.d.cts","names":[],"sources":["../../src/relations/Relation.ts"],"mappings":";;;;UAOiB,SAAS,UAAU,QAAQ,UAAU;GAOnD,YAAY;GACZ,YAAY;EACb;EACA,QAAQ;EACR;;;iBAIc,WAAW,qBAAqB,iBAAiB"}
+{"version":3,"file":"Relation.d.cts","names":[],"sources":["../../src/relations/Relation.ts"],"mappings":";;;;iBAOiB,SAAS,UAAU,QAAQ,UAAU;GAOnD,YAAY;GACZ,YAAY;EACb;EACA,QAAQ;EACR;;;wBAIc,WAAW,qBAAqB,iBAAiB"}

package/build/relations/Relation.d.mts

@@ -2,7 +2,7 @@ import { RelationT, RelationU } from "./RelationSymbols.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/Relation.d.ts
 /** A relationship from `T` to `U`, could be any of many-to-one, one-to-many, or many-to-many. */
-interface Relation<T extends Entity, U extends Entity> {
+export interface Relation<T extends Entity, U extends Entity> {
   [RelationT]: T;
   [RelationU]: U;
   isLoaded: boolean;
@@ -10,7 +10,7 @@ interface Relation<T extends Entity, U extends Entity> {
   hasBeenSet: boolean;
 }
 /** Type guard utility for determining if an entity field is a Relation. */
-declare function isRelation(maybeRelation: any): maybeRelation is Relation<any, any>;
+export declare function isRelation(maybeRelation: any): maybeRelation is Relation<any, any>;
 //#endregion
-export { Relation, RelationT, RelationU, isRelation };
+export { RelationT, RelationU };
 //# sourceMappingURL=Relation.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Relation.d.mts","names":[],"sources":["../../src/relations/Relation.ts"],"mappings":";;;;UAOiB,SAAS,UAAU,QAAQ,UAAU;GAOnD,YAAY;GACZ,YAAY;EACb;EACA,QAAQ;EACR;;;iBAIc,WAAW,qBAAqB,iBAAiB"}
+{"version":3,"file":"Relation.d.mts","names":[],"sources":["../../src/relations/Relation.ts"],"mappings":";;;;iBAOiB,SAAS,UAAU,QAAQ,UAAU;GAOnD,YAAY;GACZ,YAAY;EACb;EACA,QAAQ;EACR;;;wBAIc,WAAW,qBAAqB,iBAAiB"}

package/build/relations/RelationSymbols.d.cts

@@ -1,6 +1,5 @@
 //#region src/relations/RelationSymbols.d.ts
-declare const RelationT: unique symbol;
-declare const RelationU: unique symbol;
+export declare const RelationT: unique symbol;
+export declare const RelationU: unique symbol;
 //#endregion
-export { RelationT, RelationU };
 //# sourceMappingURL=RelationSymbols.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"RelationSymbols.d.cts","names":[],"sources":["../../src/relations/RelationSymbols.ts"],"mappings":";cAAa;cACA"}
+{"version":3,"file":"RelationSymbols.d.cts","names":[],"sources":["../../src/relations/RelationSymbols.ts"],"mappings":";qBAAa;qBACA"}

package/build/relations/RelationSymbols.d.mts

@@ -1,6 +1,5 @@
 //#region src/relations/RelationSymbols.d.ts
-declare const RelationT: unique symbol;
-declare const RelationU: unique symbol;
+export declare const RelationT: unique symbol;
+export declare const RelationU: unique symbol;
 //#endregion
-export { RelationT, RelationU };
 //# sourceMappingURL=RelationSymbols.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"RelationSymbols.d.mts","names":[],"sources":["../../src/relations/RelationSymbols.ts"],"mappings":";cAAa;cACA"}
+{"version":3,"file":"RelationSymbols.d.mts","names":[],"sources":["../../src/relations/RelationSymbols.ts"],"mappings":";qBAAa;qBACA"}

package/build/relations/hasAsyncMethod.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hasAsyncMethod.cjs","names":["lazyField","#entity","#hint","isLoaded"],"sources":["../../src/relations/hasAsyncMethod.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"src/loading/loadHints.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\n\nconst AsyncMethodM = Symbol();\nexport const AsyncMethodPopulateSecret = Symbol();\n\nexport interface AsyncMethod<T extends Entity, A extends unknown[], V> {\n  // To differentiate from AsyncProperties\n  [AsyncMethodM]: undefined;\n  isLoaded: boolean;\n  load(...args: A): Promise<V>;\n}\n\nexport interface LoadedMethod<T extends Entity, A extends unknown[], V> {\n  call(...args: A): V;\n}\n\nexport function hasAsyncMethod<T extends Entity, const H extends LoadHint<T>, A extends unknown[], V>(\n  loadHint: H,\n  fn: (entity: Loaded<T, H>, ...args: A) => V,\n): AsyncMethod<T, A, V> {\n  return lazyField((entity: T) => {\n    return new AsyncMethodImpl(entity, loadHint, fn);\n  });\n}\n\nexport class AsyncMethodImpl<T extends Entity, H extends LoadHint<T>, A extends unknown[], V> implements AsyncMethod<\n  T,\n  A,\n  V\n> {\n  private loaded = false;\n  private loadPromise: Promise<any> | undefined;\n\n  readonly #entity: T;\n  readonly #hint: H;\n  constructor(\n    entity: T,\n    hint: H,\n    private fn: (entity: Loaded<T, H>, ...args: A) => V,\n  ) {\n    this.#entity = entity;\n    this.#hint = hint;\n  }\n\n  /** Args might be either the user-provided args, or the populate `opts` if we're being preloaded. */\n  async load(...args: A): Promise<V> {\n    // Are we being called by `em.populate`? If so, we don't have the real args, so avoid invoking fn\n    const isPopulate = args && typeof args[0] === \"object\" && AsyncMethodPopulateSecret in (args as any)[0];\n    if (!this.loaded) {\n      this.loadPromise ??= this.#entity.em.populate(this.#entity, this.#hint!).then((loaded) => (this.loaded = true));\n      await this.loadPromise;\n    }\n    return isPopulate ? (undefined as any) : this.call(...args);\n  }\n\n  call(...args: A): V {\n    if (!this.isLoaded) {\n      throw new Error(\"hasAsyncMethod.call was called but not loaded\");\n    }\n    return this.fn(this.#entity as Loaded<T, H>, ...args);\n  }\n\n  get isLoaded() {\n    return this.loaded || isLoaded(this.#entity, this.#hint);\n  }\n\n  [AsyncMethodM]: undefined;\n}\n"],"mappings":";;;;;AAIA,MAAM,eAAe,OAAO;AAC5B,MAAa,4BAA4B,OAAO;AAahD,SAAgB,eACd,UACA,IACsB;CACtB,OAAOA,kBAAAA,WAAW,WAAc;EAC9B,OAAO,IAAI,gBAAgB,QAAQ,UAAU,EAAE;CACjD,CAAC;AACH;AAEA,IAAa,kBAAb,MAIE;CASU;CARV,SAAiB;CACjB;CAEA;CACA;CACA,YACE,QACA,MACA,IACA;EADQ,KAAA,KAAA;EAER,KAAKC,UAAU;EACf,KAAKC,QAAQ;CACf;;CAGA,MAAM,KAAK,GAAG,MAAqB;EAEjC,MAAM,aAAa,QAAQ,OAAO,KAAK,OAAO,YAAY,6BAA8B,KAAa;EACrG,IAAI,CAAC,KAAK,QAAQ;GAChB,KAAK,gBAAgB,KAAKD,QAAQ,GAAG,SAAS,KAAKA,SAAS,KAAKC,KAAM,CAAC,CAAC,MAAM,WAAY,KAAK,SAAS,IAAK;GAC9G,MAAM,KAAK;EACb;EACA,OAAO,aAAc,KAAA,IAAoB,KAAK,KAAK,GAAG,IAAI;CAC5D;CAEA,KAAK,GAAG,MAAY;EAClB,IAAI,CAAC,KAAK,UACR,MAAM,IAAI,MAAM,+CAA+C;EAEjE,OAAO,KAAK,GAAG,KAAKD,SAAyB,GAAG,IAAI;CACtD;CAEA,IAAI,WAAW;EACb,OAAO,KAAK,UAAUE,0BAAAA,SAAS,KAAKF,SAAS,KAAKC,KAAK;CACzD;CAEA,CAAC;AACH"}
+{"version":3,"file":"hasAsyncMethod.cjs","names":["lazyField","isLoaded"],"sources":["../../src/relations/hasAsyncMethod.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"src/loading/loadHints.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\n\nconst AsyncMethodM = Symbol();\nexport const AsyncMethodPopulateSecret = Symbol();\n\nexport interface AsyncMethod<T extends Entity, A extends unknown[], V> {\n  // To differentiate from AsyncProperties\n  [AsyncMethodM]: undefined;\n  isLoaded: boolean;\n  load(...args: A): Promise<V>;\n}\n\nexport interface LoadedMethod<T extends Entity, A extends unknown[], V> {\n  call(...args: A): V;\n}\n\nexport function hasAsyncMethod<T extends Entity, const H extends LoadHint<T>, A extends unknown[], V>(\n  loadHint: H,\n  fn: (entity: Loaded<T, H>, ...args: A) => V,\n): AsyncMethod<T, A, V> {\n  return lazyField((entity: T) => {\n    return new AsyncMethodImpl(entity, loadHint, fn);\n  });\n}\n\nexport class AsyncMethodImpl<T extends Entity, H extends LoadHint<T>, A extends unknown[], V> implements AsyncMethod<\n  T,\n  A,\n  V\n> {\n  private loaded = false;\n  private loadPromise: Promise<any> | undefined;\n\n  readonly #entity: T;\n  readonly #hint: H;\n  constructor(\n    entity: T,\n    hint: H,\n    private fn: (entity: Loaded<T, H>, ...args: A) => V,\n  ) {\n    this.#entity = entity;\n    this.#hint = hint;\n  }\n\n  /** Args might be either the user-provided args, or the populate `opts` if we're being preloaded. */\n  async load(...args: A): Promise<V> {\n    // Are we being called by `em.populate`? If so, we don't have the real args, so avoid invoking fn\n    const isPopulate = args && typeof args[0] === \"object\" && AsyncMethodPopulateSecret in (args as any)[0];\n    if (!this.loaded) {\n      this.loadPromise ??= this.#entity.em.populate(this.#entity, this.#hint!).then((loaded) => (this.loaded = true));\n      await this.loadPromise;\n    }\n    return isPopulate ? (undefined as any) : this.call(...args);\n  }\n\n  call(...args: A): V {\n    if (!this.isLoaded) {\n      throw new Error(\"hasAsyncMethod.call was called but not loaded\");\n    }\n    return this.fn(this.#entity as Loaded<T, H>, ...args);\n  }\n\n  get isLoaded() {\n    return this.loaded || isLoaded(this.#entity, this.#hint);\n  }\n\n  [AsyncMethodM]: undefined;\n}\n"],"mappings":";;;;;AAIA,MAAM,eAAe,OAAO;AAC5B,MAAa,4BAA4B,OAAO;AAahD,SAAgB,eACd,UACA,IACsB;CACtB,OAAOA,kBAAAA,WAAW,WAAc;EAC9B,OAAO,IAAI,gBAAgB,QAAQ,UAAU,EAAE;CACjD,CAAC;AACH;AAEA,IAAa,kBAAb,MAIE;CASU;CARV,SAAiB;CACjB;CAEA;CACA;CACA,YACE,QACA,MACA,IACA;EADQ,KAAA,KAAA;EAER,KAAK,UAAU;EACf,KAAK,QAAQ;CACf;;CAGA,MAAM,KAAK,GAAG,MAAqB;EAEjC,MAAM,aAAa,QAAQ,OAAO,KAAK,OAAO,YAAY,6BAA8B,KAAa;EACrG,IAAI,CAAC,KAAK,QAAQ;GAChB,KAAK,gBAAgB,KAAK,QAAQ,GAAG,SAAS,KAAK,SAAS,KAAK,KAAM,CAAC,CAAC,MAAM,WAAY,KAAK,SAAS,IAAK;GAC9G,MAAM,KAAK;EACb;EACA,OAAO,aAAc,KAAA,IAAoB,KAAK,KAAK,GAAG,IAAI;CAC5D;CAEA,KAAK,GAAG,MAAY;EAClB,IAAI,CAAC,KAAK,UACR,MAAM,IAAI,MAAM,+CAA+C;EAEjE,OAAO,KAAK,GAAG,KAAK,SAAyB,GAAG,IAAI;CACtD;CAEA,IAAI,WAAW;EACb,OAAO,KAAK,UAAUC,0BAAAA,SAAS,KAAK,SAAS,KAAK,KAAK;CACzD;CAEA,CAAC;AACH"}

package/build/relations/hasAsyncMethod.d.cts

@@ -2,17 +2,17 @@ import { LoadHint, Loaded } from "../loading/loadHints.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/hasAsyncMethod.d.ts
 declare const AsyncMethodM: unique symbol;
-declare const AsyncMethodPopulateSecret: unique symbol;
-interface AsyncMethod<T extends Entity, A extends unknown[], V> {
+export declare const AsyncMethodPopulateSecret: unique symbol;
+export interface AsyncMethod<T extends Entity, A extends unknown[], V> {
   [AsyncMethodM]: undefined;
   isLoaded: boolean;
   load(...args: A): Promise<V>;
 }
-interface LoadedMethod<T extends Entity, A extends unknown[], V> {
+export interface LoadedMethod<T extends Entity, A extends unknown[], V> {
   call(...args: A): V;
 }
-declare function hasAsyncMethod<T extends Entity, const H extends LoadHint<T>, A extends unknown[], V>(loadHint: H, fn: (entity: Loaded<T, H>, ...args: A) => V): AsyncMethod<T, A, V>;
-declare class AsyncMethodImpl<T extends Entity, H extends LoadHint<T>, A extends unknown[], V> implements AsyncMethod<T, A, V> {
+export declare function hasAsyncMethod<T extends Entity, const H extends LoadHint<T>, A extends unknown[], V>(loadHint: H, fn: (entity: Loaded<T, H>, ...args: A) => V): AsyncMethod<T, A, V>;
+export declare class AsyncMethodImpl<T extends Entity, H extends LoadHint<T>, A extends unknown[], V> implements AsyncMethod<T, A, V> {
   #private;
   private fn;
   private loaded;
@@ -25,5 +25,5 @@ declare class AsyncMethodImpl<T extends Entity, H extends LoadHint<T>, A extends
   [AsyncMethodM]: undefined;
 }
 //#endregion
-export { AsyncMethod, AsyncMethodImpl, AsyncMethodPopulateSecret, LoadedMethod, hasAsyncMethod };
+export {};
 //# sourceMappingURL=hasAsyncMethod.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hasAsyncMethod.d.cts","names":[],"sources":["../../src/relations/hasAsyncMethod.ts"],"mappings":";;;cAIM;cACO;UAEI,YAAY,UAAU,QAAQ,qBAAqB;GAEjE;EACD;EACA,QAAQ,MAAM,IAAI,QAAQ;;UAGX,aAAa,UAAU,QAAQ,qBAAqB;EACnE,QAAQ,MAAM,IAAI;;iBAGJ,eAAe,UAAU,cAAc,UAAU,SAAS,IAAI,qBAAqB,GACjG,UAAU,GACV,KAAK,QAAQ,OAAO,GAAG,OAAO,MAAM,MAAM,IACzC,YAAY,GAAG,GAAG;cAMR,gBAAgB,UAAU,QAAQ,UAAU,SAAS,IAAI,qBAAqB,cAAc,YACvG,GACA,GACA;;UAUU;UARF;UACA;EAIR,YACE,QAAQ,GACR,MAAM,GACE,KAAK,QAAQ,OAAO,GAAG,OAAO,MAAM,MAAM;;EAO9C,QAAQ,MAAM,IAAI,QAAQ;EAUhC,QAAQ,MAAM,IAAI;MAOd;GAIH"}
+{"version":3,"file":"hasAsyncMethod.d.cts","names":[],"sources":["../../src/relations/hasAsyncMethod.ts"],"mappings":";;;cAIM;qBACO;iBAEI,YAAY,UAAU,QAAQ,qBAAqB;GAEjE;EACD;EACA,QAAQ,MAAM,IAAI,QAAQ;;iBAGX,aAAa,UAAU,QAAQ,qBAAqB;EACnE,QAAQ,MAAM,IAAI;;wBAGJ,eAAe,UAAU,cAAc,UAAU,SAAS,IAAI,qBAAqB,GACjG,UAAU,GACV,KAAK,QAAQ,OAAO,GAAG,OAAO,MAAM,MAAM,IACzC,YAAY,GAAG,GAAG;qBAMR,gBAAgB,UAAU,QAAQ,UAAU,SAAS,IAAI,qBAAqB,cAAc,YACvG,GACA,GACA;;UAUU;UARF;UACA;EAIR,YACE,QAAQ,GACR,MAAM,GACE,KAAK,QAAQ,OAAO,GAAG,OAAO,MAAM,MAAM;;EAO9C,QAAQ,MAAM,IAAI,QAAQ;EAUhC,QAAQ,MAAM,IAAI;MAOd;GAIH"}

package/build/relations/hasAsyncMethod.d.mts

@@ -2,17 +2,17 @@ import { LoadHint, Loaded } from "../loading/loadHints.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/hasAsyncMethod.d.ts
 declare const AsyncMethodM: unique symbol;
-declare const AsyncMethodPopulateSecret: unique symbol;
-interface AsyncMethod<T extends Entity, A extends unknown[], V> {
+export declare const AsyncMethodPopulateSecret: unique symbol;
+export interface AsyncMethod<T extends Entity, A extends unknown[], V> {
   [AsyncMethodM]: undefined;
   isLoaded: boolean;
   load(...args: A): Promise<V>;
 }
-interface LoadedMethod<T extends Entity, A extends unknown[], V> {
+export interface LoadedMethod<T extends Entity, A extends unknown[], V> {
   call(...args: A): V;
 }
-declare function hasAsyncMethod<T extends Entity, const H extends LoadHint<T>, A extends unknown[], V>(loadHint: H, fn: (entity: Loaded<T, H>, ...args: A) => V): AsyncMethod<T, A, V>;
-declare class AsyncMethodImpl<T extends Entity, H extends LoadHint<T>, A extends unknown[], V> implements AsyncMethod<T, A, V> {
+export declare function hasAsyncMethod<T extends Entity, const H extends LoadHint<T>, A extends unknown[], V>(loadHint: H, fn: (entity: Loaded<T, H>, ...args: A) => V): AsyncMethod<T, A, V>;
+export declare class AsyncMethodImpl<T extends Entity, H extends LoadHint<T>, A extends unknown[], V> implements AsyncMethod<T, A, V> {
   #private;
   private fn;
   private loaded;
@@ -25,5 +25,5 @@ declare class AsyncMethodImpl<T extends Entity, H extends LoadHint<T>, A extends
   [AsyncMethodM]: undefined;
 }
 //#endregion
-export { AsyncMethod, AsyncMethodImpl, AsyncMethodPopulateSecret, LoadedMethod, hasAsyncMethod };
+export {};
 //# sourceMappingURL=hasAsyncMethod.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hasAsyncMethod.d.mts","names":[],"sources":["../../src/relations/hasAsyncMethod.ts"],"mappings":";;;cAIM;cACO;UAEI,YAAY,UAAU,QAAQ,qBAAqB;GAEjE;EACD;EACA,QAAQ,MAAM,IAAI,QAAQ;;UAGX,aAAa,UAAU,QAAQ,qBAAqB;EACnE,QAAQ,MAAM,IAAI;;iBAGJ,eAAe,UAAU,cAAc,UAAU,SAAS,IAAI,qBAAqB,GACjG,UAAU,GACV,KAAK,QAAQ,OAAO,GAAG,OAAO,MAAM,MAAM,IACzC,YAAY,GAAG,GAAG;cAMR,gBAAgB,UAAU,QAAQ,UAAU,SAAS,IAAI,qBAAqB,cAAc,YACvG,GACA,GACA;;UAUU;UARF;UACA;EAIR,YACE,QAAQ,GACR,MAAM,GACE,KAAK,QAAQ,OAAO,GAAG,OAAO,MAAM,MAAM;;EAO9C,QAAQ,MAAM,IAAI,QAAQ;EAUhC,QAAQ,MAAM,IAAI;MAOd;GAIH"}
+{"version":3,"file":"hasAsyncMethod.d.mts","names":[],"sources":["../../src/relations/hasAsyncMethod.ts"],"mappings":";;;cAIM;qBACO;iBAEI,YAAY,UAAU,QAAQ,qBAAqB;GAEjE;EACD;EACA,QAAQ,MAAM,IAAI,QAAQ;;iBAGX,aAAa,UAAU,QAAQ,qBAAqB;EACnE,QAAQ,MAAM,IAAI;;wBAGJ,eAAe,UAAU,cAAc,UAAU,SAAS,IAAI,qBAAqB,GACjG,UAAU,GACV,KAAK,QAAQ,OAAO,GAAG,OAAO,MAAM,MAAM,IACzC,YAAY,GAAG,GAAG;qBAMR,gBAAgB,UAAU,QAAQ,UAAU,SAAS,IAAI,qBAAqB,cAAc,YACvG,GACA,GACA;;UAUU;UARF;UACA;EAIR,YACE,QAAQ,GACR,MAAM,GACE,KAAK,QAAQ,OAAO,GAAG,OAAO,MAAM,MAAM;;EAO9C,QAAQ,MAAM,IAAI,QAAQ;EAUhC,QAAQ,MAAM,IAAI;MAOd;GAIH"}

package/build/relations/hasAsyncMethod.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasAsyncMethod.js","names":["#entity","#hint"],"sources":["../../src/relations/hasAsyncMethod.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"src/loading/loadHints.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\n\nconst AsyncMethodM = Symbol();\nexport const AsyncMethodPopulateSecret = Symbol();\n\nexport interface AsyncMethod<T extends Entity, A extends unknown[], V> {\n  // To differentiate from AsyncProperties\n  [AsyncMethodM]: undefined;\n  isLoaded: boolean;\n  load(...args: A): Promise<V>;\n}\n\nexport interface LoadedMethod<T extends Entity, A extends unknown[], V> {\n  call(...args: A): V;\n}\n\nexport function hasAsyncMethod<T extends Entity, const H extends LoadHint<T>, A extends unknown[], V>(\n  loadHint: H,\n  fn: (entity: Loaded<T, H>, ...args: A) => V,\n): AsyncMethod<T, A, V> {\n  return lazyField((entity: T) => {\n    return new AsyncMethodImpl(entity, loadHint, fn);\n  });\n}\n\nexport class AsyncMethodImpl<T extends Entity, H extends LoadHint<T>, A extends unknown[], V> implements AsyncMethod<\n  T,\n  A,\n  V\n> {\n  private loaded = false;\n  private loadPromise: Promise<any> | undefined;\n\n  readonly #entity: T;\n  readonly #hint: H;\n  constructor(\n    entity: T,\n    hint: H,\n    private fn: (entity: Loaded<T, H>, ...args: A) => V,\n  ) {\n    this.#entity = entity;\n    this.#hint = hint;\n  }\n\n  /** Args might be either the user-provided args, or the populate `opts` if we're being preloaded. */\n  async load(...args: A): Promise<V> {\n    // Are we being called by `em.populate`? If so, we don't have the real args, so avoid invoking fn\n    const isPopulate = args && typeof args[0] === \"object\" && AsyncMethodPopulateSecret in (args as any)[0];\n    if (!this.loaded) {\n      this.loadPromise ??= this.#entity.em.populate(this.#entity, this.#hint!).then((loaded) => (this.loaded = true));\n      await this.loadPromise;\n    }\n    return isPopulate ? (undefined as any) : this.call(...args);\n  }\n\n  call(...args: A): V {\n    if (!this.isLoaded) {\n      throw new Error(\"hasAsyncMethod.call was called but not loaded\");\n    }\n    return this.fn(this.#entity as Loaded<T, H>, ...args);\n  }\n\n  get isLoaded() {\n    return this.loaded || isLoaded(this.#entity, this.#hint);\n  }\n\n  [AsyncMethodM]: undefined;\n}\n"],"mappings":";;;;AAIA,MAAM,eAAe,OAAO;AAC5B,MAAa,4BAA4B,OAAO;AAahD,SAAgB,eACd,UACA,IACsB;CACtB,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,gBAAgB,QAAQ,UAAU,EAAE;CACjD,CAAC;AACH;AAEA,IAAa,kBAAb,MAIE;CASU;CARV,SAAiB;CACjB;CAEA;CACA;CACA,YACE,QACA,MACA,IACA;EADQ,KAAA,KAAA;EAER,KAAKA,UAAU;EACf,KAAKC,QAAQ;CACf;;CAGA,MAAM,KAAK,GAAG,MAAqB;EAEjC,MAAM,aAAa,QAAQ,OAAO,KAAK,OAAO,YAAY,6BAA8B,KAAa;EACrG,IAAI,CAAC,KAAK,QAAQ;GAChB,KAAK,gBAAgB,KAAKD,QAAQ,GAAG,SAAS,KAAKA,SAAS,KAAKC,KAAM,CAAC,CAAC,MAAM,WAAY,KAAK,SAAS,IAAK;GAC9G,MAAM,KAAK;EACb;EACA,OAAO,aAAc,KAAA,IAAoB,KAAK,KAAK,GAAG,IAAI;CAC5D;CAEA,KAAK,GAAG,MAAY;EAClB,IAAI,CAAC,KAAK,UACR,MAAM,IAAI,MAAM,+CAA+C;EAEjE,OAAO,KAAK,GAAG,KAAKD,SAAyB,GAAG,IAAI;CACtD;CAEA,IAAI,WAAW;EACb,OAAO,KAAK,UAAU,SAAS,KAAKA,SAAS,KAAKC,KAAK;CACzD;CAEA,CAAC;AACH"}
+{"version":3,"file":"hasAsyncMethod.js","names":[],"sources":["../../src/relations/hasAsyncMethod.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"src/loading/loadHints.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\n\nconst AsyncMethodM = Symbol();\nexport const AsyncMethodPopulateSecret = Symbol();\n\nexport interface AsyncMethod<T extends Entity, A extends unknown[], V> {\n  // To differentiate from AsyncProperties\n  [AsyncMethodM]: undefined;\n  isLoaded: boolean;\n  load(...args: A): Promise<V>;\n}\n\nexport interface LoadedMethod<T extends Entity, A extends unknown[], V> {\n  call(...args: A): V;\n}\n\nexport function hasAsyncMethod<T extends Entity, const H extends LoadHint<T>, A extends unknown[], V>(\n  loadHint: H,\n  fn: (entity: Loaded<T, H>, ...args: A) => V,\n): AsyncMethod<T, A, V> {\n  return lazyField((entity: T) => {\n    return new AsyncMethodImpl(entity, loadHint, fn);\n  });\n}\n\nexport class AsyncMethodImpl<T extends Entity, H extends LoadHint<T>, A extends unknown[], V> implements AsyncMethod<\n  T,\n  A,\n  V\n> {\n  private loaded = false;\n  private loadPromise: Promise<any> | undefined;\n\n  readonly #entity: T;\n  readonly #hint: H;\n  constructor(\n    entity: T,\n    hint: H,\n    private fn: (entity: Loaded<T, H>, ...args: A) => V,\n  ) {\n    this.#entity = entity;\n    this.#hint = hint;\n  }\n\n  /** Args might be either the user-provided args, or the populate `opts` if we're being preloaded. */\n  async load(...args: A): Promise<V> {\n    // Are we being called by `em.populate`? If so, we don't have the real args, so avoid invoking fn\n    const isPopulate = args && typeof args[0] === \"object\" && AsyncMethodPopulateSecret in (args as any)[0];\n    if (!this.loaded) {\n      this.loadPromise ??= this.#entity.em.populate(this.#entity, this.#hint!).then((loaded) => (this.loaded = true));\n      await this.loadPromise;\n    }\n    return isPopulate ? (undefined as any) : this.call(...args);\n  }\n\n  call(...args: A): V {\n    if (!this.isLoaded) {\n      throw new Error(\"hasAsyncMethod.call was called but not loaded\");\n    }\n    return this.fn(this.#entity as Loaded<T, H>, ...args);\n  }\n\n  get isLoaded() {\n    return this.loaded || isLoaded(this.#entity, this.#hint);\n  }\n\n  [AsyncMethodM]: undefined;\n}\n"],"mappings":";;;;AAIA,MAAM,eAAe,OAAO;AAC5B,MAAa,4BAA4B,OAAO;AAahD,SAAgB,eACd,UACA,IACsB;CACtB,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,gBAAgB,QAAQ,UAAU,EAAE;CACjD,CAAC;AACH;AAEA,IAAa,kBAAb,MAIE;CASU;CARV,SAAiB;CACjB;CAEA;CACA;CACA,YACE,QACA,MACA,IACA;EADQ,KAAA,KAAA;EAER,KAAK,UAAU;EACf,KAAK,QAAQ;CACf;;CAGA,MAAM,KAAK,GAAG,MAAqB;EAEjC,MAAM,aAAa,QAAQ,OAAO,KAAK,OAAO,YAAY,6BAA8B,KAAa;EACrG,IAAI,CAAC,KAAK,QAAQ;GAChB,KAAK,gBAAgB,KAAK,QAAQ,GAAG,SAAS,KAAK,SAAS,KAAK,KAAM,CAAC,CAAC,MAAM,WAAY,KAAK,SAAS,IAAK;GAC9G,MAAM,KAAK;EACb;EACA,OAAO,aAAc,KAAA,IAAoB,KAAK,KAAK,GAAG,IAAI;CAC5D;CAEA,KAAK,GAAG,MAAY;EAClB,IAAI,CAAC,KAAK,UACR,MAAM,IAAI,MAAM,+CAA+C;EAEjE,OAAO,KAAK,GAAG,KAAK,SAAyB,GAAG,IAAI;CACtD;CAEA,IAAI,WAAW;EACb,OAAO,KAAK,UAAU,SAAS,KAAK,SAAS,KAAK,KAAK;CACzD;CAEA,CAAC;AACH"}

package/build/relations/hasManyDerived.d.cts

@@ -19,7 +19,7 @@ type HasManyDerivedOpts<T extends Entity, U extends Entity, H extends LoadHint<T
  *
  * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, "reviews")`.
  */
-declare function hasManyDerived<T extends Entity, U extends Entity, H extends LoadHint<T>>(loadHint: H, opts: HasManyDerivedOpts<T, U, H>): Collection<T, U>;
+export declare function hasManyDerived<T extends Entity, U extends Entity, H extends LoadHint<T>>(loadHint: H, opts: HasManyDerivedOpts<T, U, H>): Collection<T, U>;
 //#endregion
-export { hasManyDerived };
+export {};
 //# sourceMappingURL=hasManyDerived.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hasManyDerived.d.cts","names":[],"sources":["../../src/relations/hasManyDerived.ts"],"mappings":";;;;;KAMK,mBAAmB,UAAU,QAAQ,UAAU,QAAQ,UAAU,SAAS;EAC7E,QAAQ,QAAQ,GAAG;IAAQ;QAA4B;EACvD,MAAM,QAAQ,OAAO,GAAG,gBAAgB;EACxC,OAAO,QAAQ,OAAO,GAAG,IAAI,QAAQ;EACrC,OAAO,QAAQ,OAAO,GAAG,IAAI,OAAO;EACpC,UAAU,QAAQ,OAAO,GAAG,IAAI,OAAO;;;;;;;;;iBAUzB,eAAe,UAAU,QAAQ,UAAU,QAAQ,UAAU,SAAS,IACpF,UAAU,GACV,MAAM,mBAAmB,GAAG,GAAG,KAC9B,WAAW,GAAG"}
+{"version":3,"file":"hasManyDerived.d.cts","names":[],"sources":["../../src/relations/hasManyDerived.ts"],"mappings":";;;;;KAMK,mBAAmB,UAAU,QAAQ,UAAU,QAAQ,UAAU,SAAS;EAC7E,QAAQ,QAAQ,GAAG;IAAQ;QAA4B;EACvD,MAAM,QAAQ,OAAO,GAAG,gBAAgB;EACxC,OAAO,QAAQ,OAAO,GAAG,IAAI,QAAQ;EACrC,OAAO,QAAQ,OAAO,GAAG,IAAI,OAAO;EACpC,UAAU,QAAQ,OAAO,GAAG,IAAI,OAAO;;;;;;;;;wBAUzB,eAAe,UAAU,QAAQ,UAAU,QAAQ,UAAU,SAAS,IACpF,UAAU,GACV,MAAM,mBAAmB,GAAG,GAAG,KAC9B,WAAW,GAAG"}

package/build/relations/hasManyDerived.d.mts

@@ -19,7 +19,7 @@ type HasManyDerivedOpts<T extends Entity, U extends Entity, H extends LoadHint<T
  *
  * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, "reviews")`.
  */
-declare function hasManyDerived<T extends Entity, U extends Entity, H extends LoadHint<T>>(loadHint: H, opts: HasManyDerivedOpts<T, U, H>): Collection<T, U>;
+export declare function hasManyDerived<T extends Entity, U extends Entity, H extends LoadHint<T>>(loadHint: H, opts: HasManyDerivedOpts<T, U, H>): Collection<T, U>;
 //#endregion
-export { hasManyDerived };
+export {};
 //# sourceMappingURL=hasManyDerived.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hasManyDerived.d.mts","names":[],"sources":["../../src/relations/hasManyDerived.ts"],"mappings":";;;;;KAMK,mBAAmB,UAAU,QAAQ,UAAU,QAAQ,UAAU,SAAS;EAC7E,QAAQ,QAAQ,GAAG;IAAQ;QAA4B;EACvD,MAAM,QAAQ,OAAO,GAAG,gBAAgB;EACxC,OAAO,QAAQ,OAAO,GAAG,IAAI,QAAQ;EACrC,OAAO,QAAQ,OAAO,GAAG,IAAI,OAAO;EACpC,UAAU,QAAQ,OAAO,GAAG,IAAI,OAAO;;;;;;;;;iBAUzB,eAAe,UAAU,QAAQ,UAAU,QAAQ,UAAU,SAAS,IACpF,UAAU,GACV,MAAM,mBAAmB,GAAG,GAAG,KAC9B,WAAW,GAAG"}
+{"version":3,"file":"hasManyDerived.d.mts","names":[],"sources":["../../src/relations/hasManyDerived.ts"],"mappings":";;;;;KAMK,mBAAmB,UAAU,QAAQ,UAAU,QAAQ,UAAU,SAAS;EAC7E,QAAQ,QAAQ,GAAG;IAAQ;QAA4B;EACvD,MAAM,QAAQ,OAAO,GAAG,gBAAgB;EACxC,OAAO,QAAQ,OAAO,GAAG,IAAI,QAAQ;EACrC,OAAO,QAAQ,OAAO,GAAG,IAAI,OAAO;EACpC,UAAU,QAAQ,OAAO,GAAG,IAAI,OAAO;;;;;;;;;wBAUzB,eAAe,UAAU,QAAQ,UAAU,QAAQ,UAAU,SAAS,IACpF,UAAU,GACV,MAAM,mBAAmB,GAAG,GAAG,KAC9B,WAAW,GAAG"}

package/build/relations/hasManyThrough.d.cts

@@ -10,7 +10,6 @@ import { Entity } from "../Entity.cjs";
  *
  * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, "reviews")`.
  */
-declare function hasManyThrough<T extends Entity, U extends Entity>(lens: (lens: Lens<T>) => Lens<U, U[]>): Collection<T, U>;
+export declare function hasManyThrough<T extends Entity, U extends Entity>(lens: (lens: Lens<T>) => Lens<U, U[]>): Collection<T, U>;
 //#endregion
-export { hasManyThrough };
 //# sourceMappingURL=hasManyThrough.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hasManyThrough.d.cts","names":[],"sources":["../../src/relations/hasManyThrough.ts"],"mappings":";;;;;;;;;;;;iBAoBgB,eAAe,UAAU,QAAQ,UAAU,QACzD,OAAO,MAAM,KAAK,OAAO,KAAK,GAAG,OAChC,WAAW,GAAG"}
+{"version":3,"file":"hasManyThrough.d.cts","names":[],"sources":["../../src/relations/hasManyThrough.ts"],"mappings":";;;;;;;;;;;;wBAoBgB,eAAe,UAAU,QAAQ,UAAU,QACzD,OAAO,MAAM,KAAK,OAAO,KAAK,GAAG,OAChC,WAAW,GAAG"}

package/build/relations/hasManyThrough.d.mts

@@ -10,7 +10,6 @@ import { Entity } from "../Entity.mjs";
  *
  * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, "reviews")`.
  */
-declare function hasManyThrough<T extends Entity, U extends Entity>(lens: (lens: Lens<T>) => Lens<U, U[]>): Collection<T, U>;
+export declare function hasManyThrough<T extends Entity, U extends Entity>(lens: (lens: Lens<T>) => Lens<U, U[]>): Collection<T, U>;
 //#endregion
-export { hasManyThrough };
 //# sourceMappingURL=hasManyThrough.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hasManyThrough.d.mts","names":[],"sources":["../../src/relations/hasManyThrough.ts"],"mappings":";;;;;;;;;;;;iBAoBgB,eAAe,UAAU,QAAQ,UAAU,QACzD,OAAO,MAAM,KAAK,OAAO,KAAK,GAAG,OAChC,WAAW,GAAG"}
+{"version":3,"file":"hasManyThrough.d.mts","names":[],"sources":["../../src/relations/hasManyThrough.ts"],"mappings":";;;;;;;;;;;;wBAoBgB,eAAe,UAAU,QAAQ,UAAU,QACzD,OAAO,MAAM,KAAK,OAAO,KAAK,GAAG,OAChC,WAAW,GAAG"}

package/build/relations/hasOneDerived.d.cts

@@ -9,7 +9,6 @@ import { Entity } from "../Entity.cjs";
  *
  * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, "author")`.
  */
-declare function hasOneDerived<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N, const H extends LoadHint<T>>(loadHint: H, get: (entity: Loaded<T, H>) => V): Reference<T, U, N>;
+export declare function hasOneDerived<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N, const H extends LoadHint<T>>(loadHint: H, get: (entity: Loaded<T, H>) => V): Reference<T, U, N>;
 //#endregion
-export { hasOneDerived };
 //# sourceMappingURL=hasOneDerived.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hasOneDerived.d.cts","names":[],"sources":["../../src/relations/hasOneDerived.ts"],"mappings":";;;;;;;;;;;iBAcgB,cACd,UAAU,QACV,UAAU,QACV,6BACA,UAAU,IAAI,SACR,UAAU,SAAS,IACzB,UAAU,GAAG,MAAM,QAAQ,OAAO,GAAG,OAAO,IAAI,UAAU,GAAG,GAAG"}
+{"version":3,"file":"hasOneDerived.d.cts","names":[],"sources":["../../src/relations/hasOneDerived.ts"],"mappings":";;;;;;;;;;;wBAcgB,cACd,UAAU,QACV,UAAU,QACV,6BACA,UAAU,IAAI,SACR,UAAU,SAAS,IACzB,UAAU,GAAG,MAAM,QAAQ,OAAO,GAAG,OAAO,IAAI,UAAU,GAAG,GAAG"}

package/build/relations/hasOneDerived.d.mts

@@ -9,7 +9,6 @@ import { Entity } from "../Entity.mjs";
  *
  * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, "author")`.
  */
-declare function hasOneDerived<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N, const H extends LoadHint<T>>(loadHint: H, get: (entity: Loaded<T, H>) => V): Reference<T, U, N>;
+export declare function hasOneDerived<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N, const H extends LoadHint<T>>(loadHint: H, get: (entity: Loaded<T, H>) => V): Reference<T, U, N>;
 //#endregion
-export { hasOneDerived };
 //# sourceMappingURL=hasOneDerived.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hasOneDerived.d.mts","names":[],"sources":["../../src/relations/hasOneDerived.ts"],"mappings":";;;;;;;;;;;iBAcgB,cACd,UAAU,QACV,UAAU,QACV,6BACA,UAAU,IAAI,SACR,UAAU,SAAS,IACzB,UAAU,GAAG,MAAM,QAAQ,OAAO,GAAG,OAAO,IAAI,UAAU,GAAG,GAAG"}
+{"version":3,"file":"hasOneDerived.d.mts","names":[],"sources":["../../src/relations/hasOneDerived.ts"],"mappings":";;;;;;;;;;;wBAcgB,cACd,UAAU,QACV,UAAU,QACV,6BACA,UAAU,IAAI,SACR,UAAU,SAAS,IACzB,UAAU,GAAG,MAAM,QAAQ,OAAO,GAAG,OAAO,IAAI,UAAU,GAAG,GAAG"}

package/build/relations/hasOneThrough.d.cts

@@ -10,7 +10,6 @@ import { Entity } from "../Entity.cjs";
  *
  * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, "author")`.
  */
-declare function hasOneThrough<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N>(lens: (lens: Lens<T>) => Lens<V>): Reference<T, U, N>;
+export declare function hasOneThrough<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N>(lens: (lens: Lens<T>) => Lens<V>): Reference<T, U, N>;
 //#endregion
-export { hasOneThrough };
 //# sourceMappingURL=hasOneThrough.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hasOneThrough.d.cts","names":[],"sources":["../../src/relations/hasOneThrough.ts"],"mappings":";;;;;;;;;;;;iBAqBgB,cAAc,UAAU,QAAQ,UAAU,QAAQ,6BAA6B,UAAU,IAAI,GAC3G,OAAO,MAAM,KAAK,OAAO,KAAK,KAC7B,UAAU,GAAG,GAAG"}
+{"version":3,"file":"hasOneThrough.d.cts","names":[],"sources":["../../src/relations/hasOneThrough.ts"],"mappings":";;;;;;;;;;;;wBAqBgB,cAAc,UAAU,QAAQ,UAAU,QAAQ,6BAA6B,UAAU,IAAI,GAC3G,OAAO,MAAM,KAAK,OAAO,KAAK,KAC7B,UAAU,GAAG,GAAG"}

package/build/relations/hasOneThrough.d.mts

@@ -10,7 +10,6 @@ import { Entity } from "../Entity.mjs";
  *
  * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, "author")`.
  */
-declare function hasOneThrough<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N>(lens: (lens: Lens<T>) => Lens<V>): Reference<T, U, N>;
+export declare function hasOneThrough<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N>(lens: (lens: Lens<T>) => Lens<V>): Reference<T, U, N>;
 //#endregion
-export { hasOneThrough };
 //# sourceMappingURL=hasOneThrough.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hasOneThrough.d.mts","names":[],"sources":["../../src/relations/hasOneThrough.ts"],"mappings":";;;;;;;;;;;;iBAqBgB,cAAc,UAAU,QAAQ,UAAU,QAAQ,6BAA6B,UAAU,IAAI,GAC3G,OAAO,MAAM,KAAK,OAAO,KAAK,KAC7B,UAAU,GAAG,GAAG"}
+{"version":3,"file":"hasOneThrough.d.mts","names":[],"sources":["../../src/relations/hasOneThrough.ts"],"mappings":";;;;;;;;;;;;wBAqBgB,cAAc,UAAU,QAAQ,UAAU,QAAQ,6BAA6B,UAAU,IAAI,GAC3G,OAAO,MAAM,KAAK,OAAO,KAAK,KAC7B,UAAU,GAAG,GAAG"}

package/build/relations/hasProperty.cjs

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_loading_loadHints = require("../loading/loadHints.cjs");
 const require_relations_PropertySymbols = require("./PropertySymbols.cjs");
 const require_relations_RecursiveCycleError = require("./RecursiveCycleError.cjs");
-const require_reactivity_reactiveHints = require("../reactivity/reactiveHints.cjs");
-const require_loading_loadHints = require("../loading/loadHints.cjs");
 const require_utils = require("../utils.cjs");
 const require_newEntity = require("../newEntity.cjs");
+const require_reactivity_reactiveHints = require("../reactivity/reactiveHints.cjs");
 const require_EntityMetadata = require("../EntityMetadata.cjs");
 require("../Entity.cjs");
 //#region src/relations/hasProperty.ts

package/build/relations/hasProperty.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hasProperty.cjs","names":["lazyField","#entity","#hint","#reactiveHint","#loadPromise","#loaded","tryResolve","convertToLoadHint","getMetadata","#isCheckingLoaded","RecursiveCycleError","isLoaded","PropertyT"],"sources":["../../src/relations/hasProperty.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { getMetadata } from \"src/EntityMetadata.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"src/loading/loadHints.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport {\n  type MaybeReactedPropertyEntity,\n  type Reacted,\n  type ReactiveHint,\n  convertToLoadHint,\n} from \"src/reactivity/reactiveHints.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\nimport { RecursiveCycleError } from \"src/relations/RecursiveCycleError.ts\";\nimport { tryResolve } from \"src/utils.ts\";\n\nexport { PropertyT };\n\nexport interface Property<T extends Entity, V> {\n  // Differentiate from AsyncMethod\n  [PropertyT]: T;\n  isLoaded: boolean;\n  load(): Promise<V>;\n}\n\nexport interface LoadedProperty<T extends Entity, V> {\n  get: V;\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(\n  loadHint: H,\n  fn: (entity: Loaded<T, H>) => V,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, loadHint, fn);\n  });\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasReactiveProperty<T extends Entity, const H extends ReactiveHint<T>, V>(\n  reactiveHint: H,\n  fn: (entity: Reacted<T, H>) => MaybeReactedPropertyEntity<V>,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, reactiveHint as any, fn as any, { isReactive: true });\n  });\n}\n\nexport class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements Property<T, V> {\n  // We'll probe for loaded if undefined\n  #loaded: boolean | undefined = undefined;\n  #isCheckingLoaded = false;\n  #loadPromise: any;\n\n  readonly #entity: T;\n  #hint: H | undefined;\n  #reactiveHint: ReactiveHint<T> | undefined;\n  constructor(\n    entity: T,\n    private fieldName: string,\n    hint: H | ReactiveHint<T>,\n    private fn: (entity: Loaded<T, H>) => V,\n    private opts: { isReactive?: boolean } = {},\n  ) {\n    const { isReactive = false } = opts;\n    this.#entity = entity;\n    this.#hint = isReactive ? undefined : (hint as H);\n    this.#reactiveHint = isReactive ? (hint as ReactiveHint<T>) : undefined;\n  }\n\n  load(): Promise<V> {\n    if (!this.isLoaded) {\n      const { loadHint, fn } = this;\n      return (this.#loadPromise ??= this.#entity.em.populate(this.#entity, loadHint).then((loaded) => {\n        this.#loaded = true;\n        return fn(loaded);\n      }));\n    }\n    return tryResolve(() => this.get);\n  }\n\n  get loadHint(): H {\n    if (!this.#hint) {\n      // Would be nice to statically (but lazily?) cache this...\n      this.#hint = convertToLoadHint(getMetadata(this.#entity), this.#reactiveHint as any) as H;\n    }\n    return this.#hint;\n  }\n\n  get reactiveHint(): ReactiveHint<T> | undefined {\n    return this.#reactiveHint;\n  }\n\n  get get(): V {\n    return this.fn(this.#entity as Loaded<T, H>);\n  }\n\n  get isLoaded() {\n    // Probe the first time, which is useful for factories that are DeepNew\n    if (this.#loaded === undefined) {\n      if (this.#isCheckingLoaded) {\n        this.#isCheckingLoaded = false;\n        throw new RecursiveCycleError({ entity: this.#entity, fieldName: this.fieldName }, [this.#entity]);\n      }\n      this.#isCheckingLoaded = true;\n      this.#loaded = isLoaded(this.#entity, this.loadHint);\n      this.#isCheckingLoaded = false;\n    }\n    return !!this.#loaded;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a Property. */\nexport function isProperty(maybeProperty: any): maybeProperty is Property<any, any> {\n  return maybeProperty instanceof PropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded Property. */\nexport function isLoadedProperty(maybeProperty: any): maybeProperty is Property<any, any> & LoadedProperty<any, any> {\n  return isProperty(maybeProperty) && maybeProperty.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmCA,SAAgB,YACd,UACA,IACgB;CAChB,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,UAAU,EAAE;CACzD,CAAC;AACH;;;;;;;;;AAUA,SAAgB,oBACd,cACA,IACgB;CAChB,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,cAAqB,IAAW,EAAE,YAAY,KAAK,CAAC;CACjG,CAAC;AACH;AAEA,IAAa,eAAb,MAAgG;CAWpF;CAEA;CACA;CAZV,UAA+B,KAAA;CAC/B,oBAAoB;CACpB;CAEA;CACA;CACA;CACA,YACE,QACA,WACA,MACA,IACA,OAAyC,CAAC,GAC1C;EAJQ,KAAA,YAAA;EAEA,KAAA,KAAA;EACA,KAAA,OAAA;EAER,MAAM,EAAE,aAAa,UAAU;EAC/B,KAAKC,UAAU;EACf,KAAKC,QAAQ,aAAa,KAAA,IAAa;EACvC,KAAKC,gBAAgB,aAAc,OAA2B,KAAA;CAChE;CAEA,OAAmB;EACjB,IAAI,CAAC,KAAK,UAAU;GAClB,MAAM,EAAE,UAAU,OAAO;GACzB,OAAQ,KAAKC,iBAAiB,KAAKH,QAAQ,GAAG,SAAS,KAAKA,SAAS,QAAQ,CAAC,CAAC,MAAM,WAAW;IAC9F,KAAKI,UAAU;IACf,OAAO,GAAG,MAAM;GAClB,CAAC;EACH;EACA,OAAOC,cAAAA,iBAAiB,KAAK,GAAG;CAClC;CAEA,IAAI,WAAc;EAChB,IAAI,CAAC,KAAKJ,OAER,KAAKA,QAAQK,iCAAAA,kBAAkBC,uBAAAA,YAAY,KAAKP,OAAO,GAAG,KAAKE,aAAoB;EAErF,OAAO,KAAKD;CACd;CAEA,IAAI,eAA4C;EAC9C,OAAO,KAAKC;CACd;CAEA,IAAI,MAAS;EACX,OAAO,KAAK,GAAG,KAAKF,OAAuB;CAC7C;CAEA,IAAI,WAAW;EAEb,IAAI,KAAKI,YAAY,KAAA,GAAW;GAC9B,IAAI,KAAKI,mBAAmB;IAC1B,KAAKA,oBAAoB;IACzB,MAAM,IAAIC,sCAAAA,oBAAoB;KAAE,QAAQ,KAAKT;KAAS,WAAW,KAAK;IAAU,GAAG,CAAC,KAAKA,OAAO,CAAC;GACnG;GACA,KAAKQ,oBAAoB;GACzB,KAAKJ,UAAUM,0BAAAA,SAAS,KAAKV,SAAS,KAAK,QAAQ;GACnD,KAAKQ,oBAAoB;EAC3B;EACA,OAAO,CAAC,CAAC,KAAKJ;CAChB;CAEA,CAACO,kCAAAA,aAAa,KAAA;AAChB;;AAGA,SAAgB,WAAW,eAAyD;CAClF,OAAO,yBAAyB;AAClC;;AAGA,SAAgB,iBAAiB,eAAoF;CACnH,OAAO,WAAW,aAAa,KAAK,cAAc;AACpD"}
+{"version":3,"file":"hasProperty.cjs","names":["lazyField","tryResolve","convertToLoadHint","getMetadata","RecursiveCycleError","isLoaded","PropertyT"],"sources":["../../src/relations/hasProperty.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { getMetadata } from \"src/EntityMetadata.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"src/loading/loadHints.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport {\n  type MaybeReactedPropertyEntity,\n  type Reacted,\n  type ReactiveHint,\n  convertToLoadHint,\n} from \"src/reactivity/reactiveHints.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\nimport { RecursiveCycleError } from \"src/relations/RecursiveCycleError.ts\";\nimport { tryResolve } from \"src/utils.ts\";\n\nexport { PropertyT };\n\nexport interface Property<T extends Entity, V> {\n  // Differentiate from AsyncMethod\n  [PropertyT]: T;\n  isLoaded: boolean;\n  load(): Promise<V>;\n}\n\nexport interface LoadedProperty<T extends Entity, V> {\n  get: V;\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(\n  loadHint: H,\n  fn: (entity: Loaded<T, H>) => V,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, loadHint, fn);\n  });\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasReactiveProperty<T extends Entity, const H extends ReactiveHint<T>, V>(\n  reactiveHint: H,\n  fn: (entity: Reacted<T, H>) => MaybeReactedPropertyEntity<V>,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, reactiveHint as any, fn as any, { isReactive: true });\n  });\n}\n\nexport class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements Property<T, V> {\n  // We'll probe for loaded if undefined\n  #loaded: boolean | undefined = undefined;\n  #isCheckingLoaded = false;\n  #loadPromise: any;\n\n  readonly #entity: T;\n  #hint: H | undefined;\n  #reactiveHint: ReactiveHint<T> | undefined;\n  constructor(\n    entity: T,\n    private fieldName: string,\n    hint: H | ReactiveHint<T>,\n    private fn: (entity: Loaded<T, H>) => V,\n    private opts: { isReactive?: boolean } = {},\n  ) {\n    const { isReactive = false } = opts;\n    this.#entity = entity;\n    this.#hint = isReactive ? undefined : (hint as H);\n    this.#reactiveHint = isReactive ? (hint as ReactiveHint<T>) : undefined;\n  }\n\n  load(): Promise<V> {\n    if (!this.isLoaded) {\n      const { loadHint, fn } = this;\n      return (this.#loadPromise ??= this.#entity.em.populate(this.#entity, loadHint).then((loaded) => {\n        this.#loaded = true;\n        return fn(loaded);\n      }));\n    }\n    return tryResolve(() => this.get);\n  }\n\n  get loadHint(): H {\n    if (!this.#hint) {\n      // Would be nice to statically (but lazily?) cache this...\n      this.#hint = convertToLoadHint(getMetadata(this.#entity), this.#reactiveHint as any) as H;\n    }\n    return this.#hint;\n  }\n\n  get reactiveHint(): ReactiveHint<T> | undefined {\n    return this.#reactiveHint;\n  }\n\n  get get(): V {\n    return this.fn(this.#entity as Loaded<T, H>);\n  }\n\n  get isLoaded() {\n    // Probe the first time, which is useful for factories that are DeepNew\n    if (this.#loaded === undefined) {\n      if (this.#isCheckingLoaded) {\n        this.#isCheckingLoaded = false;\n        throw new RecursiveCycleError({ entity: this.#entity, fieldName: this.fieldName }, [this.#entity]);\n      }\n      this.#isCheckingLoaded = true;\n      this.#loaded = isLoaded(this.#entity, this.loadHint);\n      this.#isCheckingLoaded = false;\n    }\n    return !!this.#loaded;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a Property. */\nexport function isProperty(maybeProperty: any): maybeProperty is Property<any, any> {\n  return maybeProperty instanceof PropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded Property. */\nexport function isLoadedProperty(maybeProperty: any): maybeProperty is Property<any, any> & LoadedProperty<any, any> {\n  return isProperty(maybeProperty) && maybeProperty.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmCA,SAAgB,YACd,UACA,IACgB;CAChB,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,UAAU,EAAE;CACzD,CAAC;AACH;;;;;;;;;AAUA,SAAgB,oBACd,cACA,IACgB;CAChB,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,cAAqB,IAAW,EAAE,YAAY,KAAK,CAAC;CACjG,CAAC;AACH;AAEA,IAAa,eAAb,MAAgG;CAWpF;CAEA;CACA;CAZV,UAA+B,KAAA;CAC/B,oBAAoB;CACpB;CAEA;CACA;CACA;CACA,YACE,QACA,WACA,MACA,IACA,OAAyC,CAAC,GAC1C;EAJQ,KAAA,YAAA;EAEA,KAAA,KAAA;EACA,KAAA,OAAA;EAER,MAAM,EAAE,aAAa,UAAU;EAC/B,KAAK,UAAU;EACf,KAAK,QAAQ,aAAa,KAAA,IAAa;EACvC,KAAK,gBAAgB,aAAc,OAA2B,KAAA;CAChE;CAEA,OAAmB;EACjB,IAAI,CAAC,KAAK,UAAU;GAClB,MAAM,EAAE,UAAU,OAAO;GACzB,OAAQ,KAAK,iBAAiB,KAAK,QAAQ,GAAG,SAAS,KAAK,SAAS,QAAQ,CAAC,CAAC,MAAM,WAAW;IAC9F,KAAK,UAAU;IACf,OAAO,GAAG,MAAM;GAClB,CAAC;EACH;EACA,OAAOC,cAAAA,iBAAiB,KAAK,GAAG;CAClC;CAEA,IAAI,WAAc;EAChB,IAAI,CAAC,KAAK,OAER,KAAK,QAAQC,iCAAAA,kBAAkBC,uBAAAA,YAAY,KAAK,OAAO,GAAG,KAAK,aAAoB;EAErF,OAAO,KAAK;CACd;CAEA,IAAI,eAA4C;EAC9C,OAAO,KAAK;CACd;CAEA,IAAI,MAAS;EACX,OAAO,KAAK,GAAG,KAAK,OAAuB;CAC7C;CAEA,IAAI,WAAW;EAEb,IAAI,KAAK,YAAY,KAAA,GAAW;GAC9B,IAAI,KAAK,mBAAmB;IAC1B,KAAK,oBAAoB;IACzB,MAAM,IAAIC,sCAAAA,oBAAoB;KAAE,QAAQ,KAAK;KAAS,WAAW,KAAK;IAAU,GAAG,CAAC,KAAK,OAAO,CAAC;GACnG;GACA,KAAK,oBAAoB;GACzB,KAAK,UAAUC,0BAAAA,SAAS,KAAK,SAAS,KAAK,QAAQ;GACnD,KAAK,oBAAoB;EAC3B;EACA,OAAO,CAAC,CAAC,KAAK;CAChB;CAEA,CAACC,kCAAAA,aAAa,KAAA;AAChB;;AAGA,SAAgB,WAAW,eAAyD;CAClF,OAAO,yBAAyB;AAClC;;AAGA,SAAgB,iBAAiB,eAAoF;CACnH,OAAO,WAAW,aAAa,KAAK,cAAc;AACpD"}

package/build/relations/hasProperty.d.cts

@@ -3,12 +3,12 @@ import { LoadHint, Loaded } from "../loading/loadHints.cjs";
 import { MaybeReactedPropertyEntity, Reacted, ReactiveHint } from "../reactivity/reactiveHints.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/hasProperty.d.ts
-interface Property<T extends Entity, V> {
+export interface Property<T extends Entity, V> {
   [PropertyT]: T;
   isLoaded: boolean;
   load(): Promise<V>;
 }
-interface LoadedProperty<T extends Entity, V> {
+export interface LoadedProperty<T extends Entity, V> {
   get: V;
 }
 /**
@@ -19,7 +19,7 @@ interface LoadedProperty<T extends Entity, V> {
  * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,
  * with `someProperty.get`.
  */
-declare function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(loadHint: H, fn: (entity: Loaded<T, H>) => V): Property<T, V>;
+export declare function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(loadHint: H, fn: (entity: Loaded<T, H>) => V): Property<T, V>;
 /**
  * Creates a calculated derived value from a load hint + lambda.
  *
@@ -28,8 +28,8 @@ declare function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(l
  * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,
  * with `someProperty.get`.
  */
-declare function hasReactiveProperty<T extends Entity, const H extends ReactiveHint<T>, V>(reactiveHint: H, fn: (entity: Reacted<T, H>) => MaybeReactedPropertyEntity<V>): Property<T, V>;
-declare class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements Property<T, V> {
+export declare function hasReactiveProperty<T extends Entity, const H extends ReactiveHint<T>, V>(reactiveHint: H, fn: (entity: Reacted<T, H>) => MaybeReactedPropertyEntity<V>): Property<T, V>;
+export declare class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements Property<T, V> {
   #private;
   private fieldName;
   private fn;
@@ -45,9 +45,9 @@ declare class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implement
   [PropertyT]: T;
 }
 /** Type guard utility for determining if an entity field is a Property. */
-declare function isProperty(maybeProperty: any): maybeProperty is Property<any, any>;
+export declare function isProperty(maybeProperty: any): maybeProperty is Property<any, any>;
 /** Type guard utility for determining if an entity field is a loaded Property. */
-declare function isLoadedProperty(maybeProperty: any): maybeProperty is Property<any, any> & LoadedProperty<any, any>;
+export declare function isLoadedProperty(maybeProperty: any): maybeProperty is Property<any, any> & LoadedProperty<any, any>;
 //#endregion
-export { LoadedProperty, Property, PropertyImpl, PropertyT, hasProperty, hasReactiveProperty, isLoadedProperty, isProperty };
+export { PropertyT };
 //# sourceMappingURL=hasProperty.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hasProperty.d.cts","names":[],"sources":["../../src/relations/hasProperty.ts"],"mappings":";;;;;UAgBiB,SAAS,UAAU,QAAQ;GAEzC,YAAY;EACb;EACA,QAAQ,QAAQ;;UAGD,eAAe,UAAU,QAAQ;EAChD,KAAK;;;;;;;;;;iBAWS,YAAY,UAAU,cAAc,UAAU,SAAS,IAAI,GACzE,UAAU,GACV,KAAK,QAAQ,OAAO,GAAG,OAAO,IAC7B,SAAS,GAAG;;;;;;;;;iBAcC,oBAAoB,UAAU,cAAc,UAAU,aAAa,IAAI,GACrF,cAAc,GACd,KAAK,QAAQ,QAAQ,GAAG,OAAO,2BAA2B,KACzD,SAAS,GAAG;cAMF,aAAa,UAAU,QAAQ,UAAU,SAAS,IAAI,cAAc,SAAS,GAAG;;UAWjF;UAEA;UACA;EALV,YACE,QAAQ,GACA,mBACR,MAAM,IAAI,aAAa,IACf,KAAK,QAAQ,OAAO,GAAG,OAAO,GAC9B;IAAQ;;EAQlB,QAAQ,QAAQ;MAWZ,YAAY;MAQZ,gBAAgB,aAAa;MAI7B,OAAO;MAIP;GAcH,YAAiC;;;iBAIpB,WAAW,qBAAqB,iBAAiB;;iBAKjD,iBAAiB,qBAAqB,iBAAiB,qBAAqB"}
+{"version":3,"file":"hasProperty.d.cts","names":[],"sources":["../../src/relations/hasProperty.ts"],"mappings":";;;;;iBAgBiB,SAAS,UAAU,QAAQ;GAEzC,YAAY;EACb;EACA,QAAQ,QAAQ;;iBAGD,eAAe,UAAU,QAAQ;EAChD,KAAK;;;;;;;;;;wBAWS,YAAY,UAAU,cAAc,UAAU,SAAS,IAAI,GACzE,UAAU,GACV,KAAK,QAAQ,OAAO,GAAG,OAAO,IAC7B,SAAS,GAAG;;;;;;;;;wBAcC,oBAAoB,UAAU,cAAc,UAAU,aAAa,IAAI,GACrF,cAAc,GACd,KAAK,QAAQ,QAAQ,GAAG,OAAO,2BAA2B,KACzD,SAAS,GAAG;qBAMF,aAAa,UAAU,QAAQ,UAAU,SAAS,IAAI,cAAc,SAAS,GAAG;;UAWjF;UAEA;UACA;EALV,YACE,QAAQ,GACA,mBACR,MAAM,IAAI,aAAa,IACf,KAAK,QAAQ,OAAO,GAAG,OAAO,GAC9B;IAAQ;;EAQlB,QAAQ,QAAQ;MAWZ,YAAY;MAQZ,gBAAgB,aAAa;MAI7B,OAAO;MAIP;GAcH,YAAiC;;;wBAIpB,WAAW,qBAAqB,iBAAiB;;wBAKjD,iBAAiB,qBAAqB,iBAAiB,qBAAqB"}

package/build/relations/hasProperty.d.mts

@@ -3,12 +3,12 @@ import { LoadHint, Loaded } from "../loading/loadHints.mjs";
 import { MaybeReactedPropertyEntity, Reacted, ReactiveHint } from "../reactivity/reactiveHints.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/hasProperty.d.ts
-interface Property<T extends Entity, V> {
+export interface Property<T extends Entity, V> {
   [PropertyT]: T;
   isLoaded: boolean;
   load(): Promise<V>;
 }
-interface LoadedProperty<T extends Entity, V> {
+export interface LoadedProperty<T extends Entity, V> {
   get: V;
 }
 /**
@@ -19,7 +19,7 @@ interface LoadedProperty<T extends Entity, V> {
  * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,
  * with `someProperty.get`.
  */
-declare function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(loadHint: H, fn: (entity: Loaded<T, H>) => V): Property<T, V>;
+export declare function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(loadHint: H, fn: (entity: Loaded<T, H>) => V): Property<T, V>;
 /**
  * Creates a calculated derived value from a load hint + lambda.
  *
@@ -28,8 +28,8 @@ declare function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(l
  * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,
  * with `someProperty.get`.
  */
-declare function hasReactiveProperty<T extends Entity, const H extends ReactiveHint<T>, V>(reactiveHint: H, fn: (entity: Reacted<T, H>) => MaybeReactedPropertyEntity<V>): Property<T, V>;
-declare class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements Property<T, V> {
+export declare function hasReactiveProperty<T extends Entity, const H extends ReactiveHint<T>, V>(reactiveHint: H, fn: (entity: Reacted<T, H>) => MaybeReactedPropertyEntity<V>): Property<T, V>;
+export declare class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements Property<T, V> {
   #private;
   private fieldName;
   private fn;
@@ -45,9 +45,9 @@ declare class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implement
   [PropertyT]: T;
 }
 /** Type guard utility for determining if an entity field is a Property. */
-declare function isProperty(maybeProperty: any): maybeProperty is Property<any, any>;
+export declare function isProperty(maybeProperty: any): maybeProperty is Property<any, any>;
 /** Type guard utility for determining if an entity field is a loaded Property. */
-declare function isLoadedProperty(maybeProperty: any): maybeProperty is Property<any, any> & LoadedProperty<any, any>;
+export declare function isLoadedProperty(maybeProperty: any): maybeProperty is Property<any, any> & LoadedProperty<any, any>;
 //#endregion
-export { LoadedProperty, Property, PropertyImpl, PropertyT, hasProperty, hasReactiveProperty, isLoadedProperty, isProperty };
+export { PropertyT };
 //# sourceMappingURL=hasProperty.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hasProperty.d.mts","names":[],"sources":["../../src/relations/hasProperty.ts"],"mappings":";;;;;UAgBiB,SAAS,UAAU,QAAQ;GAEzC,YAAY;EACb;EACA,QAAQ,QAAQ;;UAGD,eAAe,UAAU,QAAQ;EAChD,KAAK;;;;;;;;;;iBAWS,YAAY,UAAU,cAAc,UAAU,SAAS,IAAI,GACzE,UAAU,GACV,KAAK,QAAQ,OAAO,GAAG,OAAO,IAC7B,SAAS,GAAG;;;;;;;;;iBAcC,oBAAoB,UAAU,cAAc,UAAU,aAAa,IAAI,GACrF,cAAc,GACd,KAAK,QAAQ,QAAQ,GAAG,OAAO,2BAA2B,KACzD,SAAS,GAAG;cAMF,aAAa,UAAU,QAAQ,UAAU,SAAS,IAAI,cAAc,SAAS,GAAG;;UAWjF;UAEA;UACA;EALV,YACE,QAAQ,GACA,mBACR,MAAM,IAAI,aAAa,IACf,KAAK,QAAQ,OAAO,GAAG,OAAO,GAC9B;IAAQ;;EAQlB,QAAQ,QAAQ;MAWZ,YAAY;MAQZ,gBAAgB,aAAa;MAI7B,OAAO;MAIP;GAcH,YAAiC;;;iBAIpB,WAAW,qBAAqB,iBAAiB;;iBAKjD,iBAAiB,qBAAqB,iBAAiB,qBAAqB"}
+{"version":3,"file":"hasProperty.d.mts","names":[],"sources":["../../src/relations/hasProperty.ts"],"mappings":";;;;;iBAgBiB,SAAS,UAAU,QAAQ;GAEzC,YAAY;EACb;EACA,QAAQ,QAAQ;;iBAGD,eAAe,UAAU,QAAQ;EAChD,KAAK;;;;;;;;;;wBAWS,YAAY,UAAU,cAAc,UAAU,SAAS,IAAI,GACzE,UAAU,GACV,KAAK,QAAQ,OAAO,GAAG,OAAO,IAC7B,SAAS,GAAG;;;;;;;;;wBAcC,oBAAoB,UAAU,cAAc,UAAU,aAAa,IAAI,GACrF,cAAc,GACd,KAAK,QAAQ,QAAQ,GAAG,OAAO,2BAA2B,KACzD,SAAS,GAAG;qBAMF,aAAa,UAAU,QAAQ,UAAU,SAAS,IAAI,cAAc,SAAS,GAAG;;UAWjF;UAEA;UACA;EALV,YACE,QAAQ,GACA,mBACR,MAAM,IAAI,aAAa,IACf,KAAK,QAAQ,OAAO,GAAG,OAAO,GAC9B;IAAQ;;EAQlB,QAAQ,QAAQ;MAWZ,YAAY;MAQZ,gBAAgB,aAAa;MAI7B,OAAO;MAIP;GAcH,YAAiC;;;wBAIpB,WAAW,qBAAqB,iBAAiB;;wBAKjD,iBAAiB,qBAAqB,iBAAiB,qBAAqB"}

package/build/relations/hasProperty.js

@@ -1,9 +1,9 @@
+import { isLoaded } from "../loading/loadHints.js";
 import { PropertyT } from "./PropertySymbols.js";
 import { RecursiveCycleError } from "./RecursiveCycleError.js";
-import { convertToLoadHint } from "../reactivity/reactiveHints.js";
-import { isLoaded } from "../loading/loadHints.js";
 import { tryResolve } from "../utils.js";
 import { lazyField } from "../newEntity.js";
+import { convertToLoadHint } from "../reactivity/reactiveHints.js";
 import { getMetadata } from "../EntityMetadata.js";
 import "../Entity.js";
 //#region src/relations/hasProperty.ts

package/build/relations/hasProperty.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasProperty.js","names":["#entity","#hint","#reactiveHint","#loadPromise","#loaded","#isCheckingLoaded"],"sources":["../../src/relations/hasProperty.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { getMetadata } from \"src/EntityMetadata.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"src/loading/loadHints.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport {\n  type MaybeReactedPropertyEntity,\n  type Reacted,\n  type ReactiveHint,\n  convertToLoadHint,\n} from \"src/reactivity/reactiveHints.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\nimport { RecursiveCycleError } from \"src/relations/RecursiveCycleError.ts\";\nimport { tryResolve } from \"src/utils.ts\";\n\nexport { PropertyT };\n\nexport interface Property<T extends Entity, V> {\n  // Differentiate from AsyncMethod\n  [PropertyT]: T;\n  isLoaded: boolean;\n  load(): Promise<V>;\n}\n\nexport interface LoadedProperty<T extends Entity, V> {\n  get: V;\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(\n  loadHint: H,\n  fn: (entity: Loaded<T, H>) => V,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, loadHint, fn);\n  });\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasReactiveProperty<T extends Entity, const H extends ReactiveHint<T>, V>(\n  reactiveHint: H,\n  fn: (entity: Reacted<T, H>) => MaybeReactedPropertyEntity<V>,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, reactiveHint as any, fn as any, { isReactive: true });\n  });\n}\n\nexport class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements Property<T, V> {\n  // We'll probe for loaded if undefined\n  #loaded: boolean | undefined = undefined;\n  #isCheckingLoaded = false;\n  #loadPromise: any;\n\n  readonly #entity: T;\n  #hint: H | undefined;\n  #reactiveHint: ReactiveHint<T> | undefined;\n  constructor(\n    entity: T,\n    private fieldName: string,\n    hint: H | ReactiveHint<T>,\n    private fn: (entity: Loaded<T, H>) => V,\n    private opts: { isReactive?: boolean } = {},\n  ) {\n    const { isReactive = false } = opts;\n    this.#entity = entity;\n    this.#hint = isReactive ? undefined : (hint as H);\n    this.#reactiveHint = isReactive ? (hint as ReactiveHint<T>) : undefined;\n  }\n\n  load(): Promise<V> {\n    if (!this.isLoaded) {\n      const { loadHint, fn } = this;\n      return (this.#loadPromise ??= this.#entity.em.populate(this.#entity, loadHint).then((loaded) => {\n        this.#loaded = true;\n        return fn(loaded);\n      }));\n    }\n    return tryResolve(() => this.get);\n  }\n\n  get loadHint(): H {\n    if (!this.#hint) {\n      // Would be nice to statically (but lazily?) cache this...\n      this.#hint = convertToLoadHint(getMetadata(this.#entity), this.#reactiveHint as any) as H;\n    }\n    return this.#hint;\n  }\n\n  get reactiveHint(): ReactiveHint<T> | undefined {\n    return this.#reactiveHint;\n  }\n\n  get get(): V {\n    return this.fn(this.#entity as Loaded<T, H>);\n  }\n\n  get isLoaded() {\n    // Probe the first time, which is useful for factories that are DeepNew\n    if (this.#loaded === undefined) {\n      if (this.#isCheckingLoaded) {\n        this.#isCheckingLoaded = false;\n        throw new RecursiveCycleError({ entity: this.#entity, fieldName: this.fieldName }, [this.#entity]);\n      }\n      this.#isCheckingLoaded = true;\n      this.#loaded = isLoaded(this.#entity, this.loadHint);\n      this.#isCheckingLoaded = false;\n    }\n    return !!this.#loaded;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a Property. */\nexport function isProperty(maybeProperty: any): maybeProperty is Property<any, any> {\n  return maybeProperty instanceof PropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded Property. */\nexport function isLoadedProperty(maybeProperty: any): maybeProperty is Property<any, any> & LoadedProperty<any, any> {\n  return isProperty(maybeProperty) && maybeProperty.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmCA,SAAgB,YACd,UACA,IACgB;CAChB,OAAO,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,UAAU,EAAE;CACzD,CAAC;AACH;;;;;;;;;AAUA,SAAgB,oBACd,cACA,IACgB;CAChB,OAAO,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,cAAqB,IAAW,EAAE,YAAY,KAAK,CAAC;CACjG,CAAC;AACH;AAEA,IAAa,eAAb,MAAgG;CAWpF;CAEA;CACA;CAZV,UAA+B,KAAA;CAC/B,oBAAoB;CACpB;CAEA;CACA;CACA;CACA,YACE,QACA,WACA,MACA,IACA,OAAyC,CAAC,GAC1C;EAJQ,KAAA,YAAA;EAEA,KAAA,KAAA;EACA,KAAA,OAAA;EAER,MAAM,EAAE,aAAa,UAAU;EAC/B,KAAKA,UAAU;EACf,KAAKC,QAAQ,aAAa,KAAA,IAAa;EACvC,KAAKC,gBAAgB,aAAc,OAA2B,KAAA;CAChE;CAEA,OAAmB;EACjB,IAAI,CAAC,KAAK,UAAU;GAClB,MAAM,EAAE,UAAU,OAAO;GACzB,OAAQ,KAAKC,iBAAiB,KAAKH,QAAQ,GAAG,SAAS,KAAKA,SAAS,QAAQ,CAAC,CAAC,MAAM,WAAW;IAC9F,KAAKI,UAAU;IACf,OAAO,GAAG,MAAM;GAClB,CAAC;EACH;EACA,OAAO,iBAAiB,KAAK,GAAG;CAClC;CAEA,IAAI,WAAc;EAChB,IAAI,CAAC,KAAKH,OAER,KAAKA,QAAQ,kBAAkB,YAAY,KAAKD,OAAO,GAAG,KAAKE,aAAoB;EAErF,OAAO,KAAKD;CACd;CAEA,IAAI,eAA4C;EAC9C,OAAO,KAAKC;CACd;CAEA,IAAI,MAAS;EACX,OAAO,KAAK,GAAG,KAAKF,OAAuB;CAC7C;CAEA,IAAI,WAAW;EAEb,IAAI,KAAKI,YAAY,KAAA,GAAW;GAC9B,IAAI,KAAKC,mBAAmB;IAC1B,KAAKA,oBAAoB;IACzB,MAAM,IAAI,oBAAoB;KAAE,QAAQ,KAAKL;KAAS,WAAW,KAAK;IAAU,GAAG,CAAC,KAAKA,OAAO,CAAC;GACnG;GACA,KAAKK,oBAAoB;GACzB,KAAKD,UAAU,SAAS,KAAKJ,SAAS,KAAK,QAAQ;GACnD,KAAKK,oBAAoB;EAC3B;EACA,OAAO,CAAC,CAAC,KAAKD;CAChB;CAEA,CAAC,aAAa,KAAA;AAChB;;AAGA,SAAgB,WAAW,eAAyD;CAClF,OAAO,yBAAyB;AAClC;;AAGA,SAAgB,iBAAiB,eAAoF;CACnH,OAAO,WAAW,aAAa,KAAK,cAAc;AACpD"}
+{"version":3,"file":"hasProperty.js","names":[],"sources":["../../src/relations/hasProperty.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { getMetadata } from \"src/EntityMetadata.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"src/loading/loadHints.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport {\n  type MaybeReactedPropertyEntity,\n  type Reacted,\n  type ReactiveHint,\n  convertToLoadHint,\n} from \"src/reactivity/reactiveHints.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\nimport { RecursiveCycleError } from \"src/relations/RecursiveCycleError.ts\";\nimport { tryResolve } from \"src/utils.ts\";\n\nexport { PropertyT };\n\nexport interface Property<T extends Entity, V> {\n  // Differentiate from AsyncMethod\n  [PropertyT]: T;\n  isLoaded: boolean;\n  load(): Promise<V>;\n}\n\nexport interface LoadedProperty<T extends Entity, V> {\n  get: V;\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(\n  loadHint: H,\n  fn: (entity: Loaded<T, H>) => V,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, loadHint, fn);\n  });\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasReactiveProperty<T extends Entity, const H extends ReactiveHint<T>, V>(\n  reactiveHint: H,\n  fn: (entity: Reacted<T, H>) => MaybeReactedPropertyEntity<V>,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, reactiveHint as any, fn as any, { isReactive: true });\n  });\n}\n\nexport class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements Property<T, V> {\n  // We'll probe for loaded if undefined\n  #loaded: boolean | undefined = undefined;\n  #isCheckingLoaded = false;\n  #loadPromise: any;\n\n  readonly #entity: T;\n  #hint: H | undefined;\n  #reactiveHint: ReactiveHint<T> | undefined;\n  constructor(\n    entity: T,\n    private fieldName: string,\n    hint: H | ReactiveHint<T>,\n    private fn: (entity: Loaded<T, H>) => V,\n    private opts: { isReactive?: boolean } = {},\n  ) {\n    const { isReactive = false } = opts;\n    this.#entity = entity;\n    this.#hint = isReactive ? undefined : (hint as H);\n    this.#reactiveHint = isReactive ? (hint as ReactiveHint<T>) : undefined;\n  }\n\n  load(): Promise<V> {\n    if (!this.isLoaded) {\n      const { loadHint, fn } = this;\n      return (this.#loadPromise ??= this.#entity.em.populate(this.#entity, loadHint).then((loaded) => {\n        this.#loaded = true;\n        return fn(loaded);\n      }));\n    }\n    return tryResolve(() => this.get);\n  }\n\n  get loadHint(): H {\n    if (!this.#hint) {\n      // Would be nice to statically (but lazily?) cache this...\n      this.#hint = convertToLoadHint(getMetadata(this.#entity), this.#reactiveHint as any) as H;\n    }\n    return this.#hint;\n  }\n\n  get reactiveHint(): ReactiveHint<T> | undefined {\n    return this.#reactiveHint;\n  }\n\n  get get(): V {\n    return this.fn(this.#entity as Loaded<T, H>);\n  }\n\n  get isLoaded() {\n    // Probe the first time, which is useful for factories that are DeepNew\n    if (this.#loaded === undefined) {\n      if (this.#isCheckingLoaded) {\n        this.#isCheckingLoaded = false;\n        throw new RecursiveCycleError({ entity: this.#entity, fieldName: this.fieldName }, [this.#entity]);\n      }\n      this.#isCheckingLoaded = true;\n      this.#loaded = isLoaded(this.#entity, this.loadHint);\n      this.#isCheckingLoaded = false;\n    }\n    return !!this.#loaded;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a Property. */\nexport function isProperty(maybeProperty: any): maybeProperty is Property<any, any> {\n  return maybeProperty instanceof PropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded Property. */\nexport function isLoadedProperty(maybeProperty: any): maybeProperty is Property<any, any> & LoadedProperty<any, any> {\n  return isProperty(maybeProperty) && maybeProperty.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmCA,SAAgB,YACd,UACA,IACgB;CAChB,OAAO,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,UAAU,EAAE;CACzD,CAAC;AACH;;;;;;;;;AAUA,SAAgB,oBACd,cACA,IACgB;CAChB,OAAO,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,cAAqB,IAAW,EAAE,YAAY,KAAK,CAAC;CACjG,CAAC;AACH;AAEA,IAAa,eAAb,MAAgG;CAWpF;CAEA;CACA;CAZV,UAA+B,KAAA;CAC/B,oBAAoB;CACpB;CAEA;CACA;CACA;CACA,YACE,QACA,WACA,MACA,IACA,OAAyC,CAAC,GAC1C;EAJQ,KAAA,YAAA;EAEA,KAAA,KAAA;EACA,KAAA,OAAA;EAER,MAAM,EAAE,aAAa,UAAU;EAC/B,KAAK,UAAU;EACf,KAAK,QAAQ,aAAa,KAAA,IAAa;EACvC,KAAK,gBAAgB,aAAc,OAA2B,KAAA;CAChE;CAEA,OAAmB;EACjB,IAAI,CAAC,KAAK,UAAU;GAClB,MAAM,EAAE,UAAU,OAAO;GACzB,OAAQ,KAAK,iBAAiB,KAAK,QAAQ,GAAG,SAAS,KAAK,SAAS,QAAQ,CAAC,CAAC,MAAM,WAAW;IAC9F,KAAK,UAAU;IACf,OAAO,GAAG,MAAM;GAClB,CAAC;EACH;EACA,OAAO,iBAAiB,KAAK,GAAG;CAClC;CAEA,IAAI,WAAc;EAChB,IAAI,CAAC,KAAK,OAER,KAAK,QAAQ,kBAAkB,YAAY,KAAK,OAAO,GAAG,KAAK,aAAoB;EAErF,OAAO,KAAK;CACd;CAEA,IAAI,eAA4C;EAC9C,OAAO,KAAK;CACd;CAEA,IAAI,MAAS;EACX,OAAO,KAAK,GAAG,KAAK,OAAuB;CAC7C;CAEA,IAAI,WAAW;EAEb,IAAI,KAAK,YAAY,KAAA,GAAW;GAC9B,IAAI,KAAK,mBAAmB;IAC1B,KAAK,oBAAoB;IACzB,MAAM,IAAI,oBAAoB;KAAE,QAAQ,KAAK;KAAS,WAAW,KAAK;IAAU,GAAG,CAAC,KAAK,OAAO,CAAC;GACnG;GACA,KAAK,oBAAoB;GACzB,KAAK,UAAU,SAAS,KAAK,SAAS,KAAK,QAAQ;GACnD,KAAK,oBAAoB;EAC3B;EACA,OAAO,CAAC,CAAC,KAAK;CAChB;CAEA,CAAC,aAAa,KAAA;AAChB;;AAGA,SAAgB,WAAW,eAAyD;CAClF,OAAO,yBAAyB;AAClC;;AAGA,SAAgB,iBAAiB,eAAoF;CACnH,OAAO,WAAW,aAAa,KAAK,cAAc;AACpD"}