joist-core 2.3.0 → 2.4.0

package/build/relations/hasOneDerived.d.mts

@@ -0,0 +1,15 @@
+import { Reference } from "./Reference.mjs";
+import { LoadHint, Loaded } from "../loading/loadHints.mjs";
+import { Entity } from "../Entity.mjs";
+//#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.mts.map

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

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

package/build/relations/hasOneDerived.js

@@ -1,24 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasOneDerived = hasOneDerived;
-const __1 = require("../");
-const newEntity_1 = require("../newEntity");
-const CustomReference_1 = require("./CustomReference");
+import { CustomReference } from "./CustomReference.js";
+import { isLoaded } from "../loading/loadHints.js";
+import "./Reference.js";
+import { lazyField } from "../newEntity.js";
+import "../index.js";
+import "../Entity.js";
+//#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")`.
- */
+* 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 (0, newEntity_1.lazyField)((entity) => {
-        return new CustomReference_1.CustomReference(entity, {
-            load: (entity, opts) => entity.em.populate(entity, { hint: loadHint, ...opts }),
-            get: () => get(entity),
-            isLoaded: () => (0, __1.isLoaded)(entity, loadHint),
-            loadHint,
-        });
-    });
+	return lazyField((entity) => {
+		return new CustomReference(entity, {
+			load: (entity, opts) => entity.em.populate(entity, {
+				hint: loadHint,
+				...opts
+			}),
+			get: () => get(entity),
+			isLoaded: () => isLoaded(entity, loadHint),
+			loadHint
+		});
+	});
 }
+//#endregion
+export { hasOneDerived };
+
 //# sourceMappingURL=hasOneDerived.js.map

package/build/relations/hasOneDerived.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasOneDerived.js","sourceRoot":"","sources":["../../src/relations/hasOneDerived.ts"],"names":[],"mappings":";;AAcA,sCAeC;AA7BD,2BAA+B;AAG/B,4CAAyC;AACzC,uDAAoD;AAGpD;;;;;;GAMG;AACH,SAAgB,aAAa,CAM3B,QAAW,EAAE,GAAgC;IAC7C,OAAO,IAAA,qBAAS,EAAC,CAAC,MAAS,EAAE,EAAE;QAC7B,OAAO,IAAI,iCAAe,CAAU,MAAM,EAAE;YAC1C,IAAI,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,CAAC;YAC/E,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,MAAsB,CAAC;YACtC,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAA,YAAQ,EAAC,MAAM,EAAE,QAAuB,CAAC;YACzD,QAAQ;SACT,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"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

