joist-core 2.3.0-next.97 → 2.3.0-next.99

package/build/relations/Relation.js.map

@@ -1 +1 @@
-{"version":3,"file":"Relation.js","names":[],"sources":["../../src/relations/Relation.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { isCollection, isReference } from \"./index.ts\";\nimport { RelationT, RelationU } from \"./RelationSymbols.ts\";\n\nexport { RelationT, RelationU };\n\n/** A relationship from `T` to `U`, could be any of many-to-one, one-to-many, or many-to-many. */\nexport interface Relation<T extends Entity, U extends Entity> {\n  // Make our Relation somewhat non-structural, otherwise since it's a marker interface,\n  // types like `number` or `string` will match it. This also seems to nudge the type\n  // inference inside `LoadHint` to go beyond \"this generic T of Entity has id and __orm\"\n  // to \"no really this generic T has fields firstName, title, etc.\".\n  // See https://stackoverflow.com/questions/53448100/generic-type-of-extended-interface-not-inferred\n  // And https://github.com/microsoft/TypeScript/issues/47213\n  [RelationT]: T;\n  [RelationU]: U;\n  isLoaded: boolean;\n  entity: Entity;\n  hasBeenSet: boolean;\n}\n\n/** Type guard utility for determining if an entity field is a Relation. */\nexport function isRelation(maybeRelation: any): maybeRelation is Relation<any, any> {\n  return isReference(maybeRelation) || isCollection(maybeRelation);\n}\n"],"mappings":";;;;;;;AAsBA,SAAgB,WAAW,eAAyD;CAClF,OAAO,YAAY,aAAa,KAAK,aAAa,aAAa;AACjE"}
+{"version":3,"file":"Relation.js","names":[],"sources":["../../src/relations/Relation.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { isCollection, isReference } from \"src/relations/index.ts\";\nimport { RelationT, RelationU } from \"src/relations/RelationSymbols.ts\";\n\nexport { RelationT, RelationU };\n\n/** A relationship from `T` to `U`, could be any of many-to-one, one-to-many, or many-to-many. */\nexport interface Relation<T extends Entity, U extends Entity> {\n  // Make our Relation somewhat non-structural, otherwise since it's a marker interface,\n  // types like `number` or `string` will match it. This also seems to nudge the type\n  // inference inside `LoadHint` to go beyond \"this generic T of Entity has id and __orm\"\n  // to \"no really this generic T has fields firstName, title, etc.\".\n  // See https://stackoverflow.com/questions/53448100/generic-type-of-extended-interface-not-inferred\n  // And https://github.com/microsoft/TypeScript/issues/47213\n  [RelationT]: T;\n  [RelationU]: U;\n  isLoaded: boolean;\n  entity: Entity;\n  hasBeenSet: boolean;\n}\n\n/** Type guard utility for determining if an entity field is a Relation. */\nexport function isRelation(maybeRelation: any): maybeRelation is Relation<any, any> {\n  return isReference(maybeRelation) || isCollection(maybeRelation);\n}\n"],"mappings":";;;;;;;AAsBA,SAAgB,WAAW,eAAyD;CAClF,OAAO,YAAY,aAAa,KAAK,aAAa,aAAa;AACjE"}

package/build/relations/hasAsyncMethod.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_loadHints = require("../loadHints.cjs");
+const require_loading_loadHints = require("../loading/loadHints.cjs");
 const require_newEntity = require("../newEntity.cjs");
 require("../Entity.cjs");
 //#region src/relations/hasAsyncMethod.ts
@@ -35,7 +35,7 @@ var AsyncMethodImpl = class {
 		return this.fn(this.#entity, ...args);
 	}
 	get isLoaded() {
-		return this.loaded || require_loadHints.isLoaded(this.#entity, this.#hint);
+		return this.loaded || require_loading_loadHints.isLoaded(this.#entity, this.#hint);
 	}
 	[AsyncMethodM];
 };

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 \"../Entity.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"../loadHints.ts\";\nimport { lazyField } from \"../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,kBAAAA,SAAS,KAAKF,SAAS,KAAKC,KAAK;CACzD;CAEA,CAAC;AACH"}
+{"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"}

package/build/relations/hasAsyncMethod.d.cts

@@ -1,4 +1,4 @@
-import { LoadHint, Loaded } from "../loadHints.cjs";
+import { LoadHint, Loaded } from "../loading/loadHints.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/hasAsyncMethod.d.ts
 declare const AsyncMethodM: unique symbol;

package/build/relations/hasAsyncMethod.d.mts

@@ -1,4 +1,4 @@
-import { LoadHint, Loaded } from "../loadHints.mjs";
+import { LoadHint, Loaded } from "../loading/loadHints.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/hasAsyncMethod.d.ts
 declare const AsyncMethodM: unique symbol;

package/build/relations/hasAsyncMethod.js

@@ -1,4 +1,4 @@
-import { isLoaded } from "../loadHints.js";
+import { isLoaded } from "../loading/loadHints.js";
 import { lazyField } from "../newEntity.js";
 import "../Entity.js";
 //#region src/relations/hasAsyncMethod.ts

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 \"../Entity.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"../loadHints.ts\";\nimport { lazyField } from \"../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":["#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"}

package/build/relations/hasManyDerived.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_loadHints = require("../loadHints.cjs");
-const require_newEntity = require("../newEntity.cjs");
 const require_relations_CustomCollection = require("./CustomCollection.cjs");
+const require_loading_loadHints = require("../loading/loadHints.cjs");
+const require_newEntity = require("../newEntity.cjs");
 require("../index.cjs");
 require("../Entity.cjs");
 //#region src/relations/hasManyDerived.ts
@@ -23,7 +23,7 @@ function hasManyDerived(loadHint, opts) {
 					...opts
 				});
 			},
-			isLoaded: () => require_loadHints.isLoaded(entity, loadHint),
+			isLoaded: () => require_loading_loadHints.isLoaded(entity, loadHint),
 			loadHint,
 			...rest
 		});

