joist-core 2.3.0 → 2.4.0-next.10

package/build/relations/hasAsyncMethod.cjs

@@ -0,0 +1,47 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_loading_loadHints = require("../loading/loadHints.cjs");
+const require_newEntity = require("../newEntity.cjs");
+require("../Entity.cjs");
+//#region src/relations/hasAsyncMethod.ts
+const AsyncMethodM = Symbol();
+const AsyncMethodPopulateSecret = Symbol();
+function hasAsyncMethod(loadHint, fn) {
+	return require_newEntity.lazyField((entity) => {
+		return new AsyncMethodImpl(entity, loadHint, fn);
+	});
+}
+var AsyncMethodImpl = class {
+	fn;
+	loaded = false;
+	loadPromise;
+	#entity;
+	#hint;
+	constructor(entity, hint, fn) {
+		this.fn = fn;
+		this.#entity = entity;
+		this.#hint = hint;
+	}
+	/** Args might be either the user-provided args, or the populate `opts` if we're being preloaded. */
+	async load(...args) {
+		const isPopulate = args && typeof args[0] === "object" && AsyncMethodPopulateSecret in args[0];
+		if (!this.loaded) {
+			this.loadPromise ??= this.#entity.em.populate(this.#entity, this.#hint).then((loaded) => this.loaded = true);
+			await this.loadPromise;
+		}
+		return isPopulate ? void 0 : this.call(...args);
+	}
+	call(...args) {
+		if (!this.isLoaded) throw new Error("hasAsyncMethod.call was called but not loaded");
+		return this.fn(this.#entity, ...args);
+	}
+	get isLoaded() {
+		return this.loaded || require_loading_loadHints.isLoaded(this.#entity, this.#hint);
+	}
+	[AsyncMethodM];
+};
+//#endregion
+exports.AsyncMethodImpl = AsyncMethodImpl;
+exports.AsyncMethodPopulateSecret = AsyncMethodPopulateSecret;
+exports.hasAsyncMethod = hasAsyncMethod;
+
+//# sourceMappingURL=hasAsyncMethod.cjs.map

package/build/relations/hasAsyncMethod.cjs.map

@@ -0,0 +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"}

package/build/relations/hasAsyncMethod.d.cts

@@ -0,0 +1,29 @@
+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> {
+  [AsyncMethodM]: undefined;
+  isLoaded: boolean;
+  load(...args: A): Promise<V>;
+}
+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> {
+  #private;
+  private fn;
+  private loaded;
+  private loadPromise;
+  constructor(entity: T, hint: H, fn: (entity: Loaded<T, H>, ...args: A) => V);
+  /** Args might be either the user-provided args, or the populate `opts` if we're being preloaded. */
+  load(...args: A): Promise<V>;
+  call(...args: A): V;
+  get isLoaded(): boolean;
+  [AsyncMethodM]: undefined;
+}
+//#endregion
+export { AsyncMethod, AsyncMethodImpl, AsyncMethodPopulateSecret, LoadedMethod, hasAsyncMethod };
+//# sourceMappingURL=hasAsyncMethod.d.cts.map

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

@@ -0,0 +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"}

package/build/relations/hasAsyncMethod.d.mts

@@ -0,0 +1,29 @@
+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> {
+  [AsyncMethodM]: undefined;
+  isLoaded: boolean;
+  load(...args: A): Promise<V>;
+}
+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> {
+  #private;
+  private fn;
+  private loaded;
+  private loadPromise;
+  constructor(entity: T, hint: H, fn: (entity: Loaded<T, H>, ...args: A) => V);
+  /** Args might be either the user-provided args, or the populate `opts` if we're being preloaded. */
+  load(...args: A): Promise<V>;
+  call(...args: A): V;
+  get isLoaded(): boolean;
+  [AsyncMethodM]: undefined;
+}
+//#endregion
+export { AsyncMethod, AsyncMethodImpl, AsyncMethodPopulateSecret, LoadedMethod, hasAsyncMethod };
+//# sourceMappingURL=hasAsyncMethod.d.mts.map

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

@@ -0,0 +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"}

package/build/relations/hasAsyncMethod.js

@@ -1,47 +1,44 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncMethodImpl = exports.AsyncMethodPopulateSecret = void 0;
-exports.hasAsyncMethod = hasAsyncMethod;
-const loadHints_1 = require("../loadHints");
-const newEntity_1 = require("../newEntity");
+import { isLoaded } from "../loading/loadHints.js";
+import { lazyField } from "../newEntity.js";
+import "../Entity.js";
+//#region src/relations/hasAsyncMethod.ts
 const AsyncMethodM = Symbol();
-exports.AsyncMethodPopulateSecret = Symbol();
+const AsyncMethodPopulateSecret = Symbol();
 function hasAsyncMethod(loadHint, fn) {
-    return (0, newEntity_1.lazyField)((entity) => {
-        return new AsyncMethodImpl(entity, loadHint, fn);
-    });
+	return lazyField((entity) => {
+		return new AsyncMethodImpl(entity, loadHint, fn);
+	});
 }
-class AsyncMethodImpl {
-    fn;
-    loaded = false;
-    loadPromise;
-    #entity;
-    #hint;
-    constructor(entity, hint, fn) {
-        this.fn = fn;
-        this.#entity = entity;
-        this.#hint = hint;
-    }
-    /** Args might be either the user-provided args, or the populate `opts` if we're being preloaded. */
-    async load(...args) {
-        // Are we being called by `em.populate`? If so, we don't have the real args, so avoid invoking fn
-        const isPopulate = args && typeof args[0] === "object" && exports.AsyncMethodPopulateSecret in args[0];
-        if (!this.loaded) {
-            this.loadPromise ??= this.#entity.em.populate(this.#entity, this.#hint).then((loaded) => (this.loaded = true));
-            await this.loadPromise;
-        }
-        return isPopulate ? undefined : this.call(...args);
-    }
-    call(...args) {
-        if (!this.isLoaded) {
-            throw new Error("hasAsyncMethod.call was called but not loaded");
-        }
-        return this.fn(this.#entity, ...args);
-    }
-    get isLoaded() {
-        return this.loaded || (0, loadHints_1.isLoaded)(this.#entity, this.#hint);
-    }
-    [AsyncMethodM];
-}
-exports.AsyncMethodImpl = AsyncMethodImpl;
+var AsyncMethodImpl = class {
+	fn;
+	loaded = false;
+	loadPromise;
+	#entity;
+	#hint;
+	constructor(entity, hint, fn) {
+		this.fn = fn;
+		this.#entity = entity;
+		this.#hint = hint;
+	}
+	/** Args might be either the user-provided args, or the populate `opts` if we're being preloaded. */
+	async load(...args) {
+		const isPopulate = args && typeof args[0] === "object" && AsyncMethodPopulateSecret in args[0];
+		if (!this.loaded) {
+			this.loadPromise ??= this.#entity.em.populate(this.#entity, this.#hint).then((loaded) => this.loaded = true);
+			await this.loadPromise;
+		}
+		return isPopulate ? void 0 : this.call(...args);
+	}
+	call(...args) {
+		if (!this.isLoaded) throw new Error("hasAsyncMethod.call was called but not loaded");
+		return this.fn(this.#entity, ...args);
+	}
+	get isLoaded() {
+		return this.loaded || isLoaded(this.#entity, this.#hint);
+	}
+	[AsyncMethodM];
+};
+//#endregion
+export { AsyncMethodImpl, AsyncMethodPopulateSecret, hasAsyncMethod };
+
 //# sourceMappingURL=hasAsyncMethod.js.map

package/build/relations/hasAsyncMethod.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasAsyncMethod.js","sourceRoot":"","sources":["../../src/relations/hasAsyncMethod.ts"],"names":[],"mappings":";;;AAkBA,wCAOC;AAxBD,4CAA0D;AAC1D,4CAAyC;AAEzC,MAAM,YAAY,GAAG,MAAM,EAAE,CAAC;AACjB,QAAA,yBAAyB,GAAG,MAAM,EAAE,CAAC;AAalD,SAAgB,cAAc,CAC5B,QAAW,EACX,EAA2C;IAE3C,OAAO,IAAA,qBAAS,EAAC,CAAC,MAAS,EAAE,EAAE;QAC7B,OAAO,IAAI,eAAe,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;IACnD,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAa,eAAe;IAahB;IARF,MAAM,GAAG,KAAK,CAAC;IACf,WAAW,CAA2B;IAErC,OAAO,CAAI;IACX,KAAK,CAAI;IAClB,YACE,MAAS,EACT,IAAO,EACC,EAA2C;QAA3C,OAAE,GAAF,EAAE,CAAyC;QAEnD,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACpB,CAAC;IAED,oGAAoG;IACpG,KAAK,CAAC,IAAI,CAAC,GAAG,IAAO;QACnB,iGAAiG;QACjG,MAAM,UAAU,GAAG,IAAI,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ,IAAI,iCAAyB,IAAK,IAAY,CAAC,CAAC,CAAC,CAAC;QACxG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAM,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;YAChH,MAAM,IAAI,CAAC,WAAW,CAAC;QACzB,CAAC;QACD,OAAO,UAAU,CAAC,CAAC,CAAE,SAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;IAC9D,CAAC;IAED,IAAI,CAAC,GAAG,IAAO;QACb,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QACnE,CAAC;QACD,OAAO,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAuB,EAAE,GAAG,IAAI,CAAC,CAAC;IACxD,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,MAAM,IAAI,IAAA,oBAAQ,EAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAC3D,CAAC;IAED,CAAC,YAAY,CAAC,CAAY;CAC3B;AA1CD,0CA0CC"}
+{"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

@@ -0,0 +1,35 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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
+/**
+* Creates a CustomCollection that can conditionally walk across references in the object graph.
+*
+* I.e. An Author "has many reviews" through the `author -> books -> reviews` relation.
+*
+* Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, "reviews")`.
+*/
+function hasManyDerived(loadHint, opts) {
+	const { load, ...rest } = opts;
+	return require_newEntity.lazyField((entity) => {
+		return new require_relations_CustomCollection.CustomCollection(entity, {
+			load(entity, opts) {
+				if (load) return load(entity, opts);
+				else return entity.em.populate(entity, {
+					hint: loadHint,
+					...opts
+				});
+			},
+			isLoaded: () => require_loading_loadHints.isLoaded(entity, loadHint),
+			loadHint,
+			...rest
+		});
+	});
+}
+//#endregion
+exports.hasManyDerived = hasManyDerived;
+
+//# sourceMappingURL=hasManyDerived.cjs.map

package/build/relations/hasManyDerived.cjs.map

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,25 @@
+import { Collection } from "./Collection.cjs";
+import { LoadHint, Loaded } from "../loading/loadHints.cjs";
+import "../index.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/relations/hasManyDerived.d.ts
+type HasManyDerivedOpts<T extends Entity, U extends Entity, H extends LoadHint<T>> = {
+  load?: (entity: T, opts: {
+    forceReload?: boolean;
+  }) => Promise<any>;
+  get: (entity: Loaded<T, H>) => readonly U[];
+  set?: (entity: Loaded<T, H>, values: U[]) => void;
+  add?: (entity: Loaded<T, H>, value: U) => void;
+  remove?: (entity: Loaded<T, H>, value: U) => void;
+};
+/**
+ * Creates a CustomCollection that can conditionally walk across references in the object graph.
+ *
+ * I.e. An Author "has many reviews" through the `author -> books -> reviews` relation.
+ *
+ * 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>;
+//#endregion
+export { hasManyDerived };
+//# sourceMappingURL=hasManyDerived.d.cts.map

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

@@ -0,0 +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"}

package/build/relations/hasManyDerived.d.mts

@@ -0,0 +1,25 @@
+import { Collection } from "./Collection.mjs";
+import { LoadHint, Loaded } from "../loading/loadHints.mjs";
+import "../index.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/relations/hasManyDerived.d.ts
+type HasManyDerivedOpts<T extends Entity, U extends Entity, H extends LoadHint<T>> = {
+  load?: (entity: T, opts: {
+    forceReload?: boolean;
+  }) => Promise<any>;
+  get: (entity: Loaded<T, H>) => readonly U[];
+  set?: (entity: Loaded<T, H>, values: U[]) => void;
+  add?: (entity: Loaded<T, H>, value: U) => void;
+  remove?: (entity: Loaded<T, H>, value: U) => void;
+};
+/**
+ * Creates a CustomCollection that can conditionally walk across references in the object graph.
+ *
+ * I.e. An Author "has many reviews" through the `author -> books -> reviews` relation.
+ *
+ * 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>;
+//#endregion
+export { hasManyDerived };
+//# sourceMappingURL=hasManyDerived.d.mts.map

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

@@ -0,0 +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"}

package/build/relations/hasManyDerived.js

@@ -1,32 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasManyDerived = hasManyDerived;
-const __1 = require("../");
-const newEntity_1 = require("../newEntity");
-const CustomCollection_1 = require("./CustomCollection");
+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
 /**
- * Creates a CustomCollection that can conditionally walk across references in the object graph.
- *
- * I.e. An Author "has many reviews" through the `author -> books -> reviews` relation.
- *
- * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, "reviews")`.
- */
+* Creates a CustomCollection that can conditionally walk across references in the object graph.
+*
+* I.e. An Author "has many reviews" through the `author -> books -> reviews` relation.
+*
+* Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, "reviews")`.
+*/
 function hasManyDerived(loadHint, opts) {
-    const { load, ...rest } = opts;
-    return (0, newEntity_1.lazyField)((entity) => {
-        return new CustomCollection_1.CustomCollection(entity, {
-            load(entity, opts) {
-                if (load) {
-                    return load(entity, opts);
-                }
-                else {
-                    return entity.em.populate(entity, { hint: loadHint, ...opts });
-                }
-            },
-            isLoaded: () => (0, __1.isLoaded)(entity, loadHint),
-            loadHint,
-            ...rest,
-        });
-    });
+	const { load, ...rest } = opts;
+	return lazyField((entity) => {
+		return new CustomCollection(entity, {
+			load(entity, opts) {
+				if (load) return load(entity, opts);
+				else return entity.em.populate(entity, {
+					hint: loadHint,
+					...opts
+				});
+			},
+			isLoaded: () => isLoaded(entity, loadHint),
+			loadHint,
+			...rest
+		});
+	});
 }
+//#endregion
+export { hasManyDerived };
+
 //# sourceMappingURL=hasManyDerived.js.map

package/build/relations/hasManyDerived.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasManyDerived.js","sourceRoot":"","sources":["../../src/relations/hasManyDerived.ts"],"names":[],"mappings":";;AAqBA,wCAmBC;AAxCD,2BAA2C;AAG3C,4CAAyC;AACzC,yDAAsD;AAUtD;;;;;;GAMG;AACH,SAAgB,cAAc,CAC5B,QAAW,EACX,IAAiC;IAEjC,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;IAC/B,OAAO,IAAA,qBAAS,EAAC,CAAC,MAAS,EAAE,EAAE;QAC7B,OAAO,IAAI,mCAAgB,CAAO,MAAM,EAAE;YACxC,IAAI,CAAC,MAAM,EAAE,IAAI;gBACf,IAAI,IAAI,EAAE,CAAC;oBACT,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;gBAC5B,CAAC;qBAAM,CAAC;oBACN,OAAO,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC;gBACjE,CAAC;YACH,CAAC;YACD,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAA,YAAQ,EAAC,MAAM,EAAE,QAAQ,CAAC;YAC1C,QAAQ;YACR,GAAI,IAAY;SACjB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"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

@@ -0,0 +1,29 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_CustomCollection = require("./CustomCollection.cjs");
+const require_newEntity = require("../newEntity.cjs");
+const require_EntityMetadata = require("../EntityMetadata.cjs");
+const require_loading_loadLens = require("../loading/loadLens.cjs");
+require("../index.cjs");
+//#region src/relations/hasManyThrough.ts
+/**
+* Creates a CustomCollection that will walk across references in the object graph.
+*
+* I.e. An Author "has many reviews" through the `author -> books -> reviews` relation.
+*
+* Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, "reviews")`.
+*/
+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_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)
+		});
+	});
+}
+//#endregion
+exports.hasManyThrough = hasManyThrough;
+
+//# sourceMappingURL=hasManyThrough.cjs.map

