joist-core 2.3.0 → 2.4.0-next.2

package/build/relations/hasProperty.js

@@ -1,108 +1,103 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PropertyImpl = exports.PropertyT = void 0;
-exports.hasProperty = hasProperty;
-exports.hasReactiveProperty = hasReactiveProperty;
-exports.isProperty = isProperty;
-exports.isLoadedProperty = isLoadedProperty;
-const EntityMetadata_1 = require("../EntityMetadata");
-const loadHints_1 = require("../loadHints");
-const newEntity_1 = require("../newEntity");
-const reactiveHints_1 = require("../reactiveHints");
-const utils_1 = require("../utils");
-const RecursiveCycleError_1 = require("./RecursiveCycleError");
-exports.PropertyT = Symbol();
+import { PropertyT } from "./PropertySymbols.js";
+import { RecursiveCycleError } from "./RecursiveCycleError.js";
+import { convertToLoadHint } from "../reactivity/reactiveHints.js";
+import { isLoaded } from "../loading/loadHints.js";
+import { tryResolve } from "../utils.js";
+import { lazyField } from "../newEntity.js";
+import { getMetadata } from "../EntityMetadata.js";
+import "../Entity.js";
+//#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`.
- */
+* 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 (0, newEntity_1.lazyField)((entity, fieldName) => {
-        return new PropertyImpl(entity, fieldName, loadHint, fn);
-    });
+	return 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`.
- */
+* 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 (0, newEntity_1.lazyField)((entity, fieldName) => {
-        return new PropertyImpl(entity, fieldName, reactiveHint, fn, { isReactive: true });
-    });
+	return lazyField((entity, fieldName) => {
+		return new PropertyImpl(entity, fieldName, reactiveHint, fn, { isReactive: true });
+	});
 }
-class PropertyImpl {
-    fieldName;
-    fn;
-    opts;
-    // We'll probe for loaded if undefined
-    #loaded = undefined;
-    #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 ? undefined : hint;
-        this.#reactiveHint = isReactive ? hint : undefined;
-    }
-    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 (0, utils_1.tryResolve)(() => this.get);
-    }
-    get loadHint() {
-        if (!this.#hint) {
-            // Would be nice to statically (but lazily?) cache this...
-            this.#hint = (0, reactiveHints_1.convertToLoadHint)((0, EntityMetadata_1.getMetadata)(this.#entity), this.#reactiveHint);
-        }
-        return this.#hint;
-    }
-    get reactiveHint() {
-        return this.#reactiveHint;
-    }
-    get get() {
-        return this.fn(this.#entity);
-    }
-    get isLoaded() {
-        // Probe the first time, which is useful for factories that are DeepNew
-        if (this.#loaded === undefined) {
-            if (this.#isCheckingLoaded) {
-                this.#isCheckingLoaded = false;
-                throw new RecursiveCycleError_1.RecursiveCycleError({ entity: this.#entity, fieldName: this.fieldName }, [this.#entity]);
-            }
-            this.#isCheckingLoaded = true;
-            this.#loaded = (0, loadHints_1.isLoaded)(this.#entity, this.loadHint);
-            this.#isCheckingLoaded = false;
-        }
-        return !!this.#loaded;
-    }
-    [exports.PropertyT] = undefined;
-}
-exports.PropertyImpl = PropertyImpl;
+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 tryResolve(() => this.get);
+	}
+	get loadHint() {
+		if (!this.#hint) this.#hint = convertToLoadHint(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 RecursiveCycleError({
+					entity: this.#entity,
+					fieldName: this.fieldName
+				}, [this.#entity]);
+			}
+			this.#isCheckingLoaded = true;
+			this.#loaded = isLoaded(this.#entity, this.loadHint);
+			this.#isCheckingLoaded = false;
+		}
+		return !!this.#loaded;
+	}
+	[PropertyT] = void 0;
+};
 /** Type guard utility for determining if an entity field is a Property. */
 function isProperty(maybeProperty) {
-    return maybeProperty instanceof PropertyImpl;
+	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;
+	return isProperty(maybeProperty) && maybeProperty.isLoaded;
 }
+//#endregion
+export { PropertyImpl, PropertyT, hasProperty, hasReactiveProperty, isLoadedProperty, isProperty };
+
 //# sourceMappingURL=hasProperty.js.map

package/build/relations/hasProperty.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasProperty.js","sourceRoot":"","sources":["../../src/relations/hasProperty.ts"],"names":[],"mappings":"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"}
+{"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

@@ -0,0 +1,99 @@
+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_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_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");
+const require_relations_ReactiveManyToManyOtherSide = require("./ReactiveManyToManyOtherSide.cjs");
+const require_relations_AsyncReactiveField = require("./AsyncReactiveField.cjs");
+exports.AsyncPropertyImpl = require_relations_AsyncProperty.AsyncPropertyImpl;
+exports.CustomCollection = require_relations_CustomCollection.CustomCollection;
+exports.CustomReference = require_relations_CustomReference.CustomReference;
+exports.EnumCollectionImpl = require_relations_EnumCollection.EnumCollectionImpl;
+exports.LazyFieldImpl = require_relations_LazyField.LazyFieldImpl;
+exports.ManyToManyCollection = require_relations_ManyToManyCollection.ManyToManyCollection;
+exports.ManyToManyLargeCollection = require_relations_ManyToManyLargeCollection.ManyToManyLargeCollection;
+exports.ManyToOneReferenceImpl = require_relations_ManyToOneReference.ManyToOneReferenceImpl;
+exports.OneToManyCollection = require_relations_OneToManyCollection.OneToManyCollection;
+exports.OneToManyLargeCollection = require_relations_OneToManyLargeCollection.OneToManyLargeCollection;
+exports.OneToOneReferenceImpl = require_relations_OneToOneReference.OneToOneReferenceImpl;
+exports.PolymorphicReferenceImpl = require_relations_PolymorphicReference.PolymorphicReferenceImpl;
+exports.PropertyImpl = require_relations_hasProperty.PropertyImpl;
+exports.ReactiveManyToManyImpl = require_relations_ReactiveManyToMany.ReactiveManyToManyImpl;
+exports.ReactiveManyToManyOtherSideImpl = require_relations_ReactiveManyToManyOtherSide.ReactiveManyToManyOtherSideImpl;
+exports.ReactiveReferenceImpl = require_relations_ReactiveReference.ReactiveReferenceImpl;
+exports.RecursiveCycleError = require_relations_RecursiveCycleError.RecursiveCycleError;
+exports.hasAsyncMethod = require_relations_hasAsyncMethod.hasAsyncMethod;
+exports.hasAsyncProperty = require_relations_AsyncProperty.hasAsyncProperty;
+exports.hasAsyncReactiveField = require_relations_AsyncReactiveField.hasAsyncReactiveField;
+exports.hasCustomCollection = require_relations_CustomCollection.hasCustomCollection;
+exports.hasCustomReference = require_relations_CustomReference.hasCustomReference;
+exports.hasEnumCollection = require_relations_EnumCollection.hasEnumCollection;
+exports.hasLargeMany = require_relations_OneToManyLargeCollection.hasLargeMany;
+exports.hasLargeManyToMany = require_relations_ManyToManyLargeCollection.hasLargeManyToMany;
+exports.hasLazyField = require_relations_LazyField.hasLazyField;
+exports.hasMany = require_relations_OneToManyCollection.hasMany;
+exports.hasManyDerived = require_relations_hasManyDerived.hasManyDerived;
+exports.hasManyThrough = require_relations_hasManyThrough.hasManyThrough;
+exports.hasManyToMany = require_relations_ManyToManyCollection.hasManyToMany;
+exports.hasOne = require_relations_ManyToOneReference.hasOne;
+exports.hasOneDerived = require_relations_hasOneDerived.hasOneDerived;
+exports.hasOnePolymorphic = require_relations_PolymorphicReference.hasOnePolymorphic;
+exports.hasOneThrough = require_relations_hasOneThrough.hasOneThrough;
+exports.hasOneToOne = require_relations_OneToOneReference.hasOneToOne;
+exports.hasProperty = require_relations_hasProperty.hasProperty;
+exports.hasReactiveField = require_relations_ReactiveField.hasReactiveField;
+exports.hasReactiveGetter = require_relations_ReactiveGetter.hasReactiveGetter;
+exports.hasReactiveManyToMany = require_relations_ReactiveManyToMany.hasReactiveManyToMany;
+exports.hasReactiveManyToManyOtherSide = require_relations_ReactiveManyToManyOtherSide.hasReactiveManyToManyOtherSide;
+exports.hasReactiveProperty = require_relations_hasProperty.hasReactiveProperty;
+exports.hasReactiveReference = require_relations_ReactiveReference.hasReactiveReference;
+exports.hasRecursiveChildren = require_relations_RecursiveCollection.hasRecursiveChildren;
+exports.hasRecursiveM2m = require_relations_RecursiveCollection.hasRecursiveM2m;
+exports.hasRecursiveParents = require_relations_RecursiveCollection.hasRecursiveParents;
+exports.isAsyncProperty = require_relations_AsyncProperty.isAsyncProperty;
+exports.isAsyncReactiveField = require_relations_AsyncReactiveField.isAsyncReactiveField;
+exports.isCollection = require_relations_Collection.isCollection;
+exports.isLazyField = require_relations_LazyField.isLazyField;
+exports.isLoadedAsyncProperty = require_relations_AsyncProperty.isLoadedAsyncProperty;
+exports.isLoadedCollection = require_relations_Collection.isLoadedCollection;
+exports.isLoadedLazyField = require_relations_LazyField.isLoadedLazyField;
+exports.isLoadedOneToOneReference = require_relations_OneToOneReference.isLoadedOneToOneReference;
+exports.isLoadedProperty = require_relations_hasProperty.isLoadedProperty;
+exports.isLoadedReadOnlyCollection = require_relations_ReadOnlyCollection.isLoadedReadOnlyCollection;
+exports.isLoadedReference = require_relations_Reference.isLoadedReference;
+exports.isManyToOneReference = require_relations_ManyToOneReference.isManyToOneReference;
+exports.isOneToOneReference = require_relations_OneToOneReference.isOneToOneReference;
+exports.isPolymorphicReference = require_relations_PolymorphicReference.isPolymorphicReference;
+exports.isProperty = require_relations_hasProperty.isProperty;
+exports.isReactiveField = require_relations_ReactiveField.isReactiveField;
+exports.isReactiveGetter = require_relations_ReactiveGetter.isReactiveGetter;
+exports.isReactiveManyToMany = require_relations_ReactiveManyToMany.isReactiveManyToMany;
+exports.isReactiveManyToManyOtherSide = require_relations_ReactiveManyToManyOtherSide.isReactiveManyToManyOtherSide;
+exports.isReactiveReference = require_relations_ReactiveReference.isReactiveReference;
+exports.isReadOnlyCollection = require_relations_ReadOnlyCollection.isReadOnlyCollection;
+exports.isReference = require_relations_Reference.isReference;
+exports.isRelation = require_relations_Relation.isRelation;

package/build/relations/index.d.cts

@@ -0,0 +1,32 @@
+import { Collection, LoadedCollection, isCollection, isLoadedCollection } from "./Collection.cjs";
+import { CustomCollection, hasCustomCollection } from "./CustomCollection.cjs";
+import { EnumCollection, EnumCollectionImpl, LoadedEnumCollection, hasEnumCollection } from "./EnumCollection.cjs";
+import { CustomReference, hasCustomReference } from "./CustomReference.cjs";
+import { AsyncMethod, LoadedMethod, hasAsyncMethod } from "./hasAsyncMethod.cjs";
+import { LoadedProperty, Property, PropertyImpl, hasProperty, hasReactiveProperty, isLoadedProperty, isProperty } from "./hasProperty.cjs";
+import { AsyncProperty, AsyncPropertyImpl, hasAsyncProperty, isAsyncProperty, isLoadedAsyncProperty } from "./AsyncProperty.cjs";
+import { LazyField, LazyFieldImpl, hasLazyField, isLazyField, isLoadedLazyField } from "./LazyField.cjs";
+import { hasManyDerived } from "./hasManyDerived.cjs";
+import { hasManyThrough } from "./hasManyThrough.cjs";
+import { LoadedReference, Reference, isLoadedReference, isReference } from "./Reference.cjs";
+import { hasOneDerived } from "./hasOneDerived.cjs";
+import { hasOneThrough } from "./hasOneThrough.cjs";
+import { Relation, isRelation } from "./Relation.cjs";
+import { LargeCollection } from "./LargeCollection.cjs";
+import { ManyToManyCollection, hasManyToMany } from "./ManyToManyCollection.cjs";
+import { ManyToManyLargeCollection, hasLargeManyToMany } from "./ManyToManyLargeCollection.cjs";
+import { ManyToOneReference, ManyToOneReferenceImpl, hasOne, isManyToOneReference } from "./ManyToOneReference.cjs";
+import { OneToManyCollection, hasMany } from "./OneToManyCollection.cjs";
+import { OneToManyLargeCollection, hasLargeMany } from "./OneToManyLargeCollection.cjs";
+import { OneToOneReference, OneToOneReferenceImpl, hasOneToOne, isLoadedOneToOneReference, isOneToOneReference } from "./OneToOneReference.cjs";
+import { PolymorphicReference, PolymorphicReferenceImpl, hasOnePolymorphic, isPolymorphicReference } from "./PolymorphicReference.cjs";
+import { ReactiveField, hasReactiveField, isReactiveField } from "./ReactiveField.cjs";
+import { ReactiveGetter, hasReactiveGetter, isReactiveGetter } from "./ReactiveGetter.cjs";
+import { ReactiveManyToMany, ReactiveManyToManyImpl, hasReactiveManyToMany, isReactiveManyToMany } from "./ReactiveManyToMany.cjs";
+import { ReactiveManyToManyOtherSide, ReactiveManyToManyOtherSideImpl, hasReactiveManyToManyOtherSide, isReactiveManyToManyOtherSide } from "./ReactiveManyToManyOtherSide.cjs";
+import { hasAsyncReactiveField, isAsyncReactiveField } from "./AsyncReactiveField.cjs";
+import { ReactiveReference, ReactiveReferenceImpl, hasReactiveReference, isReactiveReference } from "./ReactiveReference.cjs";
+import { LoadedReadOnlyCollection, ReadOnlyCollection, isLoadedReadOnlyCollection, isReadOnlyCollection } from "./ReadOnlyCollection.cjs";
+import { RecursiveCycleError } from "./RecursiveCycleError.cjs";
+import { hasRecursiveChildren, hasRecursiveM2m, hasRecursiveParents } from "./RecursiveCollection.cjs";
+export { type AsyncMethod, type AsyncProperty, AsyncPropertyImpl, type Collection, CustomCollection, CustomReference, type EnumCollection, EnumCollectionImpl, type LargeCollection, type LazyField, LazyFieldImpl, type LoadedCollection, type LoadedEnumCollection, type LoadedMethod, type LoadedProperty, type LoadedReadOnlyCollection, type LoadedReference, ManyToManyCollection, ManyToManyLargeCollection, type ManyToOneReference, ManyToOneReferenceImpl, OneToManyCollection, OneToManyLargeCollection, type OneToOneReference, OneToOneReferenceImpl, type PolymorphicReference, PolymorphicReferenceImpl, type Property, PropertyImpl, type ReactiveField, type ReactiveGetter, type ReactiveManyToMany, ReactiveManyToManyImpl, type ReactiveManyToManyOtherSide, ReactiveManyToManyOtherSideImpl, type ReactiveReference, ReactiveReferenceImpl, type ReadOnlyCollection, RecursiveCycleError, type Reference, type Relation, hasAsyncMethod, hasAsyncProperty, hasAsyncReactiveField, hasCustomCollection, hasCustomReference, hasEnumCollection, hasLargeMany, hasLargeManyToMany, hasLazyField, hasMany, hasManyDerived, hasManyThrough, hasManyToMany, hasOne, hasOneDerived, hasOnePolymorphic, hasOneThrough, hasOneToOne, hasProperty, hasReactiveField, hasReactiveGetter, hasReactiveManyToMany, hasReactiveManyToManyOtherSide, hasReactiveProperty, hasReactiveReference, hasRecursiveChildren, hasRecursiveM2m, hasRecursiveParents, isAsyncProperty, isAsyncReactiveField, isCollection, isLazyField, isLoadedAsyncProperty, isLoadedCollection, isLoadedLazyField, isLoadedOneToOneReference, isLoadedProperty, isLoadedReadOnlyCollection, isLoadedReference, isManyToOneReference, isOneToOneReference, isPolymorphicReference, isProperty, isReactiveField, isReactiveGetter, isReactiveManyToMany, isReactiveManyToManyOtherSide, isReactiveReference, isReadOnlyCollection, isReference, isRelation };

package/build/relations/index.d.mts

@@ -0,0 +1,32 @@
+import { Collection, LoadedCollection, isCollection, isLoadedCollection } from "./Collection.mjs";
+import { CustomCollection, hasCustomCollection } from "./CustomCollection.mjs";
+import { EnumCollection, EnumCollectionImpl, LoadedEnumCollection, hasEnumCollection } from "./EnumCollection.mjs";
+import { CustomReference, hasCustomReference } from "./CustomReference.mjs";
+import { AsyncMethod, LoadedMethod, hasAsyncMethod } from "./hasAsyncMethod.mjs";
+import { LoadedProperty, Property, PropertyImpl, hasProperty, hasReactiveProperty, isLoadedProperty, isProperty } from "./hasProperty.mjs";
+import { AsyncProperty, AsyncPropertyImpl, hasAsyncProperty, isAsyncProperty, isLoadedAsyncProperty } from "./AsyncProperty.mjs";
+import { LazyField, LazyFieldImpl, hasLazyField, isLazyField, isLoadedLazyField } from "./LazyField.mjs";
+import { hasManyDerived } from "./hasManyDerived.mjs";
+import { hasManyThrough } from "./hasManyThrough.mjs";
+import { LoadedReference, Reference, isLoadedReference, isReference } from "./Reference.mjs";
+import { hasOneDerived } from "./hasOneDerived.mjs";
+import { hasOneThrough } from "./hasOneThrough.mjs";
+import { Relation, isRelation } from "./Relation.mjs";
+import { LargeCollection } from "./LargeCollection.mjs";
+import { ManyToManyCollection, hasManyToMany } from "./ManyToManyCollection.mjs";
+import { ManyToManyLargeCollection, hasLargeManyToMany } from "./ManyToManyLargeCollection.mjs";
+import { ManyToOneReference, ManyToOneReferenceImpl, hasOne, isManyToOneReference } from "./ManyToOneReference.mjs";
+import { OneToManyCollection, hasMany } from "./OneToManyCollection.mjs";
+import { OneToManyLargeCollection, hasLargeMany } from "./OneToManyLargeCollection.mjs";
+import { OneToOneReference, OneToOneReferenceImpl, hasOneToOne, isLoadedOneToOneReference, isOneToOneReference } from "./OneToOneReference.mjs";
+import { PolymorphicReference, PolymorphicReferenceImpl, hasOnePolymorphic, isPolymorphicReference } from "./PolymorphicReference.mjs";
+import { ReactiveField, hasReactiveField, isReactiveField } from "./ReactiveField.mjs";
+import { ReactiveGetter, hasReactiveGetter, isReactiveGetter } from "./ReactiveGetter.mjs";
+import { ReactiveManyToMany, ReactiveManyToManyImpl, hasReactiveManyToMany, isReactiveManyToMany } from "./ReactiveManyToMany.mjs";
+import { ReactiveManyToManyOtherSide, ReactiveManyToManyOtherSideImpl, hasReactiveManyToManyOtherSide, isReactiveManyToManyOtherSide } from "./ReactiveManyToManyOtherSide.mjs";
+import { hasAsyncReactiveField, isAsyncReactiveField } from "./AsyncReactiveField.mjs";
+import { ReactiveReference, ReactiveReferenceImpl, hasReactiveReference, isReactiveReference } from "./ReactiveReference.mjs";
+import { LoadedReadOnlyCollection, ReadOnlyCollection, isLoadedReadOnlyCollection, isReadOnlyCollection } from "./ReadOnlyCollection.mjs";
+import { RecursiveCycleError } from "./RecursiveCycleError.mjs";
+import { hasRecursiveChildren, hasRecursiveM2m, hasRecursiveParents } from "./RecursiveCollection.mjs";
+export { type AsyncMethod, type AsyncProperty, AsyncPropertyImpl, type Collection, CustomCollection, CustomReference, type EnumCollection, EnumCollectionImpl, type LargeCollection, type LazyField, LazyFieldImpl, type LoadedCollection, type LoadedEnumCollection, type LoadedMethod, type LoadedProperty, type LoadedReadOnlyCollection, type LoadedReference, ManyToManyCollection, ManyToManyLargeCollection, type ManyToOneReference, ManyToOneReferenceImpl, OneToManyCollection, OneToManyLargeCollection, type OneToOneReference, OneToOneReferenceImpl, type PolymorphicReference, PolymorphicReferenceImpl, type Property, PropertyImpl, type ReactiveField, type ReactiveGetter, type ReactiveManyToMany, ReactiveManyToManyImpl, type ReactiveManyToManyOtherSide, ReactiveManyToManyOtherSideImpl, type ReactiveReference, ReactiveReferenceImpl, type ReadOnlyCollection, RecursiveCycleError, type Reference, type Relation, hasAsyncMethod, hasAsyncProperty, hasAsyncReactiveField, hasCustomCollection, hasCustomReference, hasEnumCollection, hasLargeMany, hasLargeManyToMany, hasLazyField, hasMany, hasManyDerived, hasManyThrough, hasManyToMany, hasOne, hasOneDerived, hasOnePolymorphic, hasOneThrough, hasOneToOne, hasProperty, hasReactiveField, hasReactiveGetter, hasReactiveManyToMany, hasReactiveManyToManyOtherSide, hasReactiveProperty, hasReactiveReference, hasRecursiveChildren, hasRecursiveM2m, hasRecursiveParents, isAsyncProperty, isAsyncReactiveField, isCollection, isLazyField, isLoadedAsyncProperty, isLoadedCollection, isLoadedLazyField, isLoadedOneToOneReference, isLoadedProperty, isLoadedReadOnlyCollection, isLoadedReference, isManyToOneReference, isOneToOneReference, isPolymorphicReference, isProperty, isReactiveField, isReactiveGetter, isReactiveManyToMany, isReactiveManyToManyOtherSide, isReactiveReference, isReadOnlyCollection, isReference, isRelation };

package/build/relations/index.js

@@ -1,97 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isReactiveManyToManyOtherSide = exports.hasReactiveManyToManyOtherSide = exports.ReactiveManyToManyOtherSideImpl = exports.isReactiveManyToMany = exports.hasReactiveManyToMany = exports.ReactiveManyToManyImpl = exports.isReactiveGetter = exports.hasReactiveGetter = exports.isReactiveField = exports.hasReactiveField = exports.isPolymorphicReference = exports.hasOnePolymorphic = exports.PolymorphicReferenceImpl = exports.isOneToOneReference = exports.isLoadedOneToOneReference = exports.hasOneToOne = exports.OneToOneReferenceImpl = exports.hasLargeMany = exports.OneToManyLargeCollection = exports.hasMany = exports.OneToManyCollection = exports.isManyToOneReference = exports.hasOne = exports.ManyToOneReferenceImpl = exports.hasLargeManyToMany = exports.ManyToManyLargeCollection = exports.hasManyToMany = exports.ManyToManyCollection = exports.hasOneThrough = exports.hasOneDerived = exports.hasManyThrough = exports.hasManyDerived = exports.isLoadedAsyncProperty = exports.isAsyncProperty = exports.hasAsyncProperty = exports.AsyncPropertyImpl = exports.isProperty = exports.isLoadedProperty = exports.hasReactiveProperty = exports.hasProperty = exports.PropertyImpl = exports.hasAsyncMethod = exports.hasCustomReference = exports.CustomReference = exports.hasEnumCollection = exports.EnumCollectionImpl = exports.hasCustomCollection = exports.CustomCollection = exports.isLoadedCollection = exports.isCollection = void 0;
-exports.isRelation = exports.isReference = exports.isLoadedReference = exports.hasRecursiveParents = exports.hasRecursiveM2m = exports.hasRecursiveChildren = exports.RecursiveCycleError = exports.isReadOnlyCollection = exports.isLoadedReadOnlyCollection = exports.isReactiveReference = exports.hasReactiveReference = exports.ReactiveReferenceImpl = exports.isAsyncReactiveField = exports.hasAsyncReactiveField = void 0;
-var Collection_1 = require("./Collection");
-Object.defineProperty(exports, "isCollection", { enumerable: true, get: function () { return Collection_1.isCollection; } });
-Object.defineProperty(exports, "isLoadedCollection", { enumerable: true, get: function () { return Collection_1.isLoadedCollection; } });
-var CustomCollection_1 = require("./CustomCollection");
-Object.defineProperty(exports, "CustomCollection", { enumerable: true, get: function () { return CustomCollection_1.CustomCollection; } });
-Object.defineProperty(exports, "hasCustomCollection", { enumerable: true, get: function () { return CustomCollection_1.hasCustomCollection; } });
-var EnumCollection_1 = require("./EnumCollection");
-Object.defineProperty(exports, "EnumCollectionImpl", { enumerable: true, get: function () { return EnumCollection_1.EnumCollectionImpl; } });
-Object.defineProperty(exports, "hasEnumCollection", { enumerable: true, get: function () { return EnumCollection_1.hasEnumCollection; } });
-var CustomReference_1 = require("./CustomReference");
-Object.defineProperty(exports, "CustomReference", { enumerable: true, get: function () { return CustomReference_1.CustomReference; } });
-Object.defineProperty(exports, "hasCustomReference", { enumerable: true, get: function () { return CustomReference_1.hasCustomReference; } });
-var hasAsyncMethod_1 = require("./hasAsyncMethod");
-Object.defineProperty(exports, "hasAsyncMethod", { enumerable: true, get: function () { return hasAsyncMethod_1.hasAsyncMethod; } });
-var hasProperty_1 = require("./hasProperty");
-Object.defineProperty(exports, "PropertyImpl", { enumerable: true, get: function () { return hasProperty_1.PropertyImpl; } });
-Object.defineProperty(exports, "hasProperty", { enumerable: true, get: function () { return hasProperty_1.hasProperty; } });
-Object.defineProperty(exports, "hasReactiveProperty", { enumerable: true, get: function () { return hasProperty_1.hasReactiveProperty; } });
-Object.defineProperty(exports, "isLoadedProperty", { enumerable: true, get: function () { return hasProperty_1.isLoadedProperty; } });
-Object.defineProperty(exports, "isProperty", { enumerable: true, get: function () { return hasProperty_1.isProperty; } });
-var AsyncProperty_1 = require("./AsyncProperty");
-Object.defineProperty(exports, "AsyncPropertyImpl", { enumerable: true, get: function () { return AsyncProperty_1.AsyncPropertyImpl; } });
-Object.defineProperty(exports, "hasAsyncProperty", { enumerable: true, get: function () { return AsyncProperty_1.hasAsyncProperty; } });
-Object.defineProperty(exports, "isAsyncProperty", { enumerable: true, get: function () { return AsyncProperty_1.isAsyncProperty; } });
-Object.defineProperty(exports, "isLoadedAsyncProperty", { enumerable: true, get: function () { return AsyncProperty_1.isLoadedAsyncProperty; } });
-var hasManyDerived_1 = require("./hasManyDerived");
-Object.defineProperty(exports, "hasManyDerived", { enumerable: true, get: function () { return hasManyDerived_1.hasManyDerived; } });
-var hasManyThrough_1 = require("./hasManyThrough");
-Object.defineProperty(exports, "hasManyThrough", { enumerable: true, get: function () { return hasManyThrough_1.hasManyThrough; } });
-var hasOneDerived_1 = require("./hasOneDerived");
-Object.defineProperty(exports, "hasOneDerived", { enumerable: true, get: function () { return hasOneDerived_1.hasOneDerived; } });
-var hasOneThrough_1 = require("./hasOneThrough");
-Object.defineProperty(exports, "hasOneThrough", { enumerable: true, get: function () { return hasOneThrough_1.hasOneThrough; } });
-var ManyToManyCollection_1 = require("./ManyToManyCollection");
-Object.defineProperty(exports, "ManyToManyCollection", { enumerable: true, get: function () { return ManyToManyCollection_1.ManyToManyCollection; } });
-Object.defineProperty(exports, "hasManyToMany", { enumerable: true, get: function () { return ManyToManyCollection_1.hasManyToMany; } });
-var ManyToManyLargeCollection_1 = require("./ManyToManyLargeCollection");
-Object.defineProperty(exports, "ManyToManyLargeCollection", { enumerable: true, get: function () { return ManyToManyLargeCollection_1.ManyToManyLargeCollection; } });
-Object.defineProperty(exports, "hasLargeManyToMany", { enumerable: true, get: function () { return ManyToManyLargeCollection_1.hasLargeManyToMany; } });
-var ManyToOneReference_1 = require("./ManyToOneReference");
-Object.defineProperty(exports, "ManyToOneReferenceImpl", { enumerable: true, get: function () { return ManyToOneReference_1.ManyToOneReferenceImpl; } });
-Object.defineProperty(exports, "hasOne", { enumerable: true, get: function () { return ManyToOneReference_1.hasOne; } });
-Object.defineProperty(exports, "isManyToOneReference", { enumerable: true, get: function () { return ManyToOneReference_1.isManyToOneReference; } });
-var OneToManyCollection_1 = require("./OneToManyCollection");
-Object.defineProperty(exports, "OneToManyCollection", { enumerable: true, get: function () { return OneToManyCollection_1.OneToManyCollection; } });
-Object.defineProperty(exports, "hasMany", { enumerable: true, get: function () { return OneToManyCollection_1.hasMany; } });
-var OneToManyLargeCollection_1 = require("./OneToManyLargeCollection");
-Object.defineProperty(exports, "OneToManyLargeCollection", { enumerable: true, get: function () { return OneToManyLargeCollection_1.OneToManyLargeCollection; } });
-Object.defineProperty(exports, "hasLargeMany", { enumerable: true, get: function () { return OneToManyLargeCollection_1.hasLargeMany; } });
-var OneToOneReference_1 = require("./OneToOneReference");
-Object.defineProperty(exports, "OneToOneReferenceImpl", { enumerable: true, get: function () { return OneToOneReference_1.OneToOneReferenceImpl; } });
-Object.defineProperty(exports, "hasOneToOne", { enumerable: true, get: function () { return OneToOneReference_1.hasOneToOne; } });
-Object.defineProperty(exports, "isLoadedOneToOneReference", { enumerable: true, get: function () { return OneToOneReference_1.isLoadedOneToOneReference; } });
-Object.defineProperty(exports, "isOneToOneReference", { enumerable: true, get: function () { return OneToOneReference_1.isOneToOneReference; } });
-var PolymorphicReference_1 = require("./PolymorphicReference");
-Object.defineProperty(exports, "PolymorphicReferenceImpl", { enumerable: true, get: function () { return PolymorphicReference_1.PolymorphicReferenceImpl; } });
-Object.defineProperty(exports, "hasOnePolymorphic", { enumerable: true, get: function () { return PolymorphicReference_1.hasOnePolymorphic; } });
-Object.defineProperty(exports, "isPolymorphicReference", { enumerable: true, get: function () { return PolymorphicReference_1.isPolymorphicReference; } });
-var ReactiveField_1 = require("./ReactiveField");
-Object.defineProperty(exports, "hasReactiveField", { enumerable: true, get: function () { return ReactiveField_1.hasReactiveField; } });
-Object.defineProperty(exports, "isReactiveField", { enumerable: true, get: function () { return ReactiveField_1.isReactiveField; } });
-var ReactiveGetter_1 = require("./ReactiveGetter");
-Object.defineProperty(exports, "hasReactiveGetter", { enumerable: true, get: function () { return ReactiveGetter_1.hasReactiveGetter; } });
-Object.defineProperty(exports, "isReactiveGetter", { enumerable: true, get: function () { return ReactiveGetter_1.isReactiveGetter; } });
-var ReactiveManyToMany_1 = require("./ReactiveManyToMany");
-Object.defineProperty(exports, "ReactiveManyToManyImpl", { enumerable: true, get: function () { return ReactiveManyToMany_1.ReactiveManyToManyImpl; } });
-Object.defineProperty(exports, "hasReactiveManyToMany", { enumerable: true, get: function () { return ReactiveManyToMany_1.hasReactiveManyToMany; } });
-Object.defineProperty(exports, "isReactiveManyToMany", { enumerable: true, get: function () { return ReactiveManyToMany_1.isReactiveManyToMany; } });
-var ReactiveManyToManyOtherSide_1 = require("./ReactiveManyToManyOtherSide");
-Object.defineProperty(exports, "ReactiveManyToManyOtherSideImpl", { enumerable: true, get: function () { return ReactiveManyToManyOtherSide_1.ReactiveManyToManyOtherSideImpl; } });
-Object.defineProperty(exports, "hasReactiveManyToManyOtherSide", { enumerable: true, get: function () { return ReactiveManyToManyOtherSide_1.hasReactiveManyToManyOtherSide; } });
-Object.defineProperty(exports, "isReactiveManyToManyOtherSide", { enumerable: true, get: function () { return ReactiveManyToManyOtherSide_1.isReactiveManyToManyOtherSide; } });
-var AsyncReactiveField_1 = require("./AsyncReactiveField");
-Object.defineProperty(exports, "hasAsyncReactiveField", { enumerable: true, get: function () { return AsyncReactiveField_1.hasAsyncReactiveField; } });
-Object.defineProperty(exports, "isAsyncReactiveField", { enumerable: true, get: function () { return AsyncReactiveField_1.isAsyncReactiveField; } });
-var ReactiveReference_1 = require("./ReactiveReference");
-Object.defineProperty(exports, "ReactiveReferenceImpl", { enumerable: true, get: function () { return ReactiveReference_1.ReactiveReferenceImpl; } });
-Object.defineProperty(exports, "hasReactiveReference", { enumerable: true, get: function () { return ReactiveReference_1.hasReactiveReference; } });
-Object.defineProperty(exports, "isReactiveReference", { enumerable: true, get: function () { return ReactiveReference_1.isReactiveReference; } });
-var ReadOnlyCollection_1 = require("./ReadOnlyCollection");
-Object.defineProperty(exports, "isLoadedReadOnlyCollection", { enumerable: true, get: function () { return ReadOnlyCollection_1.isLoadedReadOnlyCollection; } });
-Object.defineProperty(exports, "isReadOnlyCollection", { enumerable: true, get: function () { return ReadOnlyCollection_1.isReadOnlyCollection; } });
-var RecursiveCollection_1 = require("./RecursiveCollection");
-Object.defineProperty(exports, "RecursiveCycleError", { enumerable: true, get: function () { return RecursiveCollection_1.RecursiveCycleError; } });
-Object.defineProperty(exports, "hasRecursiveChildren", { enumerable: true, get: function () { return RecursiveCollection_1.hasRecursiveChildren; } });
-Object.defineProperty(exports, "hasRecursiveM2m", { enumerable: true, get: function () { return RecursiveCollection_1.hasRecursiveM2m; } });
-Object.defineProperty(exports, "hasRecursiveParents", { enumerable: true, get: function () { return RecursiveCollection_1.hasRecursiveParents; } });
-var Reference_1 = require("./Reference");
-Object.defineProperty(exports, "isLoadedReference", { enumerable: true, get: function () { return Reference_1.isLoadedReference; } });
-Object.defineProperty(exports, "isReference", { enumerable: true, get: function () { return Reference_1.isReference; } });
-var Relation_1 = require("./Relation");
-Object.defineProperty(exports, "isRelation", { enumerable: true, get: function () { return Relation_1.isRelation; } });
-//# sourceMappingURL=index.js.map
+import { isCollection, isLoadedCollection } from "./Collection.js";
+import { CustomCollection, hasCustomCollection } from "./CustomCollection.js";
+import { EnumCollectionImpl, hasEnumCollection } from "./EnumCollection.js";
+import { CustomReference, hasCustomReference } from "./CustomReference.js";
+import { hasReactiveGetter, isReactiveGetter } from "./ReactiveGetter.js";
+import { isRelation } from "./Relation.js";
+import { isLoadedReadOnlyCollection, isReadOnlyCollection } from "./ReadOnlyCollection.js";
+import { RecursiveCycleError } from "./RecursiveCycleError.js";
+import { hasRecursiveChildren, hasRecursiveM2m, hasRecursiveParents } from "./RecursiveCollection.js";
+import { hasAsyncMethod } from "./hasAsyncMethod.js";
+import { PropertyImpl, hasProperty, hasReactiveProperty, isLoadedProperty, isProperty } from "./hasProperty.js";
+import { AsyncPropertyImpl, hasAsyncProperty, isAsyncProperty, isLoadedAsyncProperty } from "./AsyncProperty.js";
+import { LazyFieldImpl, hasLazyField, isLazyField, isLoadedLazyField } from "./LazyField.js";
+import { hasManyDerived } from "./hasManyDerived.js";
+import { hasManyThrough } from "./hasManyThrough.js";
+import { isLoadedReference, isReference } from "./Reference.js";
+import { hasOneDerived } from "./hasOneDerived.js";
+import { hasOneThrough } from "./hasOneThrough.js";
+import { ManyToManyCollection, hasManyToMany } from "./ManyToManyCollection.js";
+import { ManyToManyLargeCollection, hasLargeManyToMany } from "./ManyToManyLargeCollection.js";
+import { OneToManyCollection, hasMany } from "./OneToManyCollection.js";
+import { ManyToOneReferenceImpl, hasOne, isManyToOneReference } from "./ManyToOneReference.js";
+import { OneToManyLargeCollection, hasLargeMany } from "./OneToManyLargeCollection.js";
+import { ReactiveReferenceImpl, hasReactiveReference, isReactiveReference } from "./ReactiveReference.js";
+import { OneToOneReferenceImpl, hasOneToOne, isLoadedOneToOneReference, isOneToOneReference } from "./OneToOneReference.js";
+import { PolymorphicReferenceImpl, hasOnePolymorphic, isPolymorphicReference } from "./PolymorphicReference.js";
+import { hasReactiveField, isReactiveField } from "./ReactiveField.js";
+import { ReactiveManyToManyImpl, hasReactiveManyToMany, isReactiveManyToMany } from "./ReactiveManyToMany.js";
+import { ReactiveManyToManyOtherSideImpl, hasReactiveManyToManyOtherSide, isReactiveManyToManyOtherSide } from "./ReactiveManyToManyOtherSide.js";
+import { hasAsyncReactiveField, isAsyncReactiveField } from "./AsyncReactiveField.js";
+export { AsyncPropertyImpl, CustomCollection, CustomReference, EnumCollectionImpl, LazyFieldImpl, ManyToManyCollection, ManyToManyLargeCollection, ManyToOneReferenceImpl, OneToManyCollection, OneToManyLargeCollection, OneToOneReferenceImpl, PolymorphicReferenceImpl, PropertyImpl, ReactiveManyToManyImpl, ReactiveManyToManyOtherSideImpl, ReactiveReferenceImpl, RecursiveCycleError, hasAsyncMethod, hasAsyncProperty, hasAsyncReactiveField, hasCustomCollection, hasCustomReference, hasEnumCollection, hasLargeMany, hasLargeManyToMany, hasLazyField, hasMany, hasManyDerived, hasManyThrough, hasManyToMany, hasOne, hasOneDerived, hasOnePolymorphic, hasOneThrough, hasOneToOne, hasProperty, hasReactiveField, hasReactiveGetter, hasReactiveManyToMany, hasReactiveManyToManyOtherSide, hasReactiveProperty, hasReactiveReference, hasRecursiveChildren, hasRecursiveM2m, hasRecursiveParents, isAsyncProperty, isAsyncReactiveField, isCollection, isLazyField, isLoadedAsyncProperty, isLoadedCollection, isLoadedLazyField, isLoadedOneToOneReference, isLoadedProperty, isLoadedReadOnlyCollection, isLoadedReference, isManyToOneReference, isOneToOneReference, isPolymorphicReference, isProperty, isReactiveField, isReactiveGetter, isReactiveManyToMany, isReactiveManyToManyOtherSide, isReactiveReference, isReadOnlyCollection, isReference, isRelation };

package/build/relations/isCascadeDelete.cjs

@@ -0,0 +1,11 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_EntityMetadata = require("../EntityMetadata.cjs");
+//#region src/relations/isCascadeDelete.ts
+/** Returns whether this relation is configured for cascade deletion on the entity or a base type. */
+function isCascadeDelete(relation, fieldName) {
+	return require_EntityMetadata.getBaseAndSelfMetas(require_EntityMetadata.getMetadata(relation.entity)).some((meta) => meta.config.__data.cascadeDeleteFields.includes(fieldName));
+}
+//#endregion
+exports.isCascadeDelete = isCascadeDelete;
+
+//# sourceMappingURL=isCascadeDelete.cjs.map

package/build/relations/isCascadeDelete.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isCascadeDelete.cjs","names":["getBaseAndSelfMetas","getMetadata"],"sources":["../../src/relations/isCascadeDelete.ts"],"sourcesContent":["import { getBaseAndSelfMetas, getMetadata } from \"src/EntityMetadata.ts\";\nimport type { AbstractRelationImpl } from \"src/relations/AbstractRelationImpl.ts\";\n\n// Keep metadata imports out of AbstractRelationImpl so query imports cannot evaluate a relation\n// subclass before its base class has initialized.\n/** Returns whether this relation is configured for cascade deletion on the entity or a base type. */\nexport function isCascadeDelete(relation: AbstractRelationImpl<any, any>, fieldName: string): boolean {\n  return getBaseAndSelfMetas(getMetadata(relation.entity)).some((meta) =>\n    meta.config.__data.cascadeDeleteFields.includes(fieldName as any),\n  );\n}\n"],"mappings":";;;;AAMA,SAAgB,gBAAgB,UAA0C,WAA4B;CACpG,OAAOA,uBAAAA,oBAAoBC,uBAAAA,YAAY,SAAS,MAAM,CAAC,CAAC,CAAC,MAAM,SAC7D,KAAK,OAAO,OAAO,oBAAoB,SAAS,SAAgB,CAClE;AACF"}

package/build/relations/isCascadeDelete.d.cts

@@ -0,0 +1,7 @@
+import { AbstractRelationImpl } from "./AbstractRelationImpl.cjs";
+//#region src/relations/isCascadeDelete.d.ts
+/** Returns whether this relation is configured for cascade deletion on the entity or a base type. */
+declare function isCascadeDelete(relation: AbstractRelationImpl<any, any>, fieldName: string): boolean;
+//#endregion
+export { isCascadeDelete };
+//# sourceMappingURL=isCascadeDelete.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isCascadeDelete.d.cts","names":[],"sources":["../../src/relations/isCascadeDelete.ts"],"mappings":";;;iBAMgB,gBAAgB,UAAU,gCAAgC"}

package/build/relations/isCascadeDelete.d.mts

@@ -0,0 +1,7 @@
+import { AbstractRelationImpl } from "./AbstractRelationImpl.mjs";
+//#region src/relations/isCascadeDelete.d.ts
+/** Returns whether this relation is configured for cascade deletion on the entity or a base type. */
+declare function isCascadeDelete(relation: AbstractRelationImpl<any, any>, fieldName: string): boolean;
+//#endregion
+export { isCascadeDelete };
+//# sourceMappingURL=isCascadeDelete.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isCascadeDelete.d.mts","names":[],"sources":["../../src/relations/isCascadeDelete.ts"],"mappings":";;;iBAMgB,gBAAgB,UAAU,gCAAgC"}