package/build/relations/hasManyDerived.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hasManyDerived.cjs","names":["lazyField","CustomCollection","isLoaded"],"sources":["../../src/relations/hasManyDerived.ts"],"sourcesContent":["import { type Collection, isLoaded } from \"..//index.ts\";\nimport { type Entity } from \"../Entity.ts\";\nimport { type LoadHint, type Loaded } from \"../loadHints.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { CustomCollection } from \"./CustomCollection.ts\";\n\ntype HasManyDerivedOpts<T extends Entity, U extends Entity, H extends LoadHint<T>> = {\n  load?: (entity: T, opts: { forceReload?: boolean }) => Promise<any>;\n  get: (entity: Loaded<T, H>) => readonly U[];\n  set?: (entity: Loaded<T, H>, values: U[]) => void;\n  add?: (entity: Loaded<T, H>, value: U) => void;\n  remove?: (entity: Loaded<T, H>, value: U) => void;\n};\n\n/**\n * Creates a CustomCollection that can conditionally walk across references in the object graph.\n *\n * I.e. An Author \"has many reviews\" through the `author -> books -> reviews` relation.\n *\n * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, \"reviews\")`.\n */\nexport function hasManyDerived<T extends Entity, U extends Entity, H extends LoadHint<T>>(\n  loadHint: H,\n  opts: HasManyDerivedOpts<T, U, H>,\n): Collection<T, U> {\n  const { load, ...rest } = opts;\n  return lazyField((entity: T) => {\n    return new CustomCollection<T, U>(entity, {\n      load(entity, opts) {\n        if (load) {\n          return load(entity, opts);\n        } else {\n          return entity.em.populate(entity, { hint: loadHint, ...opts });\n        }\n      },\n      isLoaded: () => isLoaded(entity, loadHint),\n      loadHint,\n      ...(rest as any),\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAqBA,SAAgB,eACd,UACA,MACkB;CAClB,MAAM,EAAE,MAAM,GAAG,SAAS;CAC1B,OAAOA,kBAAAA,WAAW,WAAc;EAC9B,OAAO,IAAIC,mCAAAA,iBAAuB,QAAQ;GACxC,KAAK,QAAQ,MAAM;IACjB,IAAI,MACF,OAAO,KAAK,QAAQ,IAAI;SAExB,OAAO,OAAO,GAAG,SAAS,QAAQ;KAAE,MAAM;KAAU,GAAG;IAAK,CAAC;GAEjE;GACA,gBAAgBC,kBAAAA,SAAS,QAAQ,QAAQ;GACzC;GACA,GAAI;EACN,CAAC;CACH,CAAC;AACH"}
+{"version":3,"file":"hasManyDerived.cjs","names":["lazyField","CustomCollection","isLoaded"],"sources":["../../src/relations/hasManyDerived.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type Collection, isLoaded } from \"src/index.ts\";\nimport type { LoadHint, Loaded } from \"src/loading/loadHints.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { CustomCollection } from \"src/relations/CustomCollection.ts\";\n\ntype HasManyDerivedOpts<T extends Entity, U extends Entity, H extends LoadHint<T>> = {\n  load?: (entity: T, opts: { forceReload?: boolean }) => Promise<any>;\n  get: (entity: Loaded<T, H>) => readonly U[];\n  set?: (entity: Loaded<T, H>, values: U[]) => void;\n  add?: (entity: Loaded<T, H>, value: U) => void;\n  remove?: (entity: Loaded<T, H>, value: U) => void;\n};\n\n/**\n * Creates a CustomCollection that can conditionally walk across references in the object graph.\n *\n * I.e. An Author \"has many reviews\" through the `author -> books -> reviews` relation.\n *\n * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, \"reviews\")`.\n */\nexport function hasManyDerived<T extends Entity, U extends Entity, H extends LoadHint<T>>(\n  loadHint: H,\n  opts: HasManyDerivedOpts<T, U, H>,\n): Collection<T, U> {\n  const { load, ...rest } = opts;\n  return lazyField((entity: T) => {\n    return new CustomCollection<T, U>(entity, {\n      load(entity, opts) {\n        if (load) {\n          return load(entity, opts);\n        } else {\n          return entity.em.populate(entity, { hint: loadHint, ...opts });\n        }\n      },\n      isLoaded: () => isLoaded(entity, loadHint),\n      loadHint,\n      ...(rest as any),\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAqBA,SAAgB,eACd,UACA,MACkB;CAClB,MAAM,EAAE,MAAM,GAAG,SAAS;CAC1B,OAAOA,kBAAAA,WAAW,WAAc;EAC9B,OAAO,IAAIC,mCAAAA,iBAAuB,QAAQ;GACxC,KAAK,QAAQ,MAAM;IACjB,IAAI,MACF,OAAO,KAAK,QAAQ,IAAI;SAExB,OAAO,OAAO,GAAG,SAAS,QAAQ;KAAE,MAAM;KAAU,GAAG;IAAK,CAAC;GAEjE;GACA,gBAAgBC,0BAAAA,SAAS,QAAQ,QAAQ;GACzC;GACA,GAAI;EACN,CAAC;CACH,CAAC;AACH"}

package/build/relations/hasManyDerived.d.cts

@@ -1,5 +1,5 @@
 import { Collection } from "./Collection.cjs";
-import { LoadHint, Loaded } from "../loadHints.cjs";
+import { LoadHint, Loaded } from "../loading/loadHints.cjs";
 import "../index.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/hasManyDerived.d.ts

package/build/relations/hasManyDerived.d.mts

@@ -1,5 +1,5 @@
 import { Collection } from "./Collection.mjs";
-import { LoadHint, Loaded } from "../loadHints.mjs";
+import { LoadHint, Loaded } from "../loading/loadHints.mjs";
 import "../index.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/hasManyDerived.d.ts

package/build/relations/hasManyDerived.js

@@ -1,6 +1,6 @@
-import { isLoaded } from "../loadHints.js";
-import { lazyField } from "../newEntity.js";
 import { CustomCollection } from "./CustomCollection.js";
+import { isLoaded } from "../loading/loadHints.js";
+import { lazyField } from "../newEntity.js";
 import "../index.js";
 import "../Entity.js";
 //#region src/relations/hasManyDerived.ts

package/build/relations/hasManyDerived.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasManyDerived.js","names":[],"sources":["../../src/relations/hasManyDerived.ts"],"sourcesContent":["import { type Collection, isLoaded } from \"..//index.ts\";\nimport { type Entity } from \"../Entity.ts\";\nimport { type LoadHint, type Loaded } from \"../loadHints.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { CustomCollection } from \"./CustomCollection.ts\";\n\ntype HasManyDerivedOpts<T extends Entity, U extends Entity, H extends LoadHint<T>> = {\n  load?: (entity: T, opts: { forceReload?: boolean }) => Promise<any>;\n  get: (entity: Loaded<T, H>) => readonly U[];\n  set?: (entity: Loaded<T, H>, values: U[]) => void;\n  add?: (entity: Loaded<T, H>, value: U) => void;\n  remove?: (entity: Loaded<T, H>, value: U) => void;\n};\n\n/**\n * Creates a CustomCollection that can conditionally walk across references in the object graph.\n *\n * I.e. An Author \"has many reviews\" through the `author -> books -> reviews` relation.\n *\n * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, \"reviews\")`.\n */\nexport function hasManyDerived<T extends Entity, U extends Entity, H extends LoadHint<T>>(\n  loadHint: H,\n  opts: HasManyDerivedOpts<T, U, H>,\n): Collection<T, U> {\n  const { load, ...rest } = opts;\n  return lazyField((entity: T) => {\n    return new CustomCollection<T, U>(entity, {\n      load(entity, opts) {\n        if (load) {\n          return load(entity, opts);\n        } else {\n          return entity.em.populate(entity, { hint: loadHint, ...opts });\n        }\n      },\n      isLoaded: () => isLoaded(entity, loadHint),\n      loadHint,\n      ...(rest as any),\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAqBA,SAAgB,eACd,UACA,MACkB;CAClB,MAAM,EAAE,MAAM,GAAG,SAAS;CAC1B,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,iBAAuB,QAAQ;GACxC,KAAK,QAAQ,MAAM;IACjB,IAAI,MACF,OAAO,KAAK,QAAQ,IAAI;SAExB,OAAO,OAAO,GAAG,SAAS,QAAQ;KAAE,MAAM;KAAU,GAAG;IAAK,CAAC;GAEjE;GACA,gBAAgB,SAAS,QAAQ,QAAQ;GACzC;GACA,GAAI;EACN,CAAC;CACH,CAAC;AACH"}
+{"version":3,"file":"hasManyDerived.js","names":[],"sources":["../../src/relations/hasManyDerived.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type Collection, isLoaded } from \"src/index.ts\";\nimport type { LoadHint, Loaded } from \"src/loading/loadHints.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { CustomCollection } from \"src/relations/CustomCollection.ts\";\n\ntype HasManyDerivedOpts<T extends Entity, U extends Entity, H extends LoadHint<T>> = {\n  load?: (entity: T, opts: { forceReload?: boolean }) => Promise<any>;\n  get: (entity: Loaded<T, H>) => readonly U[];\n  set?: (entity: Loaded<T, H>, values: U[]) => void;\n  add?: (entity: Loaded<T, H>, value: U) => void;\n  remove?: (entity: Loaded<T, H>, value: U) => void;\n};\n\n/**\n * Creates a CustomCollection that can conditionally walk across references in the object graph.\n *\n * I.e. An Author \"has many reviews\" through the `author -> books -> reviews` relation.\n *\n * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, \"reviews\")`.\n */\nexport function hasManyDerived<T extends Entity, U extends Entity, H extends LoadHint<T>>(\n  loadHint: H,\n  opts: HasManyDerivedOpts<T, U, H>,\n): Collection<T, U> {\n  const { load, ...rest } = opts;\n  return lazyField((entity: T) => {\n    return new CustomCollection<T, U>(entity, {\n      load(entity, opts) {\n        if (load) {\n          return load(entity, opts);\n        } else {\n          return entity.em.populate(entity, { hint: loadHint, ...opts });\n        }\n      },\n      isLoaded: () => isLoaded(entity, loadHint),\n      loadHint,\n      ...(rest as any),\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAqBA,SAAgB,eACd,UACA,MACkB;CAClB,MAAM,EAAE,MAAM,GAAG,SAAS;CAC1B,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,iBAAuB,QAAQ;GACxC,KAAK,QAAQ,MAAM;IACjB,IAAI,MACF,OAAO,KAAK,QAAQ,IAAI;SAExB,OAAO,OAAO,GAAG,SAAS,QAAQ;KAAE,MAAM;KAAU,GAAG;IAAK,CAAC;GAEjE;GACA,gBAAgB,SAAS,QAAQ,QAAQ;GACzC;GACA,GAAI;EACN,CAAC;CACH,CAAC;AACH"}

package/build/relations/hasManyThrough.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_newEntity = require("../newEntity.cjs");
 const require_relations_CustomCollection = require("./CustomCollection.cjs");
+const require_newEntity = require("../newEntity.cjs");
 const require_EntityMetadata = require("../EntityMetadata.cjs");
-const require_loadLens = require("../loadLens.cjs");
+const require_loading_loadLens = require("../loading/loadLens.cjs");
 require("../index.cjs");
 //#region src/relations/hasManyThrough.ts
 /**
@@ -16,10 +16,10 @@ function hasManyThrough(lens) {
 	return require_newEntity.lazyField((entity) => {
 		const meta = require_EntityMetadata.getMetadata(entity);
 		return new require_relations_CustomCollection.CustomCollection(entity, {
-			load: (entity, opts) => require_loadLens.loadLens(entity, lens, opts),
-			get: () => require_loadLens.getLens(meta, entity, lens),
-			isLoaded: () => require_loadLens.isLensLoaded(entity, lens),
-			loadHint: () => require_loadLens.lensToLoadHint(lens)
+			load: (entity, opts) => require_loading_loadLens.loadLens(entity, lens, opts),
+			get: () => require_loading_loadLens.getLens(meta, entity, lens),
+			isLoaded: () => require_loading_loadLens.isLensLoaded(entity, lens),
+			loadHint: () => require_loading_loadLens.lensToLoadHint(lens)
 		});
 	});
 }

package/build/relations/hasManyThrough.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hasManyThrough.cjs","names":["lazyField","getMetadata","CustomCollection","loadLens","getLens","isLensLoaded","lensToLoadHint"],"sources":["../../src/relations/hasManyThrough.ts"],"sourcesContent":["import {\n  type Collection,\n  CustomCollection,\n  type Entity,\n  type Lens,\n  getLens,\n  getMetadata,\n  isLensLoaded,\n  lensToLoadHint,\n  loadLens,\n} from \"../index.ts\";\nimport { lazyField } from \"../newEntity.ts\";\n\n/**\n * Creates a CustomCollection that will walk across references in the object graph.\n *\n * I.e. An Author \"has many reviews\" through the `author -> books -> reviews` relation.\n *\n * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, \"reviews\")`.\n */\nexport function hasManyThrough<T extends Entity, U extends Entity>(\n  lens: (lens: Lens<T>) => Lens<U, U[]>,\n): Collection<T, U> {\n  return lazyField((entity: T) => {\n    const meta = getMetadata(entity);\n    return new CustomCollection<T, U>(entity, {\n      load: (entity, opts) => loadLens(entity, lens, opts),\n      get: () => getLens(meta, entity, lens),\n      isLoaded: () => isLensLoaded(entity, lens),\n      loadHint: () => lensToLoadHint(lens),\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAoBA,SAAgB,eACd,MACkB;CAClB,OAAOA,kBAAAA,WAAW,WAAc;EAC9B,MAAM,OAAOC,uBAAAA,YAAY,MAAM;EAC/B,OAAO,IAAIC,mCAAAA,iBAAuB,QAAQ;GACxC,OAAO,QAAQ,SAASC,iBAAAA,SAAS,QAAQ,MAAM,IAAI;GACnD,WAAWC,iBAAAA,QAAQ,MAAM,QAAQ,IAAI;GACrC,gBAAgBC,iBAAAA,aAAa,QAAQ,IAAI;GACzC,gBAAgBC,iBAAAA,eAAe,IAAI;EACrC,CAAC;CACH,CAAC;AACH"}
+{"version":3,"file":"hasManyThrough.cjs","names":["lazyField","getMetadata","CustomCollection","loadLens","getLens","isLensLoaded","lensToLoadHint"],"sources":["../../src/relations/hasManyThrough.ts"],"sourcesContent":["import {\n  type Collection,\n  CustomCollection,\n  type Entity,\n  type Lens,\n  getLens,\n  getMetadata,\n  isLensLoaded,\n  lensToLoadHint,\n  loadLens,\n} from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\n\n/**\n * Creates a CustomCollection that will walk across references in the object graph.\n *\n * I.e. An Author \"has many reviews\" through the `author -> books -> reviews` relation.\n *\n * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, \"reviews\")`.\n */\nexport function hasManyThrough<T extends Entity, U extends Entity>(\n  lens: (lens: Lens<T>) => Lens<U, U[]>,\n): Collection<T, U> {\n  return lazyField((entity: T) => {\n    const meta = getMetadata(entity);\n    return new CustomCollection<T, U>(entity, {\n      load: (entity, opts) => loadLens(entity, lens, opts),\n      get: () => getLens(meta, entity, lens),\n      isLoaded: () => isLensLoaded(entity, lens),\n      loadHint: () => lensToLoadHint(lens),\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAoBA,SAAgB,eACd,MACkB;CAClB,OAAOA,kBAAAA,WAAW,WAAc;EAC9B,MAAM,OAAOC,uBAAAA,YAAY,MAAM;EAC/B,OAAO,IAAIC,mCAAAA,iBAAuB,QAAQ;GACxC,OAAO,QAAQ,SAASC,yBAAAA,SAAS,QAAQ,MAAM,IAAI;GACnD,WAAWC,yBAAAA,QAAQ,MAAM,QAAQ,IAAI;GACrC,gBAAgBC,yBAAAA,aAAa,QAAQ,IAAI;GACzC,gBAAgBC,yBAAAA,eAAe,IAAI;EACrC,CAAC;CACH,CAAC;AACH"}

package/build/relations/hasManyThrough.d.cts

@@ -1,5 +1,5 @@
 import { Collection } from "./Collection.cjs";
-import { Lens } from "../loadLens.cjs";
+import { Lens } from "../loading/loadLens.cjs";
 import "../index.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/hasManyThrough.d.ts

package/build/relations/hasManyThrough.d.mts

@@ -1,5 +1,5 @@
 import { Collection } from "./Collection.mjs";
-import { Lens } from "../loadLens.mjs";
+import { Lens } from "../loading/loadLens.mjs";
 import "../index.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/hasManyThrough.d.ts

package/build/relations/hasManyThrough.js

@@ -1,7 +1,7 @@
-import { lazyField } from "../newEntity.js";
 import { CustomCollection } from "./CustomCollection.js";
+import { lazyField } from "../newEntity.js";
 import { getMetadata } from "../EntityMetadata.js";
-import { getLens, isLensLoaded, lensToLoadHint, loadLens } from "../loadLens.js";
+import { getLens, isLensLoaded, lensToLoadHint, loadLens } from "../loading/loadLens.js";
 import "../index.js";
 //#region src/relations/hasManyThrough.ts
 /**

package/build/relations/hasManyThrough.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasManyThrough.js","names":[],"sources":["../../src/relations/hasManyThrough.ts"],"sourcesContent":["import {\n  type Collection,\n  CustomCollection,\n  type Entity,\n  type Lens,\n  getLens,\n  getMetadata,\n  isLensLoaded,\n  lensToLoadHint,\n  loadLens,\n} from \"../index.ts\";\nimport { lazyField } from \"../newEntity.ts\";\n\n/**\n * Creates a CustomCollection that will walk across references in the object graph.\n *\n * I.e. An Author \"has many reviews\" through the `author -> books -> reviews` relation.\n *\n * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, \"reviews\")`.\n */\nexport function hasManyThrough<T extends Entity, U extends Entity>(\n  lens: (lens: Lens<T>) => Lens<U, U[]>,\n): Collection<T, U> {\n  return lazyField((entity: T) => {\n    const meta = getMetadata(entity);\n    return new CustomCollection<T, U>(entity, {\n      load: (entity, opts) => loadLens(entity, lens, opts),\n      get: () => getLens(meta, entity, lens),\n      isLoaded: () => isLensLoaded(entity, lens),\n      loadHint: () => lensToLoadHint(lens),\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAoBA,SAAgB,eACd,MACkB;CAClB,OAAO,WAAW,WAAc;EAC9B,MAAM,OAAO,YAAY,MAAM;EAC/B,OAAO,IAAI,iBAAuB,QAAQ;GACxC,OAAO,QAAQ,SAAS,SAAS,QAAQ,MAAM,IAAI;GACnD,WAAW,QAAQ,MAAM,QAAQ,IAAI;GACrC,gBAAgB,aAAa,QAAQ,IAAI;GACzC,gBAAgB,eAAe,IAAI;EACrC,CAAC;CACH,CAAC;AACH"}
+{"version":3,"file":"hasManyThrough.js","names":[],"sources":["../../src/relations/hasManyThrough.ts"],"sourcesContent":["import {\n  type Collection,\n  CustomCollection,\n  type Entity,\n  type Lens,\n  getLens,\n  getMetadata,\n  isLensLoaded,\n  lensToLoadHint,\n  loadLens,\n} from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\n\n/**\n * Creates a CustomCollection that will walk across references in the object graph.\n *\n * I.e. An Author \"has many reviews\" through the `author -> books -> reviews` relation.\n *\n * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, \"reviews\")`.\n */\nexport function hasManyThrough<T extends Entity, U extends Entity>(\n  lens: (lens: Lens<T>) => Lens<U, U[]>,\n): Collection<T, U> {\n  return lazyField((entity: T) => {\n    const meta = getMetadata(entity);\n    return new CustomCollection<T, U>(entity, {\n      load: (entity, opts) => loadLens(entity, lens, opts),\n      get: () => getLens(meta, entity, lens),\n      isLoaded: () => isLensLoaded(entity, lens),\n      loadHint: () => lensToLoadHint(lens),\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAoBA,SAAgB,eACd,MACkB;CAClB,OAAO,WAAW,WAAc;EAC9B,MAAM,OAAO,YAAY,MAAM;EAC/B,OAAO,IAAI,iBAAuB,QAAQ;GACxC,OAAO,QAAQ,SAAS,SAAS,QAAQ,MAAM,IAAI;GACnD,WAAW,QAAQ,MAAM,QAAQ,IAAI;GACrC,gBAAgB,aAAa,QAAQ,IAAI;GACzC,gBAAgB,eAAe,IAAI;EACrC,CAAC;CACH,CAAC;AACH"}

package/build/relations/hasOneDerived.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_CustomReference = require("./CustomReference.cjs");
+const require_loading_loadHints = require("../loading/loadHints.cjs");
 require("./Reference.cjs");
-const require_loadHints = require("../loadHints.cjs");
 const require_newEntity = require("../newEntity.cjs");
-const require_relations_CustomReference = require("./CustomReference.cjs");
 require("../index.cjs");
 require("../Entity.cjs");
 //#region src/relations/hasOneDerived.ts
@@ -21,7 +21,7 @@ function hasOneDerived(loadHint, get) {
 				...opts
 			}),
 			get: () => get(entity),
-			isLoaded: () => require_loadHints.isLoaded(entity, loadHint),
+			isLoaded: () => require_loading_loadHints.isLoaded(entity, loadHint),
 			loadHint
 		});
 	});

package/build/relations/hasOneDerived.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hasOneDerived.cjs","names":["lazyField","CustomReference","isLoaded"],"sources":["../../src/relations/hasOneDerived.ts"],"sourcesContent":["import { isLoaded } from \"..//index.ts\";\nimport { type Entity } from \"../Entity.ts\";\nimport { type LoadHint, type Loaded } from \"../loadHints.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { CustomReference } from \"./CustomReference.ts\";\nimport { type Reference } from \"./Reference.ts\";\n\n/**\n * Creates a CustomReference that can conditionally walk across references in the object graph.\n *\n * I.e. A BookReview \"has one author\" through the `review -> book -> author` relation.\n *\n * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, \"author\")`.\n */\nexport function hasOneDerived<\n  T extends Entity,\n  U extends Entity,\n  N extends never | undefined,\n  V extends U | N,\n  const H extends LoadHint<T>,\n>(loadHint: H, get: (entity: Loaded<T, H>) => V): Reference<T, U, N> {\n  return lazyField((entity: T) => {\n    return new CustomReference<T, U, N>(entity, {\n      load: (entity, opts) => entity.em.populate(entity, { hint: loadHint, ...opts }),\n      get: () => get(entity as Loaded<T, H>),\n      isLoaded: () => isLoaded(entity, loadHint as LoadHint<T>),\n      loadHint,\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;AAcA,SAAgB,cAMd,UAAa,KAAsD;CACnE,OAAOA,kBAAAA,WAAW,WAAc;EAC9B,OAAO,IAAIC,kCAAAA,gBAAyB,QAAQ;GAC1C,OAAO,QAAQ,SAAS,OAAO,GAAG,SAAS,QAAQ;IAAE,MAAM;IAAU,GAAG;GAAK,CAAC;GAC9E,WAAW,IAAI,MAAsB;GACrC,gBAAgBC,kBAAAA,SAAS,QAAQ,QAAuB;GACxD;EACF,CAAC;CACH,CAAC;AACH"}
+{"version":3,"file":"hasOneDerived.cjs","names":["lazyField","CustomReference","isLoaded"],"sources":["../../src/relations/hasOneDerived.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { isLoaded } from \"src/index.ts\";\nimport type { LoadHint, Loaded } from \"src/loading/loadHints.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { CustomReference } from \"src/relations/CustomReference.ts\";\nimport { type Reference } from \"src/relations/Reference.ts\";\n\n/**\n * Creates a CustomReference that can conditionally walk across references in the object graph.\n *\n * I.e. A BookReview \"has one author\" through the `review -> book -> author` relation.\n *\n * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, \"author\")`.\n */\nexport function hasOneDerived<\n  T extends Entity,\n  U extends Entity,\n  N extends never | undefined,\n  V extends U | N,\n  const H extends LoadHint<T>,\n>(loadHint: H, get: (entity: Loaded<T, H>) => V): Reference<T, U, N> {\n  return lazyField((entity: T) => {\n    return new CustomReference<T, U, N>(entity, {\n      load: (entity, opts) => entity.em.populate(entity, { hint: loadHint, ...opts }),\n      get: () => get(entity as Loaded<T, H>),\n      isLoaded: () => isLoaded(entity, loadHint as LoadHint<T>),\n      loadHint,\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;AAcA,SAAgB,cAMd,UAAa,KAAsD;CACnE,OAAOA,kBAAAA,WAAW,WAAc;EAC9B,OAAO,IAAIC,kCAAAA,gBAAyB,QAAQ;GAC1C,OAAO,QAAQ,SAAS,OAAO,GAAG,SAAS,QAAQ;IAAE,MAAM;IAAU,GAAG;GAAK,CAAC;GAC9E,WAAW,IAAI,MAAsB;GACrC,gBAAgBC,0BAAAA,SAAS,QAAQ,QAAuB;GACxD;EACF,CAAC;CACH,CAAC;AACH"}

package/build/relations/hasOneDerived.d.cts

@@ -1,5 +1,5 @@
 import { Reference } from "./Reference.cjs";
-import { LoadHint, Loaded } from "../loadHints.cjs";
+import { LoadHint, Loaded } from "../loading/loadHints.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/hasOneDerived.d.ts
 /**

package/build/relations/hasOneDerived.d.mts

@@ -1,5 +1,5 @@
 import { Reference } from "./Reference.mjs";
-import { LoadHint, Loaded } from "../loadHints.mjs";
+import { LoadHint, Loaded } from "../loading/loadHints.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/hasOneDerived.d.ts
 /**

package/build/relations/hasOneDerived.js

@@ -1,7 +1,7 @@
+import { CustomReference } from "./CustomReference.js";
+import { isLoaded } from "../loading/loadHints.js";
 import "./Reference.js";
-import { isLoaded } from "../loadHints.js";
 import { lazyField } from "../newEntity.js";
-import { CustomReference } from "./CustomReference.js";
 import "../index.js";
 import "../Entity.js";
 //#region src/relations/hasOneDerived.ts

package/build/relations/hasOneDerived.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasOneDerived.js","names":[],"sources":["../../src/relations/hasOneDerived.ts"],"sourcesContent":["import { isLoaded } from \"..//index.ts\";\nimport { type Entity } from \"../Entity.ts\";\nimport { type LoadHint, type Loaded } from \"../loadHints.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { CustomReference } from \"./CustomReference.ts\";\nimport { type Reference } from \"./Reference.ts\";\n\n/**\n * Creates a CustomReference that can conditionally walk across references in the object graph.\n *\n * I.e. A BookReview \"has one author\" through the `review -> book -> author` relation.\n *\n * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, \"author\")`.\n */\nexport function hasOneDerived<\n  T extends Entity,\n  U extends Entity,\n  N extends never | undefined,\n  V extends U | N,\n  const H extends LoadHint<T>,\n>(loadHint: H, get: (entity: Loaded<T, H>) => V): Reference<T, U, N> {\n  return lazyField((entity: T) => {\n    return new CustomReference<T, U, N>(entity, {\n      load: (entity, opts) => entity.em.populate(entity, { hint: loadHint, ...opts }),\n      get: () => get(entity as Loaded<T, H>),\n      isLoaded: () => isLoaded(entity, loadHint as LoadHint<T>),\n      loadHint,\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,SAAgB,cAMd,UAAa,KAAsD;CACnE,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,gBAAyB,QAAQ;GAC1C,OAAO,QAAQ,SAAS,OAAO,GAAG,SAAS,QAAQ;IAAE,MAAM;IAAU,GAAG;GAAK,CAAC;GAC9E,WAAW,IAAI,MAAsB;GACrC,gBAAgB,SAAS,QAAQ,QAAuB;GACxD;EACF,CAAC;CACH,CAAC;AACH"}
+{"version":3,"file":"hasOneDerived.js","names":[],"sources":["../../src/relations/hasOneDerived.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { isLoaded } from \"src/index.ts\";\nimport type { LoadHint, Loaded } from \"src/loading/loadHints.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { CustomReference } from \"src/relations/CustomReference.ts\";\nimport { type Reference } from \"src/relations/Reference.ts\";\n\n/**\n * Creates a CustomReference that can conditionally walk across references in the object graph.\n *\n * I.e. A BookReview \"has one author\" through the `review -> book -> author` relation.\n *\n * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, \"author\")`.\n */\nexport function hasOneDerived<\n  T extends Entity,\n  U extends Entity,\n  N extends never | undefined,\n  V extends U | N,\n  const H extends LoadHint<T>,\n>(loadHint: H, get: (entity: Loaded<T, H>) => V): Reference<T, U, N> {\n  return lazyField((entity: T) => {\n    return new CustomReference<T, U, N>(entity, {\n      load: (entity, opts) => entity.em.populate(entity, { hint: loadHint, ...opts }),\n      get: () => get(entity as Loaded<T, H>),\n      isLoaded: () => isLoaded(entity, loadHint as LoadHint<T>),\n      loadHint,\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,SAAgB,cAMd,UAAa,KAAsD;CACnE,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,gBAAyB,QAAQ;GAC1C,OAAO,QAAQ,SAAS,OAAO,GAAG,SAAS,QAAQ;IAAE,MAAM;IAAU,GAAG;GAAK,CAAC;GAC9E,WAAW,IAAI,MAAsB;GACrC,gBAAgB,SAAS,QAAQ,QAAuB;GACxD;EACF,CAAC;CACH,CAAC;AACH"}

package/build/relations/hasOneThrough.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_newEntity = require("../newEntity.cjs");
 const require_relations_CustomReference = require("./CustomReference.cjs");
+const require_newEntity = require("../newEntity.cjs");
 const require_EntityMetadata = require("../EntityMetadata.cjs");
-const require_loadLens = require("../loadLens.cjs");
+const require_loading_loadLens = require("../loading/loadLens.cjs");
 require("../index.cjs");
 //#region src/relations/hasOneThrough.ts
 /**
@@ -13,14 +13,14 @@ require("../index.cjs");
 * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, "author")`.
 */
 function hasOneThrough(lens) {
-	const paths = require_loadLens.lensToPath(lens);
-	const loadHint = require_loadLens.lensPathToLoadHint(paths);
+	const paths = require_loading_loadLens.lensToPath(lens);
+	const loadHint = require_loading_loadLens.lensPathToLoadHint(paths);
 	return require_newEntity.lazyField((entity) => {
 		const meta = require_EntityMetadata.getMetadata(entity);
 		return new require_relations_CustomReference.CustomReference(entity, {
-			load: (entity, opts) => require_loadLens.loadLensPath(entity, paths, opts),
-			get: () => require_loadLens.getLensPath(meta, entity, paths),
-			isLoaded: () => require_loadLens.isLensLoadedPath(entity, paths),
+			load: (entity, opts) => require_loading_loadLens.loadLensPath(entity, paths, opts),
+			get: () => require_loading_loadLens.getLensPath(meta, entity, paths),
+			isLoaded: () => require_loading_loadLens.isLensLoadedPath(entity, paths),
 			loadHint
 		});
 	});

package/build/relations/hasOneThrough.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hasOneThrough.cjs","names":["lensToPath","lensPathToLoadHint","lazyField","getMetadata","CustomReference","loadLensPath","getLensPath","isLensLoadedPath"],"sources":["../../src/relations/hasOneThrough.ts"],"sourcesContent":["import {\n  CustomReference,\n  type Entity,\n  type Lens,\n  type Reference,\n  getLensPath,\n  getMetadata,\n  isLensLoadedPath,\n  lensPathToLoadHint,\n  lensToPath,\n  loadLensPath,\n} from \"../index.ts\";\nimport { lazyField } from \"../newEntity.ts\";\n\n/**\n * Creates a CustomReference that will walk across references in the object graph.\n *\n * I.e. A BookReview \"has one author\" through the `review -> book -> author` relation.\n *\n * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, \"author\")`.\n */\nexport function hasOneThrough<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N>(\n  lens: (lens: Lens<T>) => Lens<V>,\n): Reference<T, U, N> {\n  const paths = lensToPath(lens);\n  const loadHint = lensPathToLoadHint<T>(paths);\n  return lazyField((entity: T) => {\n    const meta = getMetadata(entity);\n    return new CustomReference<T, U, N>(entity, {\n      load: (entity, opts) => loadLensPath(entity, paths, opts),\n      get: () => getLensPath(meta, entity, paths),\n      isLoaded: () => isLensLoadedPath(entity, paths),\n      loadHint,\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAqBA,SAAgB,cACd,MACoB;CACpB,MAAM,QAAQA,iBAAAA,WAAW,IAAI;CAC7B,MAAM,WAAWC,iBAAAA,mBAAsB,KAAK;CAC5C,OAAOC,kBAAAA,WAAW,WAAc;EAC9B,MAAM,OAAOC,uBAAAA,YAAY,MAAM;EAC/B,OAAO,IAAIC,kCAAAA,gBAAyB,QAAQ;GAC1C,OAAO,QAAQ,SAASC,iBAAAA,aAAa,QAAQ,OAAO,IAAI;GACxD,WAAWC,iBAAAA,YAAY,MAAM,QAAQ,KAAK;GAC1C,gBAAgBC,iBAAAA,iBAAiB,QAAQ,KAAK;GAC9C;EACF,CAAC;CACH,CAAC;AACH"}
+{"version":3,"file":"hasOneThrough.cjs","names":["lensToPath","lensPathToLoadHint","lazyField","getMetadata","CustomReference","loadLensPath","getLensPath","isLensLoadedPath"],"sources":["../../src/relations/hasOneThrough.ts"],"sourcesContent":["import {\n  CustomReference,\n  type Entity,\n  type Lens,\n  type Reference,\n  getLensPath,\n  getMetadata,\n  isLensLoadedPath,\n  lensPathToLoadHint,\n  lensToPath,\n  loadLensPath,\n} from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\n\n/**\n * Creates a CustomReference that will walk across references in the object graph.\n *\n * I.e. A BookReview \"has one author\" through the `review -> book -> author` relation.\n *\n * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, \"author\")`.\n */\nexport function hasOneThrough<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N>(\n  lens: (lens: Lens<T>) => Lens<V>,\n): Reference<T, U, N> {\n  const paths = lensToPath(lens);\n  const loadHint = lensPathToLoadHint<T>(paths);\n  return lazyField((entity: T) => {\n    const meta = getMetadata(entity);\n    return new CustomReference<T, U, N>(entity, {\n      load: (entity, opts) => loadLensPath(entity, paths, opts),\n      get: () => getLensPath(meta, entity, paths),\n      isLoaded: () => isLensLoadedPath(entity, paths),\n      loadHint,\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAqBA,SAAgB,cACd,MACoB;CACpB,MAAM,QAAQA,yBAAAA,WAAW,IAAI;CAC7B,MAAM,WAAWC,yBAAAA,mBAAsB,KAAK;CAC5C,OAAOC,kBAAAA,WAAW,WAAc;EAC9B,MAAM,OAAOC,uBAAAA,YAAY,MAAM;EAC/B,OAAO,IAAIC,kCAAAA,gBAAyB,QAAQ;GAC1C,OAAO,QAAQ,SAASC,yBAAAA,aAAa,QAAQ,OAAO,IAAI;GACxD,WAAWC,yBAAAA,YAAY,MAAM,QAAQ,KAAK;GAC1C,gBAAgBC,yBAAAA,iBAAiB,QAAQ,KAAK;GAC9C;EACF,CAAC;CACH,CAAC;AACH"}

package/build/relations/hasOneThrough.d.cts

@@ -1,5 +1,5 @@
 import { Reference } from "./Reference.cjs";
-import { Lens } from "../loadLens.cjs";
+import { Lens } from "../loading/loadLens.cjs";
 import "../index.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/hasOneThrough.d.ts

package/build/relations/hasOneThrough.d.mts

@@ -1,5 +1,5 @@
 import { Reference } from "./Reference.mjs";
-import { Lens } from "../loadLens.mjs";
+import { Lens } from "../loading/loadLens.mjs";
 import "../index.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/hasOneThrough.d.ts

package/build/relations/hasOneThrough.js

@@ -1,7 +1,7 @@
-import { lazyField } from "../newEntity.js";
 import { CustomReference } from "./CustomReference.js";
+import { lazyField } from "../newEntity.js";
 import { getMetadata } from "../EntityMetadata.js";
-import { getLensPath, isLensLoadedPath, lensPathToLoadHint, lensToPath, loadLensPath } from "../loadLens.js";
+import { getLensPath, isLensLoadedPath, lensPathToLoadHint, lensToPath, loadLensPath } from "../loading/loadLens.js";
 import "../index.js";
 //#region src/relations/hasOneThrough.ts
 /**

package/build/relations/hasOneThrough.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasOneThrough.js","names":[],"sources":["../../src/relations/hasOneThrough.ts"],"sourcesContent":["import {\n  CustomReference,\n  type Entity,\n  type Lens,\n  type Reference,\n  getLensPath,\n  getMetadata,\n  isLensLoadedPath,\n  lensPathToLoadHint,\n  lensToPath,\n  loadLensPath,\n} from \"../index.ts\";\nimport { lazyField } from \"../newEntity.ts\";\n\n/**\n * Creates a CustomReference that will walk across references in the object graph.\n *\n * I.e. A BookReview \"has one author\" through the `review -> book -> author` relation.\n *\n * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, \"author\")`.\n */\nexport function hasOneThrough<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N>(\n  lens: (lens: Lens<T>) => Lens<V>,\n): Reference<T, U, N> {\n  const paths = lensToPath(lens);\n  const loadHint = lensPathToLoadHint<T>(paths);\n  return lazyField((entity: T) => {\n    const meta = getMetadata(entity);\n    return new CustomReference<T, U, N>(entity, {\n      load: (entity, opts) => loadLensPath(entity, paths, opts),\n      get: () => getLensPath(meta, entity, paths),\n      isLoaded: () => isLensLoadedPath(entity, paths),\n      loadHint,\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAqBA,SAAgB,cACd,MACoB;CACpB,MAAM,QAAQ,WAAW,IAAI;CAC7B,MAAM,WAAW,mBAAsB,KAAK;CAC5C,OAAO,WAAW,WAAc;EAC9B,MAAM,OAAO,YAAY,MAAM;EAC/B,OAAO,IAAI,gBAAyB,QAAQ;GAC1C,OAAO,QAAQ,SAAS,aAAa,QAAQ,OAAO,IAAI;GACxD,WAAW,YAAY,MAAM,QAAQ,KAAK;GAC1C,gBAAgB,iBAAiB,QAAQ,KAAK;GAC9C;EACF,CAAC;CACH,CAAC;AACH"}
+{"version":3,"file":"hasOneThrough.js","names":[],"sources":["../../src/relations/hasOneThrough.ts"],"sourcesContent":["import {\n  CustomReference,\n  type Entity,\n  type Lens,\n  type Reference,\n  getLensPath,\n  getMetadata,\n  isLensLoadedPath,\n  lensPathToLoadHint,\n  lensToPath,\n  loadLensPath,\n} from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\n\n/**\n * Creates a CustomReference that will walk across references in the object graph.\n *\n * I.e. A BookReview \"has one author\" through the `review -> book -> author` relation.\n *\n * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, \"author\")`.\n */\nexport function hasOneThrough<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N>(\n  lens: (lens: Lens<T>) => Lens<V>,\n): Reference<T, U, N> {\n  const paths = lensToPath(lens);\n  const loadHint = lensPathToLoadHint<T>(paths);\n  return lazyField((entity: T) => {\n    const meta = getMetadata(entity);\n    return new CustomReference<T, U, N>(entity, {\n      load: (entity, opts) => loadLensPath(entity, paths, opts),\n      get: () => getLensPath(meta, entity, paths),\n      isLoaded: () => isLensLoadedPath(entity, paths),\n      loadHint,\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAqBA,SAAgB,cACd,MACoB;CACpB,MAAM,QAAQ,WAAW,IAAI;CAC7B,MAAM,WAAW,mBAAsB,KAAK;CAC5C,OAAO,WAAW,WAAc;EAC9B,MAAM,OAAO,YAAY,MAAM;EAC/B,OAAO,IAAI,gBAAyB,QAAQ;GAC1C,OAAO,QAAQ,SAAS,aAAa,QAAQ,OAAO,IAAI;GACxD,WAAW,YAAY,MAAM,QAAQ,KAAK;GAC1C,gBAAgB,iBAAiB,QAAQ,KAAK;GAC9C;EACF,CAAC;CACH,CAAC;AACH"}

package/build/relations/hasProperty.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_relations_PropertySymbols = require("./PropertySymbols.cjs");
 const require_relations_RecursiveCycleError = require("./RecursiveCycleError.cjs");
-const require_reactiveHints = require("../reactiveHints.cjs");
-const require_loadHints = require("../loadHints.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_EntityMetadata = require("../EntityMetadata.cjs");
@@ -64,7 +64,7 @@ var PropertyImpl = class {
 		return require_utils.tryResolve(() => this.get);
 	}
 	get loadHint() {
-		if (!this.#hint) this.#hint = require_reactiveHints.convertToLoadHint(require_EntityMetadata.getMetadata(this.#entity), this.#reactiveHint);
+		if (!this.#hint) this.#hint = require_reactivity_reactiveHints.convertToLoadHint(require_EntityMetadata.getMetadata(this.#entity), this.#reactiveHint);
 		return this.#hint;
 	}
 	get reactiveHint() {
@@ -83,7 +83,7 @@ var PropertyImpl = class {
 				}, [this.#entity]);
 			}
 			this.#isCheckingLoaded = true;
-			this.#loaded = require_loadHints.isLoaded(this.#entity, this.loadHint);
+			this.#loaded = require_loading_loadHints.isLoaded(this.#entity, this.loadHint);
 			this.#isCheckingLoaded = false;
 		}
 		return !!this.#loaded;

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 \"../Entity.ts\";\nimport { getMetadata } from \"../EntityMetadata.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"../loadHints.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport {\n  type MaybeReactedPropertyEntity,\n  type Reacted,\n  type ReactiveHint,\n  convertToLoadHint,\n} from \"../reactiveHints.ts\";\nimport { tryResolve } from \"../utils.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\nimport { RecursiveCycleError } from \"./RecursiveCycleError.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,sBAAAA,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,kBAAAA,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","#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"}

package/build/relations/hasProperty.d.cts

@@ -1,6 +1,6 @@
 import { PropertyT } from "./PropertySymbols.cjs";
-import { LoadHint, Loaded } from "../loadHints.cjs";
-import { MaybeReactedPropertyEntity, Reacted, ReactiveHint } from "../reactiveHints.cjs";
+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> {

package/build/relations/hasProperty.d.mts

@@ -1,6 +1,6 @@
 import { PropertyT } from "./PropertySymbols.mjs";
-import { LoadHint, Loaded } from "../loadHints.mjs";
-import { MaybeReactedPropertyEntity, Reacted, ReactiveHint } from "../reactiveHints.mjs";
+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> {

package/build/relations/hasProperty.js

@@ -1,7 +1,7 @@
 import { PropertyT } from "./PropertySymbols.js";
 import { RecursiveCycleError } from "./RecursiveCycleError.js";
-import { convertToLoadHint } from "../reactiveHints.js";
-import { isLoaded } from "../loadHints.js";
+import { convertToLoadHint } from "../reactivity/reactiveHints.js";
+import { isLoaded } from "../loading/loadHints.js";
 import { tryResolve } from "../utils.js";
 import { lazyField } from "../newEntity.js";
 import { getMetadata } from "../EntityMetadata.js";

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 \"../Entity.ts\";\nimport { getMetadata } from \"../EntityMetadata.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"../loadHints.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport {\n  type MaybeReactedPropertyEntity,\n  type Reacted,\n  type ReactiveHint,\n  convertToLoadHint,\n} from \"../reactiveHints.ts\";\nimport { tryResolve } from \"../utils.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\nimport { RecursiveCycleError } from \"./RecursiveCycleError.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":["#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"}

package/build/relations/index.cjs

@@ -1,29 +1,29 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_relations_Collection = require("./Collection.cjs");
+const require_relations_CustomCollection = require("./CustomCollection.cjs");
 const require_relations_EnumCollection = require("./EnumCollection.cjs");
-const require_relations_RecursiveCycleError = require("./RecursiveCycleError.cjs");
-const require_relations_hasProperty = require("./hasProperty.cjs");
-const require_relations_LazyField = require("./LazyField.cjs");
-const require_relations_OneToManyCollection = require("./OneToManyCollection.cjs");
-const require_relations_ManyToOneReference = require("./ManyToOneReference.cjs");
-const require_relations_Reference = require("./Reference.cjs");
-const require_relations_ReactiveReference = require("./ReactiveReference.cjs");
-const require_relations_OneToOneReference = require("./OneToOneReference.cjs");
+const require_relations_CustomReference = require("./CustomReference.cjs");
 const require_relations_ReactiveGetter = require("./ReactiveGetter.cjs");
 const require_relations_Relation = require("./Relation.cjs");
 const require_relations_ReadOnlyCollection = require("./ReadOnlyCollection.cjs");
+const require_relations_RecursiveCycleError = require("./RecursiveCycleError.cjs");
 const require_relations_RecursiveCollection = require("./RecursiveCollection.cjs");
-const require_relations_CustomCollection = require("./CustomCollection.cjs");
-const require_relations_CustomReference = require("./CustomReference.cjs");
 const require_relations_hasAsyncMethod = require("./hasAsyncMethod.cjs");
+const require_relations_hasProperty = require("./hasProperty.cjs");
 const require_relations_AsyncProperty = require("./AsyncProperty.cjs");
+const require_relations_LazyField = require("./LazyField.cjs");
 const require_relations_hasManyDerived = require("./hasManyDerived.cjs");
 const require_relations_hasManyThrough = require("./hasManyThrough.cjs");
+const require_relations_Reference = require("./Reference.cjs");
 const require_relations_hasOneDerived = require("./hasOneDerived.cjs");
 const require_relations_hasOneThrough = require("./hasOneThrough.cjs");
 const require_relations_ManyToManyCollection = require("./ManyToManyCollection.cjs");
 const require_relations_ManyToManyLargeCollection = require("./ManyToManyLargeCollection.cjs");
+const require_relations_OneToManyCollection = require("./OneToManyCollection.cjs");
+const require_relations_ManyToOneReference = require("./ManyToOneReference.cjs");
 const require_relations_OneToManyLargeCollection = require("./OneToManyLargeCollection.cjs");
+const require_relations_ReactiveReference = require("./ReactiveReference.cjs");
+const require_relations_OneToOneReference = require("./OneToOneReference.cjs");
 const require_relations_PolymorphicReference = require("./PolymorphicReference.cjs");
 const require_relations_ReactiveField = require("./ReactiveField.cjs");
 const require_relations_ReactiveManyToMany = require("./ReactiveManyToMany.cjs");