package/build/relations/hasManyThrough.cjs.map

@@ -0,0 +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 \"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

@@ -0,0 +1,16 @@
+import { Collection } from "./Collection.cjs";
+import { Lens } from "../loading/loadLens.cjs";
+import "../index.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/relations/hasManyThrough.d.ts
+/**
+ * Creates a CustomCollection that will walk across references in the object graph.
+ *
+ * I.e. An Author "has many reviews" through the `author -> books -> reviews` relation.
+ *
+ * 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>;
+//#endregion
+export { hasManyThrough };
+//# sourceMappingURL=hasManyThrough.d.cts.map

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

@@ -0,0 +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"}

package/build/relations/hasManyThrough.d.mts

@@ -0,0 +1,16 @@
+import { Collection } from "./Collection.mjs";
+import { Lens } from "../loading/loadLens.mjs";
+import "../index.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/relations/hasManyThrough.d.ts
+/**
+ * Creates a CustomCollection that will walk across references in the object graph.
+ *
+ * I.e. An Author "has many reviews" through the `author -> books -> reviews` relation.
+ *
+ * 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>;
+//#endregion
+export { hasManyThrough };
+//# sourceMappingURL=hasManyThrough.d.mts.map

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

@@ -0,0 +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"}

package/build/relations/hasManyThrough.js

@@ -1,24 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasManyThrough = hasManyThrough;
-const index_1 = require("../index");
-const newEntity_1 = require("../newEntity");
+import { CustomCollection } from "./CustomCollection.js";
+import { lazyField } from "../newEntity.js";
+import { getMetadata } from "../EntityMetadata.js";
+import { getLens, isLensLoaded, lensToLoadHint, loadLens } from "../loading/loadLens.js";
+import "../index.js";
+//#region src/relations/hasManyThrough.ts
 /**
- * Creates a CustomCollection that will walk across references in the object graph.
- *
- * I.e. An Author "has many reviews" through the `author -> books -> reviews` relation.
- *
- * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, "reviews")`.
- */
+* Creates a CustomCollection that will walk across references in the object graph.
+*
+* I.e. An Author "has many reviews" through the `author -> books -> reviews` relation.
+*
+* Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, "reviews")`.
+*/
 function hasManyThrough(lens) {
-    return (0, newEntity_1.lazyField)((entity) => {
-        const meta = (0, index_1.getMetadata)(entity);
-        return new index_1.CustomCollection(entity, {
-            load: (entity, opts) => (0, index_1.loadLens)(entity, lens, opts),
-            get: () => (0, index_1.getLens)(meta, entity, lens),
-            isLoaded: () => (0, index_1.isLensLoaded)(entity, lens),
-            loadHint: () => (0, index_1.lensToLoadHint)(lens),
-        });
-    });
+	return lazyField((entity) => {
+		const meta = getMetadata(entity);
+		return new CustomCollection(entity, {
+			load: (entity, opts) => loadLens(entity, lens, opts),
+			get: () => getLens(meta, entity, lens),
+			isLoaded: () => isLensLoaded(entity, lens),
+			loadHint: () => lensToLoadHint(lens)
+		});
+	});
 }
+//#endregion
+export { hasManyThrough };
+
 //# sourceMappingURL=hasManyThrough.js.map

package/build/relations/hasManyThrough.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasManyThrough.js","sourceRoot":"","sources":["../../src/relations/hasManyThrough.ts"],"names":[],"mappings":";;AAoBA,wCAYC;AAhCD,oCAUkB;AAClB,4CAAyC;AAEzC;;;;;;GAMG;AACH,SAAgB,cAAc,CAC5B,IAAqC;IAErC,OAAO,IAAA,qBAAS,EAAC,CAAC,MAAS,EAAE,EAAE;QAC7B,MAAM,IAAI,GAAG,IAAA,mBAAW,EAAC,MAAM,CAAC,CAAC;QACjC,OAAO,IAAI,wBAAgB,CAAO,MAAM,EAAE;YACxC,IAAI,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,IAAA,gBAAQ,EAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC;YACpD,GAAG,EAAE,GAAG,EAAE,CAAC,IAAA,eAAO,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC;YACtC,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAA,oBAAY,EAAC,MAAM,EAAE,IAAI,CAAC;YAC1C,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAA,sBAAc,EAAC,IAAI,CAAC;SACrC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"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

@@ -0,0 +1,32 @@
+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_newEntity = require("../newEntity.cjs");
+require("../index.cjs");
+require("../Entity.cjs");
+//#region src/relations/hasOneDerived.ts
+/**
+* Creates a CustomReference that can conditionally walk across references in the object graph.
+*
+* I.e. A BookReview "has one author" through the `review -> book -> author` relation.
+*
+* Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, "author")`.
+*/
+function hasOneDerived(loadHint, get) {
+	return require_newEntity.lazyField((entity) => {
+		return new require_relations_CustomReference.CustomReference(entity, {
+			load: (entity, opts) => entity.em.populate(entity, {
+				hint: loadHint,
+				...opts
+			}),
+			get: () => get(entity),
+			isLoaded: () => require_loading_loadHints.isLoaded(entity, loadHint),
+			loadHint
+		});
+	});
+}
+//#endregion
+exports.hasOneDerived = hasOneDerived;
+
+//# sourceMappingURL=hasOneDerived.cjs.map

package/build/relations/hasOneDerived.cjs.map

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,15 @@
+import { Reference } from "./Reference.cjs";
+import { LoadHint, Loaded } from "../loading/loadHints.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/relations/hasOneDerived.d.ts
+/**
+ * Creates a CustomReference that can conditionally walk across references in the object graph.
+ *
+ * I.e. A BookReview "has one author" through the `review -> book -> author` relation.
+ *
+ * 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>;
+//#endregion
+export { hasOneDerived };
+//# sourceMappingURL=hasOneDerived.d.cts.map

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

@@ -0,0 +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"}