@@ -0,0 +1,31 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_CustomReference = require("./CustomReference.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/hasOneThrough.ts
+/**
+* Creates a CustomReference that will 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 hasOneThrough(lens) {
+	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_loading_loadLens.loadLensPath(entity, paths, opts),
+			get: () => require_loading_loadLens.getLensPath(meta, entity, paths),
+			isLoaded: () => require_loading_loadLens.isLensLoadedPath(entity, paths),
+			loadHint
+		});
+	});
+}
+//#endregion
+exports.hasOneThrough = hasOneThrough;
+
+//# sourceMappingURL=hasOneThrough.cjs.map

package/build/relations/hasOneThrough.cjs.map

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

@@ -0,0 +1,16 @@
+import { Reference } from "./Reference.cjs";
+import { Lens } from "../loading/loadLens.cjs";
+import "../index.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/relations/hasOneThrough.d.ts
+/**
+ * Creates a CustomReference that will 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 hasOneThrough<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N>(lens: (lens: Lens<T>) => Lens<V>): Reference<T, U, N>;
+//#endregion
+export { hasOneThrough };
+//# sourceMappingURL=hasOneThrough.d.cts.map

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

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

package/build/relations/hasOneThrough.d.mts

@@ -0,0 +1,16 @@
+import { Reference } from "./Reference.mjs";
+import { Lens } from "../loading/loadLens.mjs";
+import "../index.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/relations/hasOneThrough.d.ts
+/**
+ * Creates a CustomReference that will 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 hasOneThrough<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N>(lens: (lens: Lens<T>) => Lens<V>): Reference<T, U, N>;
+//#endregion
+export { hasOneThrough };
+//# sourceMappingURL=hasOneThrough.d.mts.map

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

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

package/build/relations/hasOneThrough.js

@@ -1,26 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasOneThrough = hasOneThrough;
-const index_1 = require("../index");
-const newEntity_1 = require("../newEntity");
+import { CustomReference } from "./CustomReference.js";
+import { lazyField } from "../newEntity.js";
+import { getMetadata } from "../EntityMetadata.js";
+import { getLensPath, isLensLoadedPath, lensPathToLoadHint, lensToPath, loadLensPath } from "../loading/loadLens.js";
+import "../index.js";
+//#region src/relations/hasOneThrough.ts
 /**
- * Creates a CustomReference that will 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")`.
- */
+* Creates a CustomReference that will 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 hasOneThrough(lens) {
-    const paths = (0, index_1.lensToPath)(lens);
-    const loadHint = (0, index_1.lensPathToLoadHint)(paths);
-    return (0, newEntity_1.lazyField)((entity) => {
-        const meta = (0, index_1.getMetadata)(entity);
-        return new index_1.CustomReference(entity, {
-            load: (entity, opts) => (0, index_1.loadLensPath)(entity, paths, opts),
-            get: () => (0, index_1.getLensPath)(meta, entity, paths),
-            isLoaded: () => (0, index_1.isLensLoadedPath)(entity, paths),
-            loadHint,
-        });
-    });
+	const paths = lensToPath(lens);
+	const loadHint = lensPathToLoadHint(paths);
+	return lazyField((entity) => {
+		const meta = getMetadata(entity);
+		return new CustomReference(entity, {
+			load: (entity, opts) => loadLensPath(entity, paths, opts),
+			get: () => getLensPath(meta, entity, paths),
+			isLoaded: () => isLensLoadedPath(entity, paths),
+			loadHint
+		});
+	});
 }
+//#endregion
+export { hasOneThrough };
+
 //# sourceMappingURL=hasOneThrough.js.map

package/build/relations/hasOneThrough.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasOneThrough.js","sourceRoot":"","sources":["../../src/relations/hasOneThrough.ts"],"names":[],"mappings":";;AAqBA,sCAcC;AAnCD,oCAWkB;AAClB,4CAAyC;AAEzC;;;;;;GAMG;AACH,SAAgB,aAAa,CAC3B,IAAgC;IAEhC,MAAM,KAAK,GAAG,IAAA,kBAAU,EAAC,IAAI,CAAC,CAAC;IAC/B,MAAM,QAAQ,GAAG,IAAA,0BAAkB,EAAI,KAAK,CAAC,CAAC;IAC9C,OAAO,IAAA,qBAAS,EAAC,CAAC,MAAS,EAAE,EAAE;QAC7B,MAAM,IAAI,GAAG,IAAA,mBAAW,EAAC,MAAM,CAAC,CAAC;QACjC,OAAO,IAAI,uBAAe,CAAU,MAAM,EAAE;YAC1C,IAAI,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,IAAA,oBAAY,EAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC;YACzD,GAAG,EAAE,GAAG,EAAE,CAAC,IAAA,mBAAW,EAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC;YAC3C,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAA,wBAAgB,EAAC,MAAM,EAAE,KAAK,CAAC;YAC/C,QAAQ;SACT,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"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

@@ -0,0 +1,109 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_PropertySymbols = require("./PropertySymbols.cjs");
+const require_relations_RecursiveCycleError = require("./RecursiveCycleError.cjs");
+const require_reactivity_reactiveHints = require("../reactivity/reactiveHints.cjs");
+const require_loading_loadHints = require("../loading/loadHints.cjs");
+const require_utils = require("../utils.cjs");
+const require_newEntity = require("../newEntity.cjs");
+const require_EntityMetadata = require("../EntityMetadata.cjs");
+require("../Entity.cjs");
+//#region src/relations/hasProperty.ts
+/**
+* Creates a calculated derived value from a load hint + lambda.
+*
+* The property can be accessed by default as a promise, with `someProperty.load()`.
+*
+* But if `someProperty` is used as a populate hint, then it can be accessed synchronously,
+* with `someProperty.get`.
+*/
+function hasProperty(loadHint, fn) {
+	return require_newEntity.lazyField((entity, fieldName) => {
+		return new PropertyImpl(entity, fieldName, loadHint, fn);
+	});
+}
+/**
+* Creates a calculated derived value from a load hint + lambda.
+*
+* The property can be accessed by default as a promise, with `someProperty.load()`.
+*
+* But if `someProperty` is used as a populate hint, then it can be accessed synchronously,
+* with `someProperty.get`.
+*/
+function hasReactiveProperty(reactiveHint, fn) {
+	return require_newEntity.lazyField((entity, fieldName) => {
+		return new PropertyImpl(entity, fieldName, reactiveHint, fn, { isReactive: true });
+	});
+}
+var PropertyImpl = class {
+	fieldName;
+	fn;
+	opts;
+	#loaded = void 0;
+	#isCheckingLoaded = false;
+	#loadPromise;
+	#entity;
+	#hint;
+	#reactiveHint;
+	constructor(entity, fieldName, hint, fn, opts = {}) {
+		this.fieldName = fieldName;
+		this.fn = fn;
+		this.opts = opts;
+		const { isReactive = false } = opts;
+		this.#entity = entity;
+		this.#hint = isReactive ? void 0 : hint;
+		this.#reactiveHint = isReactive ? hint : void 0;
+	}
+	load() {
+		if (!this.isLoaded) {
+			const { loadHint, fn } = this;
+			return this.#loadPromise ??= this.#entity.em.populate(this.#entity, loadHint).then((loaded) => {
+				this.#loaded = true;
+				return fn(loaded);
+			});
+		}
+		return require_utils.tryResolve(() => this.get);
+	}
+	get loadHint() {
+		if (!this.#hint) this.#hint = require_reactivity_reactiveHints.convertToLoadHint(require_EntityMetadata.getMetadata(this.#entity), this.#reactiveHint);
+		return this.#hint;
+	}
+	get reactiveHint() {
+		return this.#reactiveHint;
+	}
+	get get() {
+		return this.fn(this.#entity);
+	}
+	get isLoaded() {
+		if (this.#loaded === void 0) {
+			if (this.#isCheckingLoaded) {
+				this.#isCheckingLoaded = false;
+				throw new require_relations_RecursiveCycleError.RecursiveCycleError({
+					entity: this.#entity,
+					fieldName: this.fieldName
+				}, [this.#entity]);
+			}
+			this.#isCheckingLoaded = true;
+			this.#loaded = require_loading_loadHints.isLoaded(this.#entity, this.loadHint);
+			this.#isCheckingLoaded = false;
+		}
+		return !!this.#loaded;
+	}
+	[require_relations_PropertySymbols.PropertyT] = void 0;
+};
+/** Type guard utility for determining if an entity field is a Property. */
+function isProperty(maybeProperty) {
+	return maybeProperty instanceof PropertyImpl;
+}
+/** Type guard utility for determining if an entity field is a loaded Property. */
+function isLoadedProperty(maybeProperty) {
+	return isProperty(maybeProperty) && maybeProperty.isLoaded;
+}
+//#endregion
+exports.PropertyImpl = PropertyImpl;
+exports.PropertyT = require_relations_PropertySymbols.PropertyT;
+exports.hasProperty = hasProperty;
+exports.hasReactiveProperty = hasReactiveProperty;
+exports.isLoadedProperty = isLoadedProperty;
+exports.isProperty = isProperty;
+
+//# sourceMappingURL=hasProperty.cjs.map

package/build/relations/hasProperty.cjs.map

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

package/build/relations/hasProperty.d.cts

@@ -0,0 +1,53 @@
+import { PropertyT } from "./PropertySymbols.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> {
+  [PropertyT]: T;
+  isLoaded: boolean;
+  load(): Promise<V>;
+}
+interface LoadedProperty<T extends Entity, V> {
+  get: V;
+}
+/**
+ * Creates a calculated derived value from a load hint + lambda.
+ *
+ * The property can be accessed by default as a promise, with `someProperty.load()`.
+ *
+ * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,
+ * with `someProperty.get`.
+ */
+declare function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(loadHint: H, fn: (entity: Loaded<T, H>) => V): Property<T, V>;
+/**
+ * Creates a calculated derived value from a load hint + lambda.
+ *
+ * The property can be accessed by default as a promise, with `someProperty.load()`.
+ *
+ * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,
+ * with `someProperty.get`.
+ */
+declare function hasReactiveProperty<T extends Entity, const H extends ReactiveHint<T>, V>(reactiveHint: H, fn: (entity: Reacted<T, H>) => MaybeReactedPropertyEntity<V>): Property<T, V>;
+declare class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements Property<T, V> {
+  #private;
+  private fieldName;
+  private fn;
+  private opts;
+  constructor(entity: T, fieldName: string, hint: H | ReactiveHint<T>, fn: (entity: Loaded<T, H>) => V, opts?: {
+    isReactive?: boolean;
+  });
+  load(): Promise<V>;
+  get loadHint(): H;
+  get reactiveHint(): ReactiveHint<T> | undefined;
+  get get(): V;
+  get isLoaded(): boolean;
+  [PropertyT]: T;
+}
+/** Type guard utility for determining if an entity field is a Property. */
+declare function isProperty(maybeProperty: any): maybeProperty is Property<any, any>;
+/** Type guard utility for determining if an entity field is a loaded Property. */
+declare function isLoadedProperty(maybeProperty: any): maybeProperty is Property<any, any> & LoadedProperty<any, any>;
+//#endregion
+export { LoadedProperty, Property, PropertyImpl, PropertyT, hasProperty, hasReactiveProperty, isLoadedProperty, isProperty };
+//# sourceMappingURL=hasProperty.d.cts.map

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

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

package/build/relations/hasProperty.d.mts

@@ -0,0 +1,53 @@
+import { PropertyT } from "./PropertySymbols.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> {
+  [PropertyT]: T;
+  isLoaded: boolean;
+  load(): Promise<V>;
+}
+interface LoadedProperty<T extends Entity, V> {
+  get: V;
+}
+/**
+ * Creates a calculated derived value from a load hint + lambda.
+ *
+ * The property can be accessed by default as a promise, with `someProperty.load()`.
+ *
+ * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,
+ * with `someProperty.get`.
+ */
+declare function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(loadHint: H, fn: (entity: Loaded<T, H>) => V): Property<T, V>;
+/**
+ * Creates a calculated derived value from a load hint + lambda.
+ *
+ * The property can be accessed by default as a promise, with `someProperty.load()`.
+ *
+ * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,
+ * with `someProperty.get`.
+ */
+declare function hasReactiveProperty<T extends Entity, const H extends ReactiveHint<T>, V>(reactiveHint: H, fn: (entity: Reacted<T, H>) => MaybeReactedPropertyEntity<V>): Property<T, V>;
+declare class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements Property<T, V> {
+  #private;
+  private fieldName;
+  private fn;
+  private opts;
+  constructor(entity: T, fieldName: string, hint: H | ReactiveHint<T>, fn: (entity: Loaded<T, H>) => V, opts?: {
+    isReactive?: boolean;
+  });
+  load(): Promise<V>;
+  get loadHint(): H;
+  get reactiveHint(): ReactiveHint<T> | undefined;
+  get get(): V;
+  get isLoaded(): boolean;
+  [PropertyT]: T;
+}
+/** Type guard utility for determining if an entity field is a Property. */
+declare function isProperty(maybeProperty: any): maybeProperty is Property<any, any>;
+/** Type guard utility for determining if an entity field is a loaded Property. */
+declare function isLoadedProperty(maybeProperty: any): maybeProperty is Property<any, any> & LoadedProperty<any, any>;
+//#endregion
+export { LoadedProperty, Property, PropertyImpl, PropertyT, hasProperty, hasReactiveProperty, isLoadedProperty, isProperty };
+//# sourceMappingURL=hasProperty.d.mts.map

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

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