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

package/build/relations/OneToOneReference.js

@@ -1,14 +1,14 @@
-import { setField } from "../fields.js";
 import { AbstractRelationImpl } from "./AbstractRelationImpl.js";
 import { RelationT, RelationU } from "./RelationSymbols.js";
-import { oneToOneBatchLoader } from "../batchloaders/oneToOneBatchLoader.js";
-import { isCascadeDelete } from "./isCascadeDelete.js";
 import { ReferenceN } from "./ReferenceSymbols.js";
-import { failIfNewEntity, failNoId } from "./ManyToOneReference.js";
+import { setField } from "../fields.js";
+import { deTagId } from "../keys.js";
 import "./Reference.js";
+import { isCascadeDelete } from "./isCascadeDelete.js";
+import { failIfNewEntity, failNoId } from "./ManyToOneReference.js";
+import { oneToOneBatchLoader } from "../batchloaders/oneToOneBatchLoader.js";
 import { isReactiveReference } from "./ReactiveReference.js";
 import { lazyField } from "../newEntity.js";
-import { deTagId } from "../keys.js";
 import { getMetadata } from "../EntityMetadata.js";
 import { ensureNotDeleted } from "../index.js";
 import { appendStack, getEmInternalApi } from "../EntityManager.js";

package/build/relations/PolymorphicReference.cjs

@@ -1,14 +1,14 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_fields = require("../fields.cjs");
 const require_relations_AbstractRelationImpl = require("./AbstractRelationImpl.cjs");
 const require_relations_RelationSymbols = require("./RelationSymbols.cjs");
+const require_relations_ReferenceSymbols = require("./ReferenceSymbols.cjs");
+const require_fields = require("../fields.cjs");
+const require_keys = require("../keys.cjs");
 const require_relations_isCascadeDelete = require("./isCascadeDelete.cjs");
 const require_relations_OneToManyCollection = require("./OneToManyCollection.cjs");
-const require_relations_ReferenceSymbols = require("./ReferenceSymbols.cjs");
 const require_relations_ManyToOneReference = require("./ManyToOneReference.cjs");
 const require_utils = require("../utils.cjs");
 const require_newEntity = require("../newEntity.cjs");
-const require_keys = require("../keys.cjs");
 const require_configure = require("../configure.cjs");
 const require_EntityMetadata = require("../EntityMetadata.cjs");
 const require_index = require("../index.cjs");

package/build/relations/PolymorphicReference.js

@@ -1,13 +1,13 @@
-import { getField, setField } from "../fields.js";
 import { AbstractRelationImpl } from "./AbstractRelationImpl.js";
 import { RelationT, RelationU } from "./RelationSymbols.js";
+import { ReferenceN } from "./ReferenceSymbols.js";
+import { getField, setField } from "../fields.js";
+import { maybeResolveReferenceToId } from "../keys.js";
 import { isCascadeDelete } from "./isCascadeDelete.js";
 import { OneToManyCollection } from "./OneToManyCollection.js";
-import { ReferenceN } from "./ReferenceSymbols.js";
 import { failIfNewEntity, failNoId } from "./ManyToOneReference.js";
 import { fail } from "../utils.js";
 import { lazyField } from "../newEntity.js";
-import { maybeResolveReferenceToId } from "../keys.js";
 import { getConstructorFromTaggedId, maybeGetConstructorFromReference } from "../configure.js";
 import { getMetadata } from "../EntityMetadata.js";
 import { ensureNotDeleted } from "../index.js";

package/build/relations/ReactiveField.cjs

@@ -1,10 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_fields = require("../fields.cjs");
 const require_relations_AbstractPropertyImpl = require("./AbstractPropertyImpl.cjs");
 const require_relations_PropertySymbols = require("./PropertySymbols.cjs");
-require("../IsLoadedCache.cjs");
-const require_reactiveHints = require("../reactiveHints.cjs");
-const require_loadHints = require("../loadHints.cjs");
+const require_reactivity_reactiveHints = require("../reactivity/reactiveHints.cjs");
+const require_loading_loadHints = require("../loading/loadHints.cjs");
+const require_fields = require("../fields.cjs");
 const require_newEntity = require("../newEntity.cjs");
 const require_EntityMetadata = require("../EntityMetadata.cjs");
 require("../index.cjs");
@@ -81,7 +80,7 @@ var ReactiveFieldImpl = class extends require_relations_AbstractPropertyImpl.Abs
 	}
 	get isLoaded() {
 		if (this.#isLoaded !== void 0) return this.#isLoaded;
-		this.#isLoaded = require_loadHints.isLoaded(this.entity, this.loadHint);
+		this.#isLoaded = require_loading_loadHints.isLoaded(this.entity, this.loadHint);
 		require_EntityManager.getEmInternalApi(this.entity.em).isLoadedCache.add(this);
 		return this.#isLoaded;
 	}
@@ -91,7 +90,7 @@ var ReactiveFieldImpl = class extends require_relations_AbstractPropertyImpl.Abs
 	}
 	get loadHint() {
 		const meta = require_EntityMetadata.getMetadata(this.entity);
-		return meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= require_reactiveHints.convertToLoadHint(meta, this.reactiveHint);
+		return meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= require_reactivity_reactiveHints.convertToLoadHint(meta, this.reactiveHint);
 	}
 	setFactoryValue(newValue) {
 		require_fields.setField(this.entity, this.fieldName, newValue);

package/build/relations/ReactiveField.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveField.cjs","names":["lazyField","getMetadata","AbstractPropertyImpl","#field","#reactiveHint","#loadPromise","#isLoaded","#isCached","getEmInternalApi","getField","isFieldSet","isLoaded","convertToLoadHint","PropertyT"],"sources":["../../src/relations/ReactiveField.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { getEmInternalApi } from \"../EntityManager.ts\";\nimport { type PrimitiveField, getMetadata } from \"../EntityMetadata.ts\";\nimport { getField, isFieldSet, setField } from \"../fields.ts\";\nimport { isLoaded } from \"../index.ts\";\nimport { type IsLoadedCachable } from \"../IsLoadedCache.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { type Reacted, type ReactiveHint, convertToLoadHint } from \"../reactiveHints.ts\";\nimport { AbstractPropertyImpl } from \"./AbstractPropertyImpl.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\n\n/**\n * A `ReactiveField` is a value that is derived from other entities/values,\n * similar to a `Property`, but it is also persisted in the database.\n *\n * This allows callers (or SQL queries) to access the value without first calling\n * `await load()` on the property.\n *\n * So, unlike `Property`, `.get` is always available; if the property is unloaded,\n * then `.get` will return the last-calculated value, but if the property is loaded,\n * then it will go ahead and invoke function to calculate the latest value (i.e. so\n * that you can observe the latest & greatest value w/o waiting for `em.flush` to\n * re-calc the value while persisting to the database.\n */\nexport interface ReactiveField<T extends Entity, V> {\n  [PropertyT]: T;\n  isLoaded: boolean;\n  isSet: boolean;\n\n  /**\n   * Calculates the latest derived value.\n   *\n   * Users are not required to call this method explicitly, as Joist will keep the\n   * persisted value automatically in-sync, but if for some reason (code changes,\n   * bug fixes, etc.) you need to trigger an explicit recalc, you can call `.load()`,\n   * any dependent data will be loaded from the database, and the latest value\n   * returned, and then later stored to the database on `em.flush`.\n   *\n   * Note that persisted properties used in load hints, i.e. `em.populate`s that\n   * accidentally list reactive fields (instead of just relations) will not have\n   * `.load()` invoked, and will instead use the previously-calculated value.\n   * The rationale is that one persisted property should be able to declare its\n   * dependency on another persisted property (for its reactive field-level hint)\n   * without causing that dependent property's populate hint to itself be loaded.\n   */\n  load(opts?: { forceReload?: boolean }): Promise<V>;\n\n  /** If loaded, returns the latest derived value, or if unload returns the previously-calculated value. */\n  get: V;\n\n  /**\n   * Returns the as-of-last-flush previously-calculated value.\n   *\n   * This is useful if you have to purposefully avoid using the lambda to calc the latest value,\n   * i.e. if you're in a test and want to watch a calculated value change from some dummy value\n   * to the new derived value.\n   * */\n  fieldValue: 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 hasReactiveField<T extends Entity, const H extends ReactiveHint<T>, V>(\n  hint: H,\n  fn: (entity: Reacted<T, H>) => V,\n): ReactiveField<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    const field = getMetadata(entity).allFields[fieldName] as PrimitiveField;\n    return new ReactiveFieldImpl(entity, field, hint, fn);\n  });\n}\n\nexport class ReactiveFieldImpl<T extends Entity, H extends ReactiveHint<T>, V>\n  extends AbstractPropertyImpl<T>\n  implements ReactiveField<T, V>, IsLoadedCachable\n{\n  readonly #field: PrimitiveField;\n  readonly #reactiveHint: H;\n  #loadPromise: any;\n  // Initially undefined, then cached as true/false\n  #isLoaded: boolean | undefined;\n  #isCached: boolean | \"factory-value\" = false;\n\n  constructor(\n    entity: T,\n    field: PrimitiveField,\n    reactiveHint: H,\n    private fn: (entity: Reacted<T, H>) => V,\n  ) {\n    super(entity);\n    this.#field = field;\n    this.#reactiveHint = reactiveHint;\n  }\n\n  async load(opts?: { forceReload?: boolean }): Promise<V> {\n    // Even without `forceReload=true`, any explicit calls to `.load()` ==> ensure a fresh value,\n    // because `.get` may have cached the stale/previously-calculated value.\n    //\n    // (Currently `em.populate` / `populateDataLoader` has a hack/escape hatch that ignores calling\n    // RF.load(), to avoid pulling in the RF subgraph over using the materialized value, which ideally would be\n    // replaced with us learning to do the maybeDirty approach.)\n    if (!this.isLoaded || opts?.forceReload) {\n      return (this.#loadPromise ??= this.entity.em.populate(this.entity, { hint: this.loadHint } as any).then(() => {\n        this.#loadPromise = undefined;\n        this.#isLoaded = true;\n        getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n        // Wait and reset `#isCached` until inside this `then`, so that we don't have a race condition where:\n        // - two relations (us and someone else) are both passed to `em.calc`\n        // - their load hint is simpler, so their promises resolves first, and their `.get` calls our `.get`\n        // - our `.get` sees we're not loaded, but calls `fieldValue` for the existing value, and dutifully sets `#isCached=true`\n        // - finally our promise runs, and if we didn't immediately set `#isCached=false` here, our `.get` would again\n        //   early return and keep using the stale fieldValue.\n        this.resetCacheUnlessFactoryPinned();\n        // Go through `this.get` so that `setField` is called to set our latest value\n        return this.get;\n      }));\n    }\n    this.resetCacheUnlessFactoryPinned();\n    return this.get;\n  }\n\n  /** Returns either the latest calculated value (if loaded) or the previously-calculated value (if not loaded). */\n  get get(): V {\n    const { fn } = this;\n    // Some ReactiveFields can have surprisingly expensive calculations, especially in loops\n    // or those that invoke loops, so cache the value.\n    if (this.#isCached) return this.fieldValue;\n    // isLoaded will watch for our previously-loaded subgraph being mutated (isLoaded is locally cached but hooked into\n    // our IsLoadedCache cache that is immediately invalidated on write-path), and if we've drifted to not-loaded, it's\n    // better to fail and tell the user.\n    if (this.isLoaded) {\n      const newValue = fn(this.entity as Reacted<T, H>);\n      if (!getEmInternalApi(this.entity.em).isValidating) {\n        // setField will immediately invalidate downstream #isLoaded/#isCached values\n        setField(this.entity, this.fieldName, newValue);\n        this.#isCached = true;\n        getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n      }\n      return newValue;\n    } else if (this.isSet) {\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n      return this.fieldValue;\n    } else {\n      throw new Error(`${this.fieldName} has not been derived yet`);\n    }\n  }\n\n  get fieldName(): keyof T & string {\n    return this.#field.fieldName as keyof T & string;\n  }\n\n  get reactiveHint(): H {\n    return this.#reactiveHint;\n  }\n\n  get fieldValue(): V {\n    return getField(this.entity, this.fieldName);\n  }\n\n  get isSet() {\n    return isFieldSet(this.entity, this.fieldName);\n  }\n\n  get isLoaded() {\n    // Skip an expensive isLoaded(subgraph) call if no mutations have happened\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    this.#isLoaded = isLoaded(this.entity, this.loadHint);\n    getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    // Even though we reset this on every mutation, `isLoaded` will still realize when the subgraph\n    // is still loaded (as it did before we added caching), so users won't see false positive.\n    this.#isLoaded = undefined;\n    this.resetCacheUnlessFactoryPinned();\n  }\n\n  get loadHint(): any {\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.reactiveHint));\n  }\n\n  setFactoryValue(newValue: any): void {\n    setField(this.entity, this.fieldName, newValue);\n    this.#isCached = \"factory-value\";\n  }\n\n  [PropertyT] = undefined as any as T;\n\n  private resetCacheUnlessFactoryPinned(): void {\n    // If factories asked for a hard-coded value, don't reset the cached flag\n    if (this.#isCached === \"factory-value\") return;\n    this.#isCached = false;\n  }\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveField. */\nexport function isReactiveField(maybeReactiveField: any): maybeReactiveField is ReactiveField<any, any> {\n  return maybeReactiveField instanceof ReactiveFieldImpl;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoEA,SAAgB,iBACd,MACA,IACqB;CACrB,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,MAAM,QAAQC,uBAAAA,YAAY,MAAM,CAAC,CAAC,UAAU;EAC5C,OAAO,IAAI,kBAAkB,QAAQ,OAAO,MAAM,EAAE;CACtD,CAAC;AACH;AAEA,IAAa,oBAAb,cACUC,uCAAAA,qBAEV;CAYY;CAXV;CACA;CACA;CAEA;CACA,YAAuC;CAEvC,YACE,QACA,OACA,cACA,IACA;EACA,MAAM,MAAM;EAFJ,KAAA,KAAA;EAGR,KAAKC,SAAS;EACd,KAAKC,gBAAgB;CACvB;CAEA,MAAM,KAAK,MAA8C;EAOvD,IAAI,CAAC,KAAK,YAAY,MAAM,aAC1B,OAAQ,KAAKC,iBAAiB,KAAK,OAAO,GAAG,SAAS,KAAK,QAAQ,EAAE,MAAM,KAAK,SAAS,CAAQ,CAAC,CAAC,WAAW;GAC5G,KAAKA,eAAe,KAAA;GACpB,KAAKC,YAAY;GACjB,sBAAA,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;GAOvD,KAAK,8BAA8B;GAEnC,OAAO,KAAK;EACd,CAAC;EAEH,KAAK,8BAA8B;EACnC,OAAO,KAAK;CACd;;CAGA,IAAI,MAAS;EACX,MAAM,EAAE,OAAO;EAGf,IAAI,KAAKC,WAAW,OAAO,KAAK;EAIhC,IAAI,KAAK,UAAU;GACjB,MAAM,WAAW,GAAG,KAAK,MAAuB;GAChD,IAAI,CAACC,sBAAAA,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc;IAElD,eAAA,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;IAC9C,KAAKD,YAAY;IACjB,sBAAA,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;GACzD;GACA,OAAO;EACT,OAAO,IAAI,KAAK,OAAO;GACrB,KAAKA,YAAY;GACjB,sBAAA,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;GACvD,OAAO,KAAK;EACd,OACE,MAAM,IAAI,MAAM,GAAG,KAAK,UAAU,0BAA0B;CAEhE;CAEA,IAAI,YAA8B;EAChC,OAAO,KAAKJ,OAAO;CACrB;CAEA,IAAI,eAAkB;EACpB,OAAO,KAAKC;CACd;CAEA,IAAI,aAAgB;EAClB,OAAOK,eAAAA,SAAS,KAAK,QAAQ,KAAK,SAAS;CAC7C;CAEA,IAAI,QAAQ;EACV,OAAOC,eAAAA,WAAW,KAAK,QAAQ,KAAK,SAAS;CAC/C;CAEA,IAAI,WAAW;EAEb,IAAI,KAAKJ,cAAc,KAAA,GAAW,OAAO,KAAKA;EAC9C,KAAKA,YAAYK,kBAAAA,SAAS,KAAK,QAAQ,KAAK,QAAQ;EACpD,sBAAA,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;EACvD,OAAO,KAAKL;CACd;CAEA,gBAAsB;EAGpB,KAAKA,YAAY,KAAA;EACjB,KAAK,8BAA8B;CACrC;CAEA,IAAI,WAAgB;EAClB,MAAM,OAAOL,uBAAAA,YAAY,KAAK,MAAM;EACpC,OAAQ,KAAK,OAAO,OAAO,wBAAwB,KAAK,eAAeW,sBAAAA,kBAAkB,MAAM,KAAK,YAAY;CAClH;CAEA,gBAAgB,UAAqB;EACnC,eAAA,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;EAC9C,KAAKL,YAAY;CACnB;CAEA,CAACM,kCAAAA,aAAa,KAAA;CAEd,gCAA8C;EAE5C,IAAI,KAAKN,cAAc,iBAAiB;EACxC,KAAKA,YAAY;CACnB;AACF;;AAGA,SAAgB,gBAAgB,oBAAwE;CACtG,OAAO,8BAA8B;AACvC"}
+{"version":3,"file":"ReactiveField.cjs","names":["lazyField","getMetadata","AbstractPropertyImpl","#field","#reactiveHint","#loadPromise","#isLoaded","#isCached","getEmInternalApi","getField","isFieldSet","isLoaded","convertToLoadHint","PropertyT"],"sources":["../../src/relations/ReactiveField.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { getEmInternalApi } from \"../EntityManager.ts\";\nimport { type PrimitiveField, getMetadata } from \"../EntityMetadata.ts\";\nimport { getField, isFieldSet, setField } from \"../fields.ts\";\nimport { isLoaded } from \"../index.ts\";\nimport type { IsLoadedCachable } from \"../loading/IsLoadedCache.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { type Reacted, type ReactiveHint, convertToLoadHint } from \"../reactivity/reactiveHints.ts\";\nimport { AbstractPropertyImpl } from \"./AbstractPropertyImpl.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\n\n/**\n * A `ReactiveField` is a value that is derived from other entities/values,\n * similar to a `Property`, but it is also persisted in the database.\n *\n * This allows callers (or SQL queries) to access the value without first calling\n * `await load()` on the property.\n *\n * So, unlike `Property`, `.get` is always available; if the property is unloaded,\n * then `.get` will return the last-calculated value, but if the property is loaded,\n * then it will go ahead and invoke function to calculate the latest value (i.e. so\n * that you can observe the latest & greatest value w/o waiting for `em.flush` to\n * re-calc the value while persisting to the database.\n */\nexport interface ReactiveField<T extends Entity, V> {\n  [PropertyT]: T;\n  isLoaded: boolean;\n  isSet: boolean;\n\n  /**\n   * Calculates the latest derived value.\n   *\n   * Users are not required to call this method explicitly, as Joist will keep the\n   * persisted value automatically in-sync, but if for some reason (code changes,\n   * bug fixes, etc.) you need to trigger an explicit recalc, you can call `.load()`,\n   * any dependent data will be loaded from the database, and the latest value\n   * returned, and then later stored to the database on `em.flush`.\n   *\n   * Note that persisted properties used in load hints, i.e. `em.populate`s that\n   * accidentally list reactive fields (instead of just relations) will not have\n   * `.load()` invoked, and will instead use the previously-calculated value.\n   * The rationale is that one persisted property should be able to declare its\n   * dependency on another persisted property (for its reactive field-level hint)\n   * without causing that dependent property's populate hint to itself be loaded.\n   */\n  load(opts?: { forceReload?: boolean }): Promise<V>;\n\n  /** If loaded, returns the latest derived value, or if unload returns the previously-calculated value. */\n  get: V;\n\n  /**\n   * Returns the as-of-last-flush previously-calculated value.\n   *\n   * This is useful if you have to purposefully avoid using the lambda to calc the latest value,\n   * i.e. if you're in a test and want to watch a calculated value change from some dummy value\n   * to the new derived value.\n   * */\n  fieldValue: 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 hasReactiveField<T extends Entity, const H extends ReactiveHint<T>, V>(\n  hint: H,\n  fn: (entity: Reacted<T, H>) => V,\n): ReactiveField<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    const field = getMetadata(entity).allFields[fieldName] as PrimitiveField;\n    return new ReactiveFieldImpl(entity, field, hint, fn);\n  });\n}\n\nexport class ReactiveFieldImpl<T extends Entity, H extends ReactiveHint<T>, V>\n  extends AbstractPropertyImpl<T>\n  implements ReactiveField<T, V>, IsLoadedCachable\n{\n  readonly #field: PrimitiveField;\n  readonly #reactiveHint: H;\n  #loadPromise: any;\n  // Initially undefined, then cached as true/false\n  #isLoaded: boolean | undefined;\n  #isCached: boolean | \"factory-value\" = false;\n\n  constructor(\n    entity: T,\n    field: PrimitiveField,\n    reactiveHint: H,\n    private fn: (entity: Reacted<T, H>) => V,\n  ) {\n    super(entity);\n    this.#field = field;\n    this.#reactiveHint = reactiveHint;\n  }\n\n  async load(opts?: { forceReload?: boolean }): Promise<V> {\n    // Even without `forceReload=true`, any explicit calls to `.load()` ==> ensure a fresh value,\n    // because `.get` may have cached the stale/previously-calculated value.\n    //\n    // (Currently `em.populate` / `populateDataLoader` has a hack/escape hatch that ignores calling\n    // RF.load(), to avoid pulling in the RF subgraph over using the materialized value, which ideally would be\n    // replaced with us learning to do the maybeDirty approach.)\n    if (!this.isLoaded || opts?.forceReload) {\n      return (this.#loadPromise ??= this.entity.em.populate(this.entity, { hint: this.loadHint } as any).then(() => {\n        this.#loadPromise = undefined;\n        this.#isLoaded = true;\n        getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n        // Wait and reset `#isCached` until inside this `then`, so that we don't have a race condition where:\n        // - two relations (us and someone else) are both passed to `em.calc`\n        // - their load hint is simpler, so their promises resolves first, and their `.get` calls our `.get`\n        // - our `.get` sees we're not loaded, but calls `fieldValue` for the existing value, and dutifully sets `#isCached=true`\n        // - finally our promise runs, and if we didn't immediately set `#isCached=false` here, our `.get` would again\n        //   early return and keep using the stale fieldValue.\n        this.resetCacheUnlessFactoryPinned();\n        // Go through `this.get` so that `setField` is called to set our latest value\n        return this.get;\n      }));\n    }\n    this.resetCacheUnlessFactoryPinned();\n    return this.get;\n  }\n\n  /** Returns either the latest calculated value (if loaded) or the previously-calculated value (if not loaded). */\n  get get(): V {\n    const { fn } = this;\n    // Some ReactiveFields can have surprisingly expensive calculations, especially in loops\n    // or those that invoke loops, so cache the value.\n    if (this.#isCached) return this.fieldValue;\n    // isLoaded will watch for our previously-loaded subgraph being mutated (isLoaded is locally cached but hooked into\n    // our IsLoadedCache cache that is immediately invalidated on write-path), and if we've drifted to not-loaded, it's\n    // better to fail and tell the user.\n    if (this.isLoaded) {\n      const newValue = fn(this.entity as Reacted<T, H>);\n      if (!getEmInternalApi(this.entity.em).isValidating) {\n        // setField will immediately invalidate downstream #isLoaded/#isCached values\n        setField(this.entity, this.fieldName, newValue);\n        this.#isCached = true;\n        getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n      }\n      return newValue;\n    } else if (this.isSet) {\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n      return this.fieldValue;\n    } else {\n      throw new Error(`${this.fieldName} has not been derived yet`);\n    }\n  }\n\n  get fieldName(): keyof T & string {\n    return this.#field.fieldName as keyof T & string;\n  }\n\n  get reactiveHint(): H {\n    return this.#reactiveHint;\n  }\n\n  get fieldValue(): V {\n    return getField(this.entity, this.fieldName);\n  }\n\n  get isSet() {\n    return isFieldSet(this.entity, this.fieldName);\n  }\n\n  get isLoaded() {\n    // Skip an expensive isLoaded(subgraph) call if no mutations have happened\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    this.#isLoaded = isLoaded(this.entity, this.loadHint);\n    getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    // Even though we reset this on every mutation, `isLoaded` will still realize when the subgraph\n    // is still loaded (as it did before we added caching), so users won't see false positive.\n    this.#isLoaded = undefined;\n    this.resetCacheUnlessFactoryPinned();\n  }\n\n  get loadHint(): any {\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.reactiveHint));\n  }\n\n  setFactoryValue(newValue: any): void {\n    setField(this.entity, this.fieldName, newValue);\n    this.#isCached = \"factory-value\";\n  }\n\n  [PropertyT] = undefined as any as T;\n\n  private resetCacheUnlessFactoryPinned(): void {\n    // If factories asked for a hard-coded value, don't reset the cached flag\n    if (this.#isCached === \"factory-value\") return;\n    this.#isCached = false;\n  }\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveField. */\nexport function isReactiveField(maybeReactiveField: any): maybeReactiveField is ReactiveField<any, any> {\n  return maybeReactiveField instanceof ReactiveFieldImpl;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoEA,SAAgB,iBACd,MACA,IACqB;CACrB,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,MAAM,QAAQC,uBAAAA,YAAY,MAAM,CAAC,CAAC,UAAU;EAC5C,OAAO,IAAI,kBAAkB,QAAQ,OAAO,MAAM,EAAE;CACtD,CAAC;AACH;AAEA,IAAa,oBAAb,cACUC,uCAAAA,qBAEV;CAYY;CAXV;CACA;CACA;CAEA;CACA,YAAuC;CAEvC,YACE,QACA,OACA,cACA,IACA;EACA,MAAM,MAAM;EAFJ,KAAA,KAAA;EAGR,KAAKC,SAAS;EACd,KAAKC,gBAAgB;CACvB;CAEA,MAAM,KAAK,MAA8C;EAOvD,IAAI,CAAC,KAAK,YAAY,MAAM,aAC1B,OAAQ,KAAKC,iBAAiB,KAAK,OAAO,GAAG,SAAS,KAAK,QAAQ,EAAE,MAAM,KAAK,SAAS,CAAQ,CAAC,CAAC,WAAW;GAC5G,KAAKA,eAAe,KAAA;GACpB,KAAKC,YAAY;GACjB,sBAAA,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;GAOvD,KAAK,8BAA8B;GAEnC,OAAO,KAAK;EACd,CAAC;EAEH,KAAK,8BAA8B;EACnC,OAAO,KAAK;CACd;;CAGA,IAAI,MAAS;EACX,MAAM,EAAE,OAAO;EAGf,IAAI,KAAKC,WAAW,OAAO,KAAK;EAIhC,IAAI,KAAK,UAAU;GACjB,MAAM,WAAW,GAAG,KAAK,MAAuB;GAChD,IAAI,CAACC,sBAAAA,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc;IAElD,eAAA,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;IAC9C,KAAKD,YAAY;IACjB,sBAAA,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;GACzD;GACA,OAAO;EACT,OAAO,IAAI,KAAK,OAAO;GACrB,KAAKA,YAAY;GACjB,sBAAA,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;GACvD,OAAO,KAAK;EACd,OACE,MAAM,IAAI,MAAM,GAAG,KAAK,UAAU,0BAA0B;CAEhE;CAEA,IAAI,YAA8B;EAChC,OAAO,KAAKJ,OAAO;CACrB;CAEA,IAAI,eAAkB;EACpB,OAAO,KAAKC;CACd;CAEA,IAAI,aAAgB;EAClB,OAAOK,eAAAA,SAAS,KAAK,QAAQ,KAAK,SAAS;CAC7C;CAEA,IAAI,QAAQ;EACV,OAAOC,eAAAA,WAAW,KAAK,QAAQ,KAAK,SAAS;CAC/C;CAEA,IAAI,WAAW;EAEb,IAAI,KAAKJ,cAAc,KAAA,GAAW,OAAO,KAAKA;EAC9C,KAAKA,YAAYK,0BAAAA,SAAS,KAAK,QAAQ,KAAK,QAAQ;EACpD,sBAAA,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;EACvD,OAAO,KAAKL;CACd;CAEA,gBAAsB;EAGpB,KAAKA,YAAY,KAAA;EACjB,KAAK,8BAA8B;CACrC;CAEA,IAAI,WAAgB;EAClB,MAAM,OAAOL,uBAAAA,YAAY,KAAK,MAAM;EACpC,OAAQ,KAAK,OAAO,OAAO,wBAAwB,KAAK,eAAeW,iCAAAA,kBAAkB,MAAM,KAAK,YAAY;CAClH;CAEA,gBAAgB,UAAqB;EACnC,eAAA,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;EAC9C,KAAKL,YAAY;CACnB;CAEA,CAACM,kCAAAA,aAAa,KAAA;CAEd,gCAA8C;EAE5C,IAAI,KAAKN,cAAc,iBAAiB;EACxC,KAAKA,YAAY;CACnB;AACF;;AAGA,SAAgB,gBAAgB,oBAAwE;CACtG,OAAO,8BAA8B;AACvC"}

package/build/relations/ReactiveField.d.cts

@@ -1,7 +1,7 @@
 import { AbstractPropertyImpl } from "./AbstractPropertyImpl.cjs";
 import { PropertyT } from "./PropertySymbols.cjs";
-import { IsLoadedCachable } from "../IsLoadedCache.cjs";
-import { Reacted, ReactiveHint } from "../reactiveHints.cjs";
+import { IsLoadedCachable } from "../loading/IsLoadedCache.cjs";
+import { Reacted, ReactiveHint } from "../reactivity/reactiveHints.cjs";
 import { PrimitiveField } from "../EntityMetadata.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/ReactiveField.d.ts

package/build/relations/ReactiveField.d.mts

@@ -1,7 +1,7 @@
 import { AbstractPropertyImpl } from "./AbstractPropertyImpl.mjs";
 import { PropertyT } from "./PropertySymbols.mjs";
-import { IsLoadedCachable } from "../IsLoadedCache.mjs";
-import { Reacted, ReactiveHint } from "../reactiveHints.mjs";
+import { IsLoadedCachable } from "../loading/IsLoadedCache.mjs";
+import { Reacted, ReactiveHint } from "../reactivity/reactiveHints.mjs";
 import { PrimitiveField } from "../EntityMetadata.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/ReactiveField.d.ts

package/build/relations/ReactiveField.js

@@ -1,9 +1,8 @@
-import { getField, isFieldSet, setField } from "../fields.js";
 import { AbstractPropertyImpl } from "./AbstractPropertyImpl.js";
 import { PropertyT } from "./PropertySymbols.js";
-import "../IsLoadedCache.js";
-import { convertToLoadHint } from "../reactiveHints.js";
-import { isLoaded } from "../loadHints.js";
+import { convertToLoadHint } from "../reactivity/reactiveHints.js";
+import { isLoaded } from "../loading/loadHints.js";
+import { getField, isFieldSet, setField } from "../fields.js";
 import { lazyField } from "../newEntity.js";
 import { getMetadata } from "../EntityMetadata.js";
 import "../index.js";

package/build/relations/ReactiveField.js.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveField.js","names":["#field","#reactiveHint","#loadPromise","#isLoaded","#isCached"],"sources":["../../src/relations/ReactiveField.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { getEmInternalApi } from \"../EntityManager.ts\";\nimport { type PrimitiveField, getMetadata } from \"../EntityMetadata.ts\";\nimport { getField, isFieldSet, setField } from \"../fields.ts\";\nimport { isLoaded } from \"../index.ts\";\nimport { type IsLoadedCachable } from \"../IsLoadedCache.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { type Reacted, type ReactiveHint, convertToLoadHint } from \"../reactiveHints.ts\";\nimport { AbstractPropertyImpl } from \"./AbstractPropertyImpl.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\n\n/**\n * A `ReactiveField` is a value that is derived from other entities/values,\n * similar to a `Property`, but it is also persisted in the database.\n *\n * This allows callers (or SQL queries) to access the value without first calling\n * `await load()` on the property.\n *\n * So, unlike `Property`, `.get` is always available; if the property is unloaded,\n * then `.get` will return the last-calculated value, but if the property is loaded,\n * then it will go ahead and invoke function to calculate the latest value (i.e. so\n * that you can observe the latest & greatest value w/o waiting for `em.flush` to\n * re-calc the value while persisting to the database.\n */\nexport interface ReactiveField<T extends Entity, V> {\n  [PropertyT]: T;\n  isLoaded: boolean;\n  isSet: boolean;\n\n  /**\n   * Calculates the latest derived value.\n   *\n   * Users are not required to call this method explicitly, as Joist will keep the\n   * persisted value automatically in-sync, but if for some reason (code changes,\n   * bug fixes, etc.) you need to trigger an explicit recalc, you can call `.load()`,\n   * any dependent data will be loaded from the database, and the latest value\n   * returned, and then later stored to the database on `em.flush`.\n   *\n   * Note that persisted properties used in load hints, i.e. `em.populate`s that\n   * accidentally list reactive fields (instead of just relations) will not have\n   * `.load()` invoked, and will instead use the previously-calculated value.\n   * The rationale is that one persisted property should be able to declare its\n   * dependency on another persisted property (for its reactive field-level hint)\n   * without causing that dependent property's populate hint to itself be loaded.\n   */\n  load(opts?: { forceReload?: boolean }): Promise<V>;\n\n  /** If loaded, returns the latest derived value, or if unload returns the previously-calculated value. */\n  get: V;\n\n  /**\n   * Returns the as-of-last-flush previously-calculated value.\n   *\n   * This is useful if you have to purposefully avoid using the lambda to calc the latest value,\n   * i.e. if you're in a test and want to watch a calculated value change from some dummy value\n   * to the new derived value.\n   * */\n  fieldValue: 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 hasReactiveField<T extends Entity, const H extends ReactiveHint<T>, V>(\n  hint: H,\n  fn: (entity: Reacted<T, H>) => V,\n): ReactiveField<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    const field = getMetadata(entity).allFields[fieldName] as PrimitiveField;\n    return new ReactiveFieldImpl(entity, field, hint, fn);\n  });\n}\n\nexport class ReactiveFieldImpl<T extends Entity, H extends ReactiveHint<T>, V>\n  extends AbstractPropertyImpl<T>\n  implements ReactiveField<T, V>, IsLoadedCachable\n{\n  readonly #field: PrimitiveField;\n  readonly #reactiveHint: H;\n  #loadPromise: any;\n  // Initially undefined, then cached as true/false\n  #isLoaded: boolean | undefined;\n  #isCached: boolean | \"factory-value\" = false;\n\n  constructor(\n    entity: T,\n    field: PrimitiveField,\n    reactiveHint: H,\n    private fn: (entity: Reacted<T, H>) => V,\n  ) {\n    super(entity);\n    this.#field = field;\n    this.#reactiveHint = reactiveHint;\n  }\n\n  async load(opts?: { forceReload?: boolean }): Promise<V> {\n    // Even without `forceReload=true`, any explicit calls to `.load()` ==> ensure a fresh value,\n    // because `.get` may have cached the stale/previously-calculated value.\n    //\n    // (Currently `em.populate` / `populateDataLoader` has a hack/escape hatch that ignores calling\n    // RF.load(), to avoid pulling in the RF subgraph over using the materialized value, which ideally would be\n    // replaced with us learning to do the maybeDirty approach.)\n    if (!this.isLoaded || opts?.forceReload) {\n      return (this.#loadPromise ??= this.entity.em.populate(this.entity, { hint: this.loadHint } as any).then(() => {\n        this.#loadPromise = undefined;\n        this.#isLoaded = true;\n        getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n        // Wait and reset `#isCached` until inside this `then`, so that we don't have a race condition where:\n        // - two relations (us and someone else) are both passed to `em.calc`\n        // - their load hint is simpler, so their promises resolves first, and their `.get` calls our `.get`\n        // - our `.get` sees we're not loaded, but calls `fieldValue` for the existing value, and dutifully sets `#isCached=true`\n        // - finally our promise runs, and if we didn't immediately set `#isCached=false` here, our `.get` would again\n        //   early return and keep using the stale fieldValue.\n        this.resetCacheUnlessFactoryPinned();\n        // Go through `this.get` so that `setField` is called to set our latest value\n        return this.get;\n      }));\n    }\n    this.resetCacheUnlessFactoryPinned();\n    return this.get;\n  }\n\n  /** Returns either the latest calculated value (if loaded) or the previously-calculated value (if not loaded). */\n  get get(): V {\n    const { fn } = this;\n    // Some ReactiveFields can have surprisingly expensive calculations, especially in loops\n    // or those that invoke loops, so cache the value.\n    if (this.#isCached) return this.fieldValue;\n    // isLoaded will watch for our previously-loaded subgraph being mutated (isLoaded is locally cached but hooked into\n    // our IsLoadedCache cache that is immediately invalidated on write-path), and if we've drifted to not-loaded, it's\n    // better to fail and tell the user.\n    if (this.isLoaded) {\n      const newValue = fn(this.entity as Reacted<T, H>);\n      if (!getEmInternalApi(this.entity.em).isValidating) {\n        // setField will immediately invalidate downstream #isLoaded/#isCached values\n        setField(this.entity, this.fieldName, newValue);\n        this.#isCached = true;\n        getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n      }\n      return newValue;\n    } else if (this.isSet) {\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n      return this.fieldValue;\n    } else {\n      throw new Error(`${this.fieldName} has not been derived yet`);\n    }\n  }\n\n  get fieldName(): keyof T & string {\n    return this.#field.fieldName as keyof T & string;\n  }\n\n  get reactiveHint(): H {\n    return this.#reactiveHint;\n  }\n\n  get fieldValue(): V {\n    return getField(this.entity, this.fieldName);\n  }\n\n  get isSet() {\n    return isFieldSet(this.entity, this.fieldName);\n  }\n\n  get isLoaded() {\n    // Skip an expensive isLoaded(subgraph) call if no mutations have happened\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    this.#isLoaded = isLoaded(this.entity, this.loadHint);\n    getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    // Even though we reset this on every mutation, `isLoaded` will still realize when the subgraph\n    // is still loaded (as it did before we added caching), so users won't see false positive.\n    this.#isLoaded = undefined;\n    this.resetCacheUnlessFactoryPinned();\n  }\n\n  get loadHint(): any {\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.reactiveHint));\n  }\n\n  setFactoryValue(newValue: any): void {\n    setField(this.entity, this.fieldName, newValue);\n    this.#isCached = \"factory-value\";\n  }\n\n  [PropertyT] = undefined as any as T;\n\n  private resetCacheUnlessFactoryPinned(): void {\n    // If factories asked for a hard-coded value, don't reset the cached flag\n    if (this.#isCached === \"factory-value\") return;\n    this.#isCached = false;\n  }\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveField. */\nexport function isReactiveField(maybeReactiveField: any): maybeReactiveField is ReactiveField<any, any> {\n  return maybeReactiveField instanceof ReactiveFieldImpl;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoEA,SAAgB,iBACd,MACA,IACqB;CACrB,OAAO,WAAW,QAAW,cAAc;EACzC,MAAM,QAAQ,YAAY,MAAM,CAAC,CAAC,UAAU;EAC5C,OAAO,IAAI,kBAAkB,QAAQ,OAAO,MAAM,EAAE;CACtD,CAAC;AACH;AAEA,IAAa,oBAAb,cACU,qBAEV;CAYY;CAXV;CACA;CACA;CAEA;CACA,YAAuC;CAEvC,YACE,QACA,OACA,cACA,IACA;EACA,MAAM,MAAM;EAFJ,KAAA,KAAA;EAGR,KAAKA,SAAS;EACd,KAAKC,gBAAgB;CACvB;CAEA,MAAM,KAAK,MAA8C;EAOvD,IAAI,CAAC,KAAK,YAAY,MAAM,aAC1B,OAAQ,KAAKC,iBAAiB,KAAK,OAAO,GAAG,SAAS,KAAK,QAAQ,EAAE,MAAM,KAAK,SAAS,CAAQ,CAAC,CAAC,WAAW;GAC5G,KAAKA,eAAe,KAAA;GACpB,KAAKC,YAAY;GACjB,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;GAOvD,KAAK,8BAA8B;GAEnC,OAAO,KAAK;EACd,CAAC;EAEH,KAAK,8BAA8B;EACnC,OAAO,KAAK;CACd;;CAGA,IAAI,MAAS;EACX,MAAM,EAAE,OAAO;EAGf,IAAI,KAAKC,WAAW,OAAO,KAAK;EAIhC,IAAI,KAAK,UAAU;GACjB,MAAM,WAAW,GAAG,KAAK,MAAuB;GAChD,IAAI,CAAC,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc;IAElD,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;IAC9C,KAAKA,YAAY;IACjB,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;GACzD;GACA,OAAO;EACT,OAAO,IAAI,KAAK,OAAO;GACrB,KAAKA,YAAY;GACjB,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;GACvD,OAAO,KAAK;EACd,OACE,MAAM,IAAI,MAAM,GAAG,KAAK,UAAU,0BAA0B;CAEhE;CAEA,IAAI,YAA8B;EAChC,OAAO,KAAKJ,OAAO;CACrB;CAEA,IAAI,eAAkB;EACpB,OAAO,KAAKC;CACd;CAEA,IAAI,aAAgB;EAClB,OAAO,SAAS,KAAK,QAAQ,KAAK,SAAS;CAC7C;CAEA,IAAI,QAAQ;EACV,OAAO,WAAW,KAAK,QAAQ,KAAK,SAAS;CAC/C;CAEA,IAAI,WAAW;EAEb,IAAI,KAAKE,cAAc,KAAA,GAAW,OAAO,KAAKA;EAC9C,KAAKA,YAAY,SAAS,KAAK,QAAQ,KAAK,QAAQ;EACpD,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;EACvD,OAAO,KAAKA;CACd;CAEA,gBAAsB;EAGpB,KAAKA,YAAY,KAAA;EACjB,KAAK,8BAA8B;CACrC;CAEA,IAAI,WAAgB;EAClB,MAAM,OAAO,YAAY,KAAK,MAAM;EACpC,OAAQ,KAAK,OAAO,OAAO,wBAAwB,KAAK,eAAe,kBAAkB,MAAM,KAAK,YAAY;CAClH;CAEA,gBAAgB,UAAqB;EACnC,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;EAC9C,KAAKC,YAAY;CACnB;CAEA,CAAC,aAAa,KAAA;CAEd,gCAA8C;EAE5C,IAAI,KAAKA,cAAc,iBAAiB;EACxC,KAAKA,YAAY;CACnB;AACF;;AAGA,SAAgB,gBAAgB,oBAAwE;CACtG,OAAO,8BAA8B;AACvC"}
+{"version":3,"file":"ReactiveField.js","names":["#field","#reactiveHint","#loadPromise","#isLoaded","#isCached"],"sources":["../../src/relations/ReactiveField.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { getEmInternalApi } from \"../EntityManager.ts\";\nimport { type PrimitiveField, getMetadata } from \"../EntityMetadata.ts\";\nimport { getField, isFieldSet, setField } from \"../fields.ts\";\nimport { isLoaded } from \"../index.ts\";\nimport type { IsLoadedCachable } from \"../loading/IsLoadedCache.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { type Reacted, type ReactiveHint, convertToLoadHint } from \"../reactivity/reactiveHints.ts\";\nimport { AbstractPropertyImpl } from \"./AbstractPropertyImpl.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\n\n/**\n * A `ReactiveField` is a value that is derived from other entities/values,\n * similar to a `Property`, but it is also persisted in the database.\n *\n * This allows callers (or SQL queries) to access the value without first calling\n * `await load()` on the property.\n *\n * So, unlike `Property`, `.get` is always available; if the property is unloaded,\n * then `.get` will return the last-calculated value, but if the property is loaded,\n * then it will go ahead and invoke function to calculate the latest value (i.e. so\n * that you can observe the latest & greatest value w/o waiting for `em.flush` to\n * re-calc the value while persisting to the database.\n */\nexport interface ReactiveField<T extends Entity, V> {\n  [PropertyT]: T;\n  isLoaded: boolean;\n  isSet: boolean;\n\n  /**\n   * Calculates the latest derived value.\n   *\n   * Users are not required to call this method explicitly, as Joist will keep the\n   * persisted value automatically in-sync, but if for some reason (code changes,\n   * bug fixes, etc.) you need to trigger an explicit recalc, you can call `.load()`,\n   * any dependent data will be loaded from the database, and the latest value\n   * returned, and then later stored to the database on `em.flush`.\n   *\n   * Note that persisted properties used in load hints, i.e. `em.populate`s that\n   * accidentally list reactive fields (instead of just relations) will not have\n   * `.load()` invoked, and will instead use the previously-calculated value.\n   * The rationale is that one persisted property should be able to declare its\n   * dependency on another persisted property (for its reactive field-level hint)\n   * without causing that dependent property's populate hint to itself be loaded.\n   */\n  load(opts?: { forceReload?: boolean }): Promise<V>;\n\n  /** If loaded, returns the latest derived value, or if unload returns the previously-calculated value. */\n  get: V;\n\n  /**\n   * Returns the as-of-last-flush previously-calculated value.\n   *\n   * This is useful if you have to purposefully avoid using the lambda to calc the latest value,\n   * i.e. if you're in a test and want to watch a calculated value change from some dummy value\n   * to the new derived value.\n   * */\n  fieldValue: 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 hasReactiveField<T extends Entity, const H extends ReactiveHint<T>, V>(\n  hint: H,\n  fn: (entity: Reacted<T, H>) => V,\n): ReactiveField<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    const field = getMetadata(entity).allFields[fieldName] as PrimitiveField;\n    return new ReactiveFieldImpl(entity, field, hint, fn);\n  });\n}\n\nexport class ReactiveFieldImpl<T extends Entity, H extends ReactiveHint<T>, V>\n  extends AbstractPropertyImpl<T>\n  implements ReactiveField<T, V>, IsLoadedCachable\n{\n  readonly #field: PrimitiveField;\n  readonly #reactiveHint: H;\n  #loadPromise: any;\n  // Initially undefined, then cached as true/false\n  #isLoaded: boolean | undefined;\n  #isCached: boolean | \"factory-value\" = false;\n\n  constructor(\n    entity: T,\n    field: PrimitiveField,\n    reactiveHint: H,\n    private fn: (entity: Reacted<T, H>) => V,\n  ) {\n    super(entity);\n    this.#field = field;\n    this.#reactiveHint = reactiveHint;\n  }\n\n  async load(opts?: { forceReload?: boolean }): Promise<V> {\n    // Even without `forceReload=true`, any explicit calls to `.load()` ==> ensure a fresh value,\n    // because `.get` may have cached the stale/previously-calculated value.\n    //\n    // (Currently `em.populate` / `populateDataLoader` has a hack/escape hatch that ignores calling\n    // RF.load(), to avoid pulling in the RF subgraph over using the materialized value, which ideally would be\n    // replaced with us learning to do the maybeDirty approach.)\n    if (!this.isLoaded || opts?.forceReload) {\n      return (this.#loadPromise ??= this.entity.em.populate(this.entity, { hint: this.loadHint } as any).then(() => {\n        this.#loadPromise = undefined;\n        this.#isLoaded = true;\n        getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n        // Wait and reset `#isCached` until inside this `then`, so that we don't have a race condition where:\n        // - two relations (us and someone else) are both passed to `em.calc`\n        // - their load hint is simpler, so their promises resolves first, and their `.get` calls our `.get`\n        // - our `.get` sees we're not loaded, but calls `fieldValue` for the existing value, and dutifully sets `#isCached=true`\n        // - finally our promise runs, and if we didn't immediately set `#isCached=false` here, our `.get` would again\n        //   early return and keep using the stale fieldValue.\n        this.resetCacheUnlessFactoryPinned();\n        // Go through `this.get` so that `setField` is called to set our latest value\n        return this.get;\n      }));\n    }\n    this.resetCacheUnlessFactoryPinned();\n    return this.get;\n  }\n\n  /** Returns either the latest calculated value (if loaded) or the previously-calculated value (if not loaded). */\n  get get(): V {\n    const { fn } = this;\n    // Some ReactiveFields can have surprisingly expensive calculations, especially in loops\n    // or those that invoke loops, so cache the value.\n    if (this.#isCached) return this.fieldValue;\n    // isLoaded will watch for our previously-loaded subgraph being mutated (isLoaded is locally cached but hooked into\n    // our IsLoadedCache cache that is immediately invalidated on write-path), and if we've drifted to not-loaded, it's\n    // better to fail and tell the user.\n    if (this.isLoaded) {\n      const newValue = fn(this.entity as Reacted<T, H>);\n      if (!getEmInternalApi(this.entity.em).isValidating) {\n        // setField will immediately invalidate downstream #isLoaded/#isCached values\n        setField(this.entity, this.fieldName, newValue);\n        this.#isCached = true;\n        getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n      }\n      return newValue;\n    } else if (this.isSet) {\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n      return this.fieldValue;\n    } else {\n      throw new Error(`${this.fieldName} has not been derived yet`);\n    }\n  }\n\n  get fieldName(): keyof T & string {\n    return this.#field.fieldName as keyof T & string;\n  }\n\n  get reactiveHint(): H {\n    return this.#reactiveHint;\n  }\n\n  get fieldValue(): V {\n    return getField(this.entity, this.fieldName);\n  }\n\n  get isSet() {\n    return isFieldSet(this.entity, this.fieldName);\n  }\n\n  get isLoaded() {\n    // Skip an expensive isLoaded(subgraph) call if no mutations have happened\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    this.#isLoaded = isLoaded(this.entity, this.loadHint);\n    getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    // Even though we reset this on every mutation, `isLoaded` will still realize when the subgraph\n    // is still loaded (as it did before we added caching), so users won't see false positive.\n    this.#isLoaded = undefined;\n    this.resetCacheUnlessFactoryPinned();\n  }\n\n  get loadHint(): any {\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.reactiveHint));\n  }\n\n  setFactoryValue(newValue: any): void {\n    setField(this.entity, this.fieldName, newValue);\n    this.#isCached = \"factory-value\";\n  }\n\n  [PropertyT] = undefined as any as T;\n\n  private resetCacheUnlessFactoryPinned(): void {\n    // If factories asked for a hard-coded value, don't reset the cached flag\n    if (this.#isCached === \"factory-value\") return;\n    this.#isCached = false;\n  }\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveField. */\nexport function isReactiveField(maybeReactiveField: any): maybeReactiveField is ReactiveField<any, any> {\n  return maybeReactiveField instanceof ReactiveFieldImpl;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoEA,SAAgB,iBACd,MACA,IACqB;CACrB,OAAO,WAAW,QAAW,cAAc;EACzC,MAAM,QAAQ,YAAY,MAAM,CAAC,CAAC,UAAU;EAC5C,OAAO,IAAI,kBAAkB,QAAQ,OAAO,MAAM,EAAE;CACtD,CAAC;AACH;AAEA,IAAa,oBAAb,cACU,qBAEV;CAYY;CAXV;CACA;CACA;CAEA;CACA,YAAuC;CAEvC,YACE,QACA,OACA,cACA,IACA;EACA,MAAM,MAAM;EAFJ,KAAA,KAAA;EAGR,KAAKA,SAAS;EACd,KAAKC,gBAAgB;CACvB;CAEA,MAAM,KAAK,MAA8C;EAOvD,IAAI,CAAC,KAAK,YAAY,MAAM,aAC1B,OAAQ,KAAKC,iBAAiB,KAAK,OAAO,GAAG,SAAS,KAAK,QAAQ,EAAE,MAAM,KAAK,SAAS,CAAQ,CAAC,CAAC,WAAW;GAC5G,KAAKA,eAAe,KAAA;GACpB,KAAKC,YAAY;GACjB,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;GAOvD,KAAK,8BAA8B;GAEnC,OAAO,KAAK;EACd,CAAC;EAEH,KAAK,8BAA8B;EACnC,OAAO,KAAK;CACd;;CAGA,IAAI,MAAS;EACX,MAAM,EAAE,OAAO;EAGf,IAAI,KAAKC,WAAW,OAAO,KAAK;EAIhC,IAAI,KAAK,UAAU;GACjB,MAAM,WAAW,GAAG,KAAK,MAAuB;GAChD,IAAI,CAAC,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc;IAElD,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;IAC9C,KAAKA,YAAY;IACjB,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;GACzD;GACA,OAAO;EACT,OAAO,IAAI,KAAK,OAAO;GACrB,KAAKA,YAAY;GACjB,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;GACvD,OAAO,KAAK;EACd,OACE,MAAM,IAAI,MAAM,GAAG,KAAK,UAAU,0BAA0B;CAEhE;CAEA,IAAI,YAA8B;EAChC,OAAO,KAAKJ,OAAO;CACrB;CAEA,IAAI,eAAkB;EACpB,OAAO,KAAKC;CACd;CAEA,IAAI,aAAgB;EAClB,OAAO,SAAS,KAAK,QAAQ,KAAK,SAAS;CAC7C;CAEA,IAAI,QAAQ;EACV,OAAO,WAAW,KAAK,QAAQ,KAAK,SAAS;CAC/C;CAEA,IAAI,WAAW;EAEb,IAAI,KAAKE,cAAc,KAAA,GAAW,OAAO,KAAKA;EAC9C,KAAKA,YAAY,SAAS,KAAK,QAAQ,KAAK,QAAQ;EACpD,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI;EACvD,OAAO,KAAKA;CACd;CAEA,gBAAsB;EAGpB,KAAKA,YAAY,KAAA;EACjB,KAAK,8BAA8B;CACrC;CAEA,IAAI,WAAgB;EAClB,MAAM,OAAO,YAAY,KAAK,MAAM;EACpC,OAAQ,KAAK,OAAO,OAAO,wBAAwB,KAAK,eAAe,kBAAkB,MAAM,KAAK,YAAY;CAClH;CAEA,gBAAgB,UAAqB;EACnC,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;EAC9C,KAAKC,YAAY;CACnB;CAEA,CAAC,aAAa,KAAA;CAEd,gCAA8C;EAE5C,IAAI,KAAKA,cAAc,iBAAiB;EACxC,KAAKA,YAAY;CACnB;AACF;;AAGA,SAAgB,gBAAgB,oBAAwE;CACtG,OAAO,8BAA8B;AACvC"}

package/build/relations/ReactiveGetter.cjs

@@ -1,6 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_relations_PropertySymbols = require("./PropertySymbols.cjs");
-require("../reactiveHints.cjs");
 const require_newEntity = require("../newEntity.cjs");
 require("../Entity.cjs");
 //#region src/relations/ReactiveGetter.ts

package/build/relations/ReactiveGetter.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveGetter.cjs","names":["lazyField","#entity","#fieldName","#hint","#fn","PropertyT"],"sources":["../../src/relations/ReactiveGetter.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { type Reacted, type ShallowReactiveHint } from \"../reactiveHints.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\n\n/**\n * A `ReactiveGetter` is a getter that declares what primitive fields it depends on.\n *\n * This is very similar to a `ReactiveProperty`, except because it's limited to\n * only immediate fields on the entity, it can always have `.get` called, and doesn't\n * need to be loaded.\n *\n * The benefit over a pure getter is that `ReactiveGetter` can be used in reactive\n * rules and reactive fields, which would otherwise need to use `fullNonReactiveAccess`\n * to access getter, and risk missing reactivity.\n */\nexport interface ReactiveGetter<T extends Entity, V> {\n  [PropertyT]: T;\n  get: V;\n}\n\n/** Creates a `ReactiveGetter`, for simple \"getters\" that still trackable for reactivity. */\nexport function hasReactiveGetter<T extends Entity, const H extends ShallowReactiveHint<T>, V>(\n  fieldName: keyof T & string,\n  hint: H,\n  fn: (entity: Reacted<T, H>) => V,\n): ReactiveGetter<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new ReactiveGetterImpl(entity, fieldName as keyof T & string, hint, fn);\n  });\n}\n\nexport class ReactiveGetterImpl<T extends Entity, const H extends ShallowReactiveHint<T>, V> implements ReactiveGetter<\n  T,\n  V\n> {\n  readonly #entity: T;\n  readonly #fieldName: keyof T & string;\n  readonly #hint: H;\n  readonly #fn: (entity: Reacted<T, H>) => V;\n\n  constructor(entity: T, fieldName: keyof T & string, hint: H, fn: (entity: Reacted<T, H>) => V) {\n    this.#entity = entity;\n    this.#fieldName = fieldName;\n    this.#hint = hint;\n    this.#fn = fn;\n  }\n\n  get get(): V {\n    return this.#fn(this.#entity as any);\n  }\n\n  get reactiveHint(): H {\n    return this.#hint;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveGetter. */\nexport function isReactiveGetter(maybeReactiveGetter: any): maybeReactiveGetter is ReactiveGetter<any, any> {\n  return maybeReactiveGetter instanceof ReactiveGetterImpl;\n}\n"],"mappings":";;;;;;;AAsBA,SAAgB,kBACd,WACA,MACA,IACsB;CACtB,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,mBAAmB,QAAQ,WAA+B,MAAM,EAAE;CAC/E,CAAC;AACH;AAEA,IAAa,qBAAb,MAGE;CACA;CACA;CACA;CACA;CAEA,YAAY,QAAW,WAA6B,MAAS,IAAkC;EAC7F,KAAKC,UAAU;EACf,KAAKC,aAAa;EAClB,KAAKC,QAAQ;EACb,KAAKC,MAAM;CACb;CAEA,IAAI,MAAS;EACX,OAAO,KAAKA,IAAI,KAAKH,OAAc;CACrC;CAEA,IAAI,eAAkB;EACpB,OAAO,KAAKE;CACd;CAEA,CAACE,kCAAAA,aAAa,KAAA;AAChB;;AAGA,SAAgB,iBAAiB,qBAA2E;CAC1G,OAAO,+BAA+B;AACxC"}
+{"version":3,"file":"ReactiveGetter.cjs","names":["lazyField","#entity","#fieldName","#hint","#fn","PropertyT"],"sources":["../../src/relations/ReactiveGetter.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport type { Reacted, ShallowReactiveHint } from \"../reactivity/reactiveHints.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\n\n/**\n * A `ReactiveGetter` is a getter that declares what primitive fields it depends on.\n *\n * This is very similar to a `ReactiveProperty`, except because it's limited to\n * only immediate fields on the entity, it can always have `.get` called, and doesn't\n * need to be loaded.\n *\n * The benefit over a pure getter is that `ReactiveGetter` can be used in reactive\n * rules and reactive fields, which would otherwise need to use `fullNonReactiveAccess`\n * to access getter, and risk missing reactivity.\n */\nexport interface ReactiveGetter<T extends Entity, V> {\n  [PropertyT]: T;\n  get: V;\n}\n\n/** Creates a `ReactiveGetter`, for simple \"getters\" that still trackable for reactivity. */\nexport function hasReactiveGetter<T extends Entity, const H extends ShallowReactiveHint<T>, V>(\n  fieldName: keyof T & string,\n  hint: H,\n  fn: (entity: Reacted<T, H>) => V,\n): ReactiveGetter<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new ReactiveGetterImpl(entity, fieldName as keyof T & string, hint, fn);\n  });\n}\n\nexport class ReactiveGetterImpl<T extends Entity, const H extends ShallowReactiveHint<T>, V> implements ReactiveGetter<\n  T,\n  V\n> {\n  readonly #entity: T;\n  readonly #fieldName: keyof T & string;\n  readonly #hint: H;\n  readonly #fn: (entity: Reacted<T, H>) => V;\n\n  constructor(entity: T, fieldName: keyof T & string, hint: H, fn: (entity: Reacted<T, H>) => V) {\n    this.#entity = entity;\n    this.#fieldName = fieldName;\n    this.#hint = hint;\n    this.#fn = fn;\n  }\n\n  get get(): V {\n    return this.#fn(this.#entity as any);\n  }\n\n  get reactiveHint(): H {\n    return this.#hint;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveGetter. */\nexport function isReactiveGetter(maybeReactiveGetter: any): maybeReactiveGetter is ReactiveGetter<any, any> {\n  return maybeReactiveGetter instanceof ReactiveGetterImpl;\n}\n"],"mappings":";;;;;;AAsBA,SAAgB,kBACd,WACA,MACA,IACsB;CACtB,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,mBAAmB,QAAQ,WAA+B,MAAM,EAAE;CAC/E,CAAC;AACH;AAEA,IAAa,qBAAb,MAGE;CACA;CACA;CACA;CACA;CAEA,YAAY,QAAW,WAA6B,MAAS,IAAkC;EAC7F,KAAKC,UAAU;EACf,KAAKC,aAAa;EAClB,KAAKC,QAAQ;EACb,KAAKC,MAAM;CACb;CAEA,IAAI,MAAS;EACX,OAAO,KAAKA,IAAI,KAAKH,OAAc;CACrC;CAEA,IAAI,eAAkB;EACpB,OAAO,KAAKE;CACd;CAEA,CAACE,kCAAAA,aAAa,KAAA;AAChB;;AAGA,SAAgB,iBAAiB,qBAA2E;CAC1G,OAAO,+BAA+B;AACxC"}

package/build/relations/ReactiveGetter.d.cts

@@ -1,5 +1,5 @@
 import { PropertyT } from "./PropertySymbols.cjs";
-import { Reacted, ShallowReactiveHint } from "../reactiveHints.cjs";
+import { Reacted, ShallowReactiveHint } from "../reactivity/reactiveHints.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/ReactiveGetter.d.ts
 /**

package/build/relations/ReactiveGetter.d.mts

@@ -1,5 +1,5 @@
 import { PropertyT } from "./PropertySymbols.mjs";
-import { Reacted, ShallowReactiveHint } from "../reactiveHints.mjs";
+import { Reacted, ShallowReactiveHint } from "../reactivity/reactiveHints.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/ReactiveGetter.d.ts
 /**

package/build/relations/ReactiveGetter.js

@@ -1,5 +1,4 @@
 import { PropertyT } from "./PropertySymbols.js";
-import "../reactiveHints.js";
 import { lazyField } from "../newEntity.js";
 import "../Entity.js";
 //#region src/relations/ReactiveGetter.ts

package/build/relations/ReactiveGetter.js.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveGetter.js","names":["#entity","#fieldName","#hint","#fn"],"sources":["../../src/relations/ReactiveGetter.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { type Reacted, type ShallowReactiveHint } from \"../reactiveHints.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\n\n/**\n * A `ReactiveGetter` is a getter that declares what primitive fields it depends on.\n *\n * This is very similar to a `ReactiveProperty`, except because it's limited to\n * only immediate fields on the entity, it can always have `.get` called, and doesn't\n * need to be loaded.\n *\n * The benefit over a pure getter is that `ReactiveGetter` can be used in reactive\n * rules and reactive fields, which would otherwise need to use `fullNonReactiveAccess`\n * to access getter, and risk missing reactivity.\n */\nexport interface ReactiveGetter<T extends Entity, V> {\n  [PropertyT]: T;\n  get: V;\n}\n\n/** Creates a `ReactiveGetter`, for simple \"getters\" that still trackable for reactivity. */\nexport function hasReactiveGetter<T extends Entity, const H extends ShallowReactiveHint<T>, V>(\n  fieldName: keyof T & string,\n  hint: H,\n  fn: (entity: Reacted<T, H>) => V,\n): ReactiveGetter<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new ReactiveGetterImpl(entity, fieldName as keyof T & string, hint, fn);\n  });\n}\n\nexport class ReactiveGetterImpl<T extends Entity, const H extends ShallowReactiveHint<T>, V> implements ReactiveGetter<\n  T,\n  V\n> {\n  readonly #entity: T;\n  readonly #fieldName: keyof T & string;\n  readonly #hint: H;\n  readonly #fn: (entity: Reacted<T, H>) => V;\n\n  constructor(entity: T, fieldName: keyof T & string, hint: H, fn: (entity: Reacted<T, H>) => V) {\n    this.#entity = entity;\n    this.#fieldName = fieldName;\n    this.#hint = hint;\n    this.#fn = fn;\n  }\n\n  get get(): V {\n    return this.#fn(this.#entity as any);\n  }\n\n  get reactiveHint(): H {\n    return this.#hint;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveGetter. */\nexport function isReactiveGetter(maybeReactiveGetter: any): maybeReactiveGetter is ReactiveGetter<any, any> {\n  return maybeReactiveGetter instanceof ReactiveGetterImpl;\n}\n"],"mappings":";;;;;;AAsBA,SAAgB,kBACd,WACA,MACA,IACsB;CACtB,OAAO,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,mBAAmB,QAAQ,WAA+B,MAAM,EAAE;CAC/E,CAAC;AACH;AAEA,IAAa,qBAAb,MAGE;CACA;CACA;CACA;CACA;CAEA,YAAY,QAAW,WAA6B,MAAS,IAAkC;EAC7F,KAAKA,UAAU;EACf,KAAKC,aAAa;EAClB,KAAKC,QAAQ;EACb,KAAKC,MAAM;CACb;CAEA,IAAI,MAAS;EACX,OAAO,KAAKA,IAAI,KAAKH,OAAc;CACrC;CAEA,IAAI,eAAkB;EACpB,OAAO,KAAKE;CACd;CAEA,CAAC,aAAa,KAAA;AAChB;;AAGA,SAAgB,iBAAiB,qBAA2E;CAC1G,OAAO,+BAA+B;AACxC"}
+{"version":3,"file":"ReactiveGetter.js","names":["#entity","#fieldName","#hint","#fn"],"sources":["../../src/relations/ReactiveGetter.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport type { Reacted, ShallowReactiveHint } from \"../reactivity/reactiveHints.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\n\n/**\n * A `ReactiveGetter` is a getter that declares what primitive fields it depends on.\n *\n * This is very similar to a `ReactiveProperty`, except because it's limited to\n * only immediate fields on the entity, it can always have `.get` called, and doesn't\n * need to be loaded.\n *\n * The benefit over a pure getter is that `ReactiveGetter` can be used in reactive\n * rules and reactive fields, which would otherwise need to use `fullNonReactiveAccess`\n * to access getter, and risk missing reactivity.\n */\nexport interface ReactiveGetter<T extends Entity, V> {\n  [PropertyT]: T;\n  get: V;\n}\n\n/** Creates a `ReactiveGetter`, for simple \"getters\" that still trackable for reactivity. */\nexport function hasReactiveGetter<T extends Entity, const H extends ShallowReactiveHint<T>, V>(\n  fieldName: keyof T & string,\n  hint: H,\n  fn: (entity: Reacted<T, H>) => V,\n): ReactiveGetter<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new ReactiveGetterImpl(entity, fieldName as keyof T & string, hint, fn);\n  });\n}\n\nexport class ReactiveGetterImpl<T extends Entity, const H extends ShallowReactiveHint<T>, V> implements ReactiveGetter<\n  T,\n  V\n> {\n  readonly #entity: T;\n  readonly #fieldName: keyof T & string;\n  readonly #hint: H;\n  readonly #fn: (entity: Reacted<T, H>) => V;\n\n  constructor(entity: T, fieldName: keyof T & string, hint: H, fn: (entity: Reacted<T, H>) => V) {\n    this.#entity = entity;\n    this.#fieldName = fieldName;\n    this.#hint = hint;\n    this.#fn = fn;\n  }\n\n  get get(): V {\n    return this.#fn(this.#entity as any);\n  }\n\n  get reactiveHint(): H {\n    return this.#hint;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveGetter. */\nexport function isReactiveGetter(maybeReactiveGetter: any): maybeReactiveGetter is ReactiveGetter<any, any> {\n  return maybeReactiveGetter instanceof ReactiveGetterImpl;\n}\n"],"mappings":";;;;;AAsBA,SAAgB,kBACd,WACA,MACA,IACsB;CACtB,OAAO,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,mBAAmB,QAAQ,WAA+B,MAAM,EAAE;CAC/E,CAAC;AACH;AAEA,IAAa,qBAAb,MAGE;CACA;CACA;CACA;CACA;CAEA,YAAY,QAAW,WAA6B,MAAS,IAAkC;EAC7F,KAAKA,UAAU;EACf,KAAKC,aAAa;EAClB,KAAKC,QAAQ;EACb,KAAKC,MAAM;CACb;CAEA,IAAI,MAAS;EACX,OAAO,KAAKA,IAAI,KAAKH,OAAc;CACrC;CAEA,IAAI,eAAkB;EACpB,OAAO,KAAKE;CACd;CAEA,CAAC,aAAa,KAAA;AAChB;;AAGA,SAAgB,iBAAiB,qBAA2E;CAC1G,OAAO,+BAA+B;AACxC"}

package/build/relations/ReactiveManyToMany.cjs

@@ -1,13 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_relations_AbstractRelationImpl = require("./AbstractRelationImpl.cjs");
 const require_relations_RelationSymbols = require("./RelationSymbols.cjs");
+const require_reactivity_reactiveHints = require("../reactivity/reactiveHints.cjs");
+const require_loading_loadHints = require("../loading/loadHints.cjs");
+const require_batchloaders_manyToManyBatchLoader = require("../batchloaders/manyToManyBatchLoader.cjs");
 const require_relations_isCascadeDelete = require("./isCascadeDelete.cjs");
-require("../IsLoadedCache.cjs");
-const require_reactiveHints = require("../reactiveHints.cjs");
-const require_loadHints = require("../loadHints.cjs");
 const require_utils = require("../utils.cjs");
 const require_newEntity = require("../newEntity.cjs");
-const require_batchloaders_manyToManyBatchLoader = require("../batchloaders/manyToManyBatchLoader.cjs");
 const require_EntityMetadata = require("../EntityMetadata.cjs");
 const require_index = require("../index.cjs");
 const require_EntityManager = require("../EntityManager.cjs");
@@ -70,7 +69,7 @@ var ReactiveManyToManyImpl = class extends require_relations_AbstractRelationImp
 		require_EntityManager.getEmInternalApi(this.entity.em).isLoadedCache.add(this);
 		if (require_EntityManager.getEmInternalApi(this.entity.em).rm.isMaybePendingRecalc(this.entity, this.fieldName)) {
 			this.#loadedMode = "full";
-			this.#isLoaded = require_loadHints.isLoaded(this.entity, this.loadHint);
+			this.#isLoaded = require_loading_loadHints.isLoaded(this.entity, this.loadHint);
 			this.#isCached = false;
 		} else this.#isLoaded = !!this.#loadedMode;
 		return this.#isLoaded;
@@ -111,7 +110,7 @@ var ReactiveManyToManyImpl = class extends require_relations_AbstractRelationImp
 	}
 	get loadHint() {
 		const meta = require_EntityMetadata.getMetadata(this.entity);
-		return meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= require_reactiveHints.convertToLoadHint(meta, this.reactiveHint);
+		return meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= require_reactivity_reactiveHints.convertToLoadHint(meta, this.reactiveHint);
 	}
 	setFromOpts(_others) {
 		throw new Error(`ReactiveManyToMany ${this.entity}.${this.fieldName} cannot be set via opts`);

package/build/relations/ReactiveManyToMany.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveManyToMany.cjs","names":["lazyField","getMetadata","AbstractRelationImpl","#field","getEmInternalApi","#isCached","#loadPromise","#loadedMode","#isLoaded","#doGet","#loadFromJoinTable","#loaded","#filterDeleted","isLoaded","#syncJoinTableRows","convertToLoadHint","#isCascadeDelete","getMetadataForField","isCascadeDelete","manyToManyBatchLoader","RelationT","RelationU"],"sources":["../../src/relations/ReactiveManyToMany.ts"],"sourcesContent":["import { manyToManyBatchLoader } from \"../batchloaders/manyToManyBatchLoader.ts\";\nimport {\n  type Entity,\n  type EntityMetadata,\n  type ManyToManyField,\n  type ReadOnlyCollection,\n  ensureNotDeleted,\n  fail,\n  getEmInternalApi,\n  getInstanceData,\n  getMetadata,\n  getMetadataForField,\n  isLoaded,\n} from \"../index.ts\";\nimport { type IsLoadedCachable } from \"../IsLoadedCache.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { type MaybeReactedEntity, type Reacted, type ReactiveHint, convertToLoadHint } from \"../reactiveHints.ts\";\nimport { AbstractRelationImpl } from \"./AbstractRelationImpl.ts\";\nimport { isCascadeDelete } from \"./isCascadeDelete.ts\";\nimport { RelationT, RelationU } from \"./RelationSymbols.ts\";\n\n/**\n * A reactive, derived many-to-many collection.\n *\n * Similar to `ReactiveReference` but for collections--membership is calculated from a reactive\n * function and persisted to the underlying join table.\n */\nexport interface ReactiveManyToMany<T extends Entity, U extends Entity> extends ReadOnlyCollection<T, U> {\n  load(opts?: { withDeleted?: boolean; forceReload?: boolean }): Promise<readonly U[]>;\n}\n\n/** Creates a `ReactiveManyToMany`. */\nexport function hasReactiveManyToMany<T extends Entity, U extends Entity, const H extends ReactiveHint<T>>(\n  hint: H,\n  fn: (entity: Reacted<T, H>) => readonly MaybeReactedEntity<U>[],\n): ReactiveManyToMany<T, U> {\n  return lazyField((entity: T, fieldName) => {\n    const m2m = getMetadata(entity).allFields[fieldName] as ManyToManyField;\n    return new ReactiveManyToManyImpl<T, U, H>(entity, m2m, hint, fn);\n  });\n}\n\n/** Implements ReactiveManyToMany, initially a copy/paste of ReactiveReference but for m2m. */\nexport class ReactiveManyToManyImpl<T extends Entity, U extends Entity, H extends ReactiveHint<T>>\n  extends AbstractRelationImpl<T, U[]>\n  implements ReactiveManyToMany<T, U>, IsLoadedCachable\n{\n  readonly #field: ManyToManyField;\n\n  // Could be either the ref-loaded stored array, or full-loaded calculated array\n  #loaded: U[] | undefined;\n  // In ref-mode, we use our materialized FK value (which might be undefined)\n  // If full-mode, we calculate the FK value from the subgraph\n  #loadedMode: \"ref\" | \"full\" | undefined = undefined;\n  // #isLoaded doesn't necessary care if we're ref-mode or full-mode, it's just\n  // whether a caller can call `.get` and not have it blow up.\n  #isLoaded: boolean | undefined = undefined;\n  #isCached: boolean = false;\n  #loadPromise: Promise<ReadonlyArray<U>> | undefined;\n\n  constructor(\n    entity: T,\n    field: ManyToManyField,\n    public reactiveHint: H,\n    private fn: (entity: Reacted<T, H>) => readonly MaybeReactedEntity<U>[],\n  ) {\n    super(entity);\n    this.#field = field;\n    (getInstanceData(entity).relations ??= {})[this.fieldName] = this;\n  }\n\n  async load(opts?: { withDeleted?: boolean; forceReload?: boolean }): Promise<ReadonlyArray<U>> {\n    ensureNotDeleted(this.entity, \"pending\");\n    const { loadHint } = this;\n\n    if (!this.isLoaded || opts?.forceReload) {\n      const { em } = this.entity;\n      const maybeDirty = opts?.forceReload || getEmInternalApi(em).rm.isMaybePendingRecalc(this.entity, this.fieldName);\n\n      if (maybeDirty) {\n        this.#isCached = false;\n        return (this.#loadPromise ??= em.populate(this.entity, { hint: loadHint, ...opts }).then(() => {\n          this.#loadPromise = undefined;\n          this.#loadedMode = \"full\";\n          this.#isLoaded = true;\n          getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n          return this.#doGet(opts);\n        }));\n      } else {\n        // Load from join table (existing materialized state)\n        return (this.#loadPromise ??= this.#loadFromJoinTable().then((loaded) => {\n          this.#loadPromise = undefined;\n          this.#loadedMode = \"ref\";\n          this.#isLoaded = true;\n          this.#loaded = loaded;\n          getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n          return this.#filterDeleted(loaded, opts);\n        }));\n      }\n    }\n    return this.#doGet(opts);\n  }\n\n  get isLoaded(): boolean {\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    // If a WIP mutation has marked our field as potentially dirty, we need to be \"full\" loaded\n    const maybeDirty = getEmInternalApi(this.entity.em).rm.isMaybePendingRecalc(this.entity, this.fieldName);\n    if (maybeDirty) {\n      // If we're dirty, only being \"full\" loaded is good enough to recalc\n      this.#loadedMode = \"full\";\n      this.#isLoaded = isLoaded(this.entity, this.loadHint);\n      this.#isCached = false;\n    } else {\n      // If we've had `.load` called before, assume we're still loaded\n      this.#isLoaded = !!this.#loadedMode;\n    }\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n    this.#isCached = false;\n  }\n\n  #doGet(opts?: { withDeleted?: boolean }): U[] {\n    const { fn } = this;\n    ensureNotDeleted(this.entity, \"pending\");\n    // Fast pass if we've already calculated this (cache invalidation will happen on\n    // any mutation via #resetIsLoaded)..\n    if (this.#isCached) {\n      return this.#filterDeleted(this.#loaded ?? [], opts) as U[];\n    }\n    // Call isLoaded to probe the load hint, and get `#isLoaded` set, but still have\n    // our `if` check the raw `#isLoaded` to know if we should eval-latest or return `loaded`.\n    if (this.isLoaded && this.#loadedMode === \"full\") {\n      const newValue = fn(this.entity as any) as unknown as U[];\n      // Preserve deleted entities that were in the previous loaded value\n      const previousDeleted = (this.#loaded ?? []).filter((e) => e.isDeletedEntity);\n      for (const entity of previousDeleted) {\n        if (!newValue.includes(entity)) newValue.push(entity);\n      }\n      if (!getEmInternalApi(this.entity.em).isValidating) {\n        this.#syncJoinTableRows(newValue);\n      }\n      this.#loaded = newValue;\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    } else if (!!this.#loadedMode) {\n      // We're either loadedMode=ref, or loadedMode=full (but not actually fully loaded),\n      // but in theory loadedMode only gets set in `.load()`, so we should have #loaded\n      // set to some value, even if it's not fully up-to-date.\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    } else {\n      const noun = this.entity.isNewEntity ? \"derived\" : \"loaded\";\n      throw new Error(`${this.entity}.${this.fieldName} has not been ${noun} yet`);\n    }\n    return this.#filterDeleted(this.#loaded ?? [], opts) as U[];\n  }\n\n  get getWithDeleted(): U[] {\n    return this.#doGet({ withDeleted: true });\n  }\n\n  get get(): U[] {\n    return this.#doGet({ withDeleted: false });\n  }\n\n  set(): void {\n    fail(`Cannot set ${this.entity}.${this.fieldName} ReactiveManyToMany directly.`);\n  }\n\n  get loadHint(): any {\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.reactiveHint));\n  }\n\n  setFromOpts(_others: U[]): void {\n    throw new Error(`ReactiveManyToMany ${this.entity}.${this.fieldName} cannot be set via opts`);\n  }\n\n  maybeCascadeDelete(): void {\n    if (this.#isCascadeDelete) {\n      const jr = getEmInternalApi(this.entity.em).joinRows(this);\n      (jr.getOthers(this.columnName, this.entity) as U[]).forEach((e) => this.entity.em.delete(e));\n    }\n  }\n\n  async cleanupOnEntityDeleted(): Promise<void> {\n    const existing = await this.load({ withDeleted: true });\n    const jr = getEmInternalApi(this.entity.em).joinRows(this);\n    for (const entity of existing) jr.addRemove(this, this.entity, entity);\n    this.#loaded = [];\n    this.#isLoaded = false;\n  }\n\n  // Properties needed for JoinRows/ManyToManyCollection compatibility\n  get meta(): EntityMetadata {\n    return getMetadataForField(getMetadata(this.entity), this.fieldName);\n  }\n\n  get fieldName(): string {\n    return this.#field.fieldName;\n  }\n\n  get otherMeta(): EntityMetadata {\n    return this.#field.otherMetadata();\n  }\n\n  get joinTableName(): string {\n    return this.#field.joinTableName;\n  }\n\n  get columnName(): string {\n    return this.#field.columnNames[0];\n  }\n\n  get otherColumnName(): string {\n    return this.#field.columnNames[1];\n  }\n\n  get hasJoinTableId(): boolean {\n    return this.#field.hasJoinTableId;\n  }\n\n  get otherFieldName(): string {\n    return this.#field.otherFieldName;\n  }\n\n  get hasBeenSet(): boolean {\n    return true;\n  }\n\n  get isPreloaded(): boolean {\n    return false;\n  }\n\n  preload(): void {\n    // No-op for now - could implement if needed\n  }\n\n  import(\n    other: ReactiveManyToManyImpl<T, U, H>,\n    _: unknown,\n    mapEntities: (e: U[] | undefined) => U[] | undefined,\n  ): void {\n    this.#loaded = mapEntities(other.#loaded);\n    this.#loadedMode = other.#loadedMode;\n    this.#isLoaded = other.#isLoaded ?? false;\n    // Don't set `#isCached b/c we're not registering ourselves with `isLoadedCache` yet; let\n    // the first caller to `#doGet` do that if needed.\n  }\n\n  public toString(): string {\n    return `ReactiveManyToMany(entity: ${this.entity}, fieldName: ${this.fieldName}, otherMeta: ${this.otherMeta.type})`;\n  }\n\n  get #isCascadeDelete(): boolean {\n    return isCascadeDelete(this, this.#field.fieldName);\n  }\n\n  async #loadFromJoinTable(): Promise<U[]> {\n    const { em } = this.entity;\n    const key = `${this.columnName}=${this.entity.id}`;\n    // Use the existing m2m loader by creating a compatible collection-like object\n    await manyToManyBatchLoader(em, this).load(key);\n    return getEmInternalApi(em).joinRows(this).getOthers(this.columnName, this.entity) as U[];\n  }\n\n  // This is like calling `setField` but for a m2m relation...\n  #syncJoinTableRows(newValue: U[]): void {\n    const jr = getEmInternalApi(this.entity.em).joinRows(this);\n    const newSet = new Set(newValue);\n    const oldSet = new Set(jr.getOthers(this.columnName, this.entity) as U[]);\n    // Find entities to add (in new but not in old)\n    for (const entity of newValue) {\n      if (!oldSet.has(entity)) {\n        jr.addNew(this, this.entity, entity);\n      }\n    }\n    // Find entities to remove (in old but not in new)\n    for (const entity of oldSet) {\n      if (!newSet.has(entity)) {\n        jr.addRemove(this, this.entity, entity);\n      }\n    }\n  }\n\n  #filterDeleted(entities: U[], opts?: { withDeleted?: boolean }): U[] {\n    return opts?.withDeleted === true\n      ? [...entities]\n      : entities.filter((e) => !e.isDeletedEntity && !(e as any).isSoftDeletedEntity);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveManyToMany. */\nexport function isReactiveManyToMany(\n  maybeReactiveManyToMany: any,\n): maybeReactiveManyToMany is ReactiveManyToMany<any, any> {\n  return maybeReactiveManyToMany instanceof ReactiveManyToManyImpl;\n}\n"],"mappings":"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"}
+{"version":3,"file":"ReactiveManyToMany.cjs","names":["lazyField","getMetadata","AbstractRelationImpl","#field","getEmInternalApi","#isCached","#loadPromise","#loadedMode","#isLoaded","#doGet","#loadFromJoinTable","#loaded","#filterDeleted","isLoaded","#syncJoinTableRows","convertToLoadHint","#isCascadeDelete","getMetadataForField","isCascadeDelete","manyToManyBatchLoader","RelationT","RelationU"],"sources":["../../src/relations/ReactiveManyToMany.ts"],"sourcesContent":["import { manyToManyBatchLoader } from \"../batchloaders/manyToManyBatchLoader.ts\";\nimport {\n  type Entity,\n  type EntityMetadata,\n  type ManyToManyField,\n  type ReadOnlyCollection,\n  ensureNotDeleted,\n  fail,\n  getEmInternalApi,\n  getInstanceData,\n  getMetadata,\n  getMetadataForField,\n  isLoaded,\n} from \"../index.ts\";\nimport type { IsLoadedCachable } from \"../loading/IsLoadedCache.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport {\n  type MaybeReactedEntity,\n  type Reacted,\n  type ReactiveHint,\n  convertToLoadHint,\n} from \"../reactivity/reactiveHints.ts\";\nimport { AbstractRelationImpl } from \"./AbstractRelationImpl.ts\";\nimport { isCascadeDelete } from \"./isCascadeDelete.ts\";\nimport { RelationT, RelationU } from \"./RelationSymbols.ts\";\n\n/**\n * A reactive, derived many-to-many collection.\n *\n * Similar to `ReactiveReference` but for collections--membership is calculated from a reactive\n * function and persisted to the underlying join table.\n */\nexport interface ReactiveManyToMany<T extends Entity, U extends Entity> extends ReadOnlyCollection<T, U> {\n  load(opts?: { withDeleted?: boolean; forceReload?: boolean }): Promise<readonly U[]>;\n}\n\n/** Creates a `ReactiveManyToMany`. */\nexport function hasReactiveManyToMany<T extends Entity, U extends Entity, const H extends ReactiveHint<T>>(\n  hint: H,\n  fn: (entity: Reacted<T, H>) => readonly MaybeReactedEntity<U>[],\n): ReactiveManyToMany<T, U> {\n  return lazyField((entity: T, fieldName) => {\n    const m2m = getMetadata(entity).allFields[fieldName] as ManyToManyField;\n    return new ReactiveManyToManyImpl<T, U, H>(entity, m2m, hint, fn);\n  });\n}\n\n/** Implements ReactiveManyToMany, initially a copy/paste of ReactiveReference but for m2m. */\nexport class ReactiveManyToManyImpl<T extends Entity, U extends Entity, H extends ReactiveHint<T>>\n  extends AbstractRelationImpl<T, U[]>\n  implements ReactiveManyToMany<T, U>, IsLoadedCachable\n{\n  readonly #field: ManyToManyField;\n\n  // Could be either the ref-loaded stored array, or full-loaded calculated array\n  #loaded: U[] | undefined;\n  // In ref-mode, we use our materialized FK value (which might be undefined)\n  // If full-mode, we calculate the FK value from the subgraph\n  #loadedMode: \"ref\" | \"full\" | undefined = undefined;\n  // #isLoaded doesn't necessary care if we're ref-mode or full-mode, it's just\n  // whether a caller can call `.get` and not have it blow up.\n  #isLoaded: boolean | undefined = undefined;\n  #isCached: boolean = false;\n  #loadPromise: Promise<ReadonlyArray<U>> | undefined;\n\n  constructor(\n    entity: T,\n    field: ManyToManyField,\n    public reactiveHint: H,\n    private fn: (entity: Reacted<T, H>) => readonly MaybeReactedEntity<U>[],\n  ) {\n    super(entity);\n    this.#field = field;\n    (getInstanceData(entity).relations ??= {})[this.fieldName] = this;\n  }\n\n  async load(opts?: { withDeleted?: boolean; forceReload?: boolean }): Promise<ReadonlyArray<U>> {\n    ensureNotDeleted(this.entity, \"pending\");\n    const { loadHint } = this;\n\n    if (!this.isLoaded || opts?.forceReload) {\n      const { em } = this.entity;\n      const maybeDirty = opts?.forceReload || getEmInternalApi(em).rm.isMaybePendingRecalc(this.entity, this.fieldName);\n\n      if (maybeDirty) {\n        this.#isCached = false;\n        return (this.#loadPromise ??= em.populate(this.entity, { hint: loadHint, ...opts }).then(() => {\n          this.#loadPromise = undefined;\n          this.#loadedMode = \"full\";\n          this.#isLoaded = true;\n          getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n          return this.#doGet(opts);\n        }));\n      } else {\n        // Load from join table (existing materialized state)\n        return (this.#loadPromise ??= this.#loadFromJoinTable().then((loaded) => {\n          this.#loadPromise = undefined;\n          this.#loadedMode = \"ref\";\n          this.#isLoaded = true;\n          this.#loaded = loaded;\n          getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n          return this.#filterDeleted(loaded, opts);\n        }));\n      }\n    }\n    return this.#doGet(opts);\n  }\n\n  get isLoaded(): boolean {\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    // If a WIP mutation has marked our field as potentially dirty, we need to be \"full\" loaded\n    const maybeDirty = getEmInternalApi(this.entity.em).rm.isMaybePendingRecalc(this.entity, this.fieldName);\n    if (maybeDirty) {\n      // If we're dirty, only being \"full\" loaded is good enough to recalc\n      this.#loadedMode = \"full\";\n      this.#isLoaded = isLoaded(this.entity, this.loadHint);\n      this.#isCached = false;\n    } else {\n      // If we've had `.load` called before, assume we're still loaded\n      this.#isLoaded = !!this.#loadedMode;\n    }\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n    this.#isCached = false;\n  }\n\n  #doGet(opts?: { withDeleted?: boolean }): U[] {\n    const { fn } = this;\n    ensureNotDeleted(this.entity, \"pending\");\n    // Fast pass if we've already calculated this (cache invalidation will happen on\n    // any mutation via #resetIsLoaded)..\n    if (this.#isCached) {\n      return this.#filterDeleted(this.#loaded ?? [], opts) as U[];\n    }\n    // Call isLoaded to probe the load hint, and get `#isLoaded` set, but still have\n    // our `if` check the raw `#isLoaded` to know if we should eval-latest or return `loaded`.\n    if (this.isLoaded && this.#loadedMode === \"full\") {\n      const newValue = fn(this.entity as any) as unknown as U[];\n      // Preserve deleted entities that were in the previous loaded value\n      const previousDeleted = (this.#loaded ?? []).filter((e) => e.isDeletedEntity);\n      for (const entity of previousDeleted) {\n        if (!newValue.includes(entity)) newValue.push(entity);\n      }\n      if (!getEmInternalApi(this.entity.em).isValidating) {\n        this.#syncJoinTableRows(newValue);\n      }\n      this.#loaded = newValue;\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    } else if (!!this.#loadedMode) {\n      // We're either loadedMode=ref, or loadedMode=full (but not actually fully loaded),\n      // but in theory loadedMode only gets set in `.load()`, so we should have #loaded\n      // set to some value, even if it's not fully up-to-date.\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    } else {\n      const noun = this.entity.isNewEntity ? \"derived\" : \"loaded\";\n      throw new Error(`${this.entity}.${this.fieldName} has not been ${noun} yet`);\n    }\n    return this.#filterDeleted(this.#loaded ?? [], opts) as U[];\n  }\n\n  get getWithDeleted(): U[] {\n    return this.#doGet({ withDeleted: true });\n  }\n\n  get get(): U[] {\n    return this.#doGet({ withDeleted: false });\n  }\n\n  set(): void {\n    fail(`Cannot set ${this.entity}.${this.fieldName} ReactiveManyToMany directly.`);\n  }\n\n  get loadHint(): any {\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.reactiveHint));\n  }\n\n  setFromOpts(_others: U[]): void {\n    throw new Error(`ReactiveManyToMany ${this.entity}.${this.fieldName} cannot be set via opts`);\n  }\n\n  maybeCascadeDelete(): void {\n    if (this.#isCascadeDelete) {\n      const jr = getEmInternalApi(this.entity.em).joinRows(this);\n      (jr.getOthers(this.columnName, this.entity) as U[]).forEach((e) => this.entity.em.delete(e));\n    }\n  }\n\n  async cleanupOnEntityDeleted(): Promise<void> {\n    const existing = await this.load({ withDeleted: true });\n    const jr = getEmInternalApi(this.entity.em).joinRows(this);\n    for (const entity of existing) jr.addRemove(this, this.entity, entity);\n    this.#loaded = [];\n    this.#isLoaded = false;\n  }\n\n  // Properties needed for JoinRows/ManyToManyCollection compatibility\n  get meta(): EntityMetadata {\n    return getMetadataForField(getMetadata(this.entity), this.fieldName);\n  }\n\n  get fieldName(): string {\n    return this.#field.fieldName;\n  }\n\n  get otherMeta(): EntityMetadata {\n    return this.#field.otherMetadata();\n  }\n\n  get joinTableName(): string {\n    return this.#field.joinTableName;\n  }\n\n  get columnName(): string {\n    return this.#field.columnNames[0];\n  }\n\n  get otherColumnName(): string {\n    return this.#field.columnNames[1];\n  }\n\n  get hasJoinTableId(): boolean {\n    return this.#field.hasJoinTableId;\n  }\n\n  get otherFieldName(): string {\n    return this.#field.otherFieldName;\n  }\n\n  get hasBeenSet(): boolean {\n    return true;\n  }\n\n  get isPreloaded(): boolean {\n    return false;\n  }\n\n  preload(): void {\n    // No-op for now - could implement if needed\n  }\n\n  import(\n    other: ReactiveManyToManyImpl<T, U, H>,\n    _: unknown,\n    mapEntities: (e: U[] | undefined) => U[] | undefined,\n  ): void {\n    this.#loaded = mapEntities(other.#loaded);\n    this.#loadedMode = other.#loadedMode;\n    this.#isLoaded = other.#isLoaded ?? false;\n    // Don't set `#isCached b/c we're not registering ourselves with `isLoadedCache` yet; let\n    // the first caller to `#doGet` do that if needed.\n  }\n\n  public toString(): string {\n    return `ReactiveManyToMany(entity: ${this.entity}, fieldName: ${this.fieldName}, otherMeta: ${this.otherMeta.type})`;\n  }\n\n  get #isCascadeDelete(): boolean {\n    return isCascadeDelete(this, this.#field.fieldName);\n  }\n\n  async #loadFromJoinTable(): Promise<U[]> {\n    const { em } = this.entity;\n    const key = `${this.columnName}=${this.entity.id}`;\n    // Use the existing m2m loader by creating a compatible collection-like object\n    await manyToManyBatchLoader(em, this).load(key);\n    return getEmInternalApi(em).joinRows(this).getOthers(this.columnName, this.entity) as U[];\n  }\n\n  // This is like calling `setField` but for a m2m relation...\n  #syncJoinTableRows(newValue: U[]): void {\n    const jr = getEmInternalApi(this.entity.em).joinRows(this);\n    const newSet = new Set(newValue);\n    const oldSet = new Set(jr.getOthers(this.columnName, this.entity) as U[]);\n    // Find entities to add (in new but not in old)\n    for (const entity of newValue) {\n      if (!oldSet.has(entity)) {\n        jr.addNew(this, this.entity, entity);\n      }\n    }\n    // Find entities to remove (in old but not in new)\n    for (const entity of oldSet) {\n      if (!newSet.has(entity)) {\n        jr.addRemove(this, this.entity, entity);\n      }\n    }\n  }\n\n  #filterDeleted(entities: U[], opts?: { withDeleted?: boolean }): U[] {\n    return opts?.withDeleted === true\n      ? [...entities]\n      : entities.filter((e) => !e.isDeletedEntity && !(e as any).isSoftDeletedEntity);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveManyToMany. */\nexport function isReactiveManyToMany(\n  maybeReactiveManyToMany: any,\n): maybeReactiveManyToMany is ReactiveManyToMany<any, any> {\n  return maybeReactiveManyToMany instanceof ReactiveManyToManyImpl;\n}\n"],"mappings":"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"}

package/build/relations/ReactiveManyToMany.d.cts

@@ -1,8 +1,8 @@
 import { AbstractRelationImpl } from "./AbstractRelationImpl.cjs";
 import { RelationT, RelationU } from "./RelationSymbols.cjs";
-import { IsLoadedCachable } from "../IsLoadedCache.cjs";
+import { IsLoadedCachable } from "../loading/IsLoadedCache.cjs";
 import { ReadOnlyCollection } from "./ReadOnlyCollection.cjs";
-import { MaybeReactedEntity, Reacted, ReactiveHint } from "../reactiveHints.cjs";
+import { MaybeReactedEntity, Reacted, ReactiveHint } from "../reactivity/reactiveHints.cjs";
 import { EntityMetadata, ManyToManyField } from "../EntityMetadata.cjs";
 import "../index.cjs";
 import { Entity } from "../Entity.cjs";

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

@@ -1 +1 @@
-{"version":3,"file":"ReactiveManyToMany.d.cts","names":[],"sources":["../../src/relations/ReactiveManyToMany.ts"],"mappings":";;;;;;;;;;;;;;;UA2BiB,mBAAmB,UAAU,QAAQ,UAAU,gBAAgB,mBAAmB,GAAG;EACpG,KAAK;IAAS;IAAuB;MAA0B,iBAAiB;;;iBAIlE,sBAAsB,UAAU,QAAQ,UAAU,cAAc,UAAU,aAAa,IACrG,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,gBAAgB,mBAAmB,OAC1D,mBAAmB,GAAG;;cAQZ,uBAAuB,UAAU,QAAQ,UAAU,QAAQ,UAAU,aAAa,YACrF,qBAAqB,GAAG,gBACrB,mBAAmB,GAAG,IAAI;;EAkB5B,cAAc;UACb;EAJV,YACE,QAAQ,GACR,OAAO,iBACA,cAAc,GACb,KAAK,QAAQ,QAAQ,GAAG,gBAAgB,mBAAmB;EAO/D,KAAK;IAAS;IAAuB;MAA0B,QAAQ,cAAc;MAgCvF;EAiBJ;MAyCI,kBAAkB;MAIlB,OAAO;EAIX;MAII;EAKJ,YAAY,SAAS;EAIrB;EAOM,0BAA0B;MAS5B,QAAQ;MAIR;MAIA,aAAa;MAIb;MAIA;MAIA;MAIA;MAIA;MAIA;MAIA;EAIJ;EAIA,OACE,OAAO,uBAAuB,GAAG,GAAG,IACpC,YACA,cAAc,GAAG,oBAAoB;EAShC;GAyCN,YAAY;GACZ,YAAY;;;iBAIC,qBACd,+BACC,2BAA2B"}
+{"version":3,"file":"ReactiveManyToMany.d.cts","names":[],"sources":["../../src/relations/ReactiveManyToMany.ts"],"mappings":";;;;;;;;;;;;;;;UAgCiB,mBAAmB,UAAU,QAAQ,UAAU,gBAAgB,mBAAmB,GAAG;EACpG,KAAK;IAAS;IAAuB;MAA0B,iBAAiB;;;iBAIlE,sBAAsB,UAAU,QAAQ,UAAU,cAAc,UAAU,aAAa,IACrG,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,gBAAgB,mBAAmB,OAC1D,mBAAmB,GAAG;;cAQZ,uBAAuB,UAAU,QAAQ,UAAU,QAAQ,UAAU,aAAa,YACrF,qBAAqB,GAAG,gBACrB,mBAAmB,GAAG,IAAI;;EAkB5B,cAAc;UACb;EAJV,YACE,QAAQ,GACR,OAAO,iBACA,cAAc,GACb,KAAK,QAAQ,QAAQ,GAAG,gBAAgB,mBAAmB;EAO/D,KAAK;IAAS;IAAuB;MAA0B,QAAQ,cAAc;MAgCvF;EAiBJ;MAyCI,kBAAkB;MAIlB,OAAO;EAIX;MAII;EAKJ,YAAY,SAAS;EAIrB;EAOM,0BAA0B;MAS5B,QAAQ;MAIR;MAIA,aAAa;MAIb;MAIA;MAIA;MAIA;MAIA;MAIA;MAIA;EAIJ;EAIA,OACE,OAAO,uBAAuB,GAAG,GAAG,IACpC,YACA,cAAc,GAAG,oBAAoB;EAShC;GAyCN,YAAY;GACZ,YAAY;;;iBAIC,qBACd,+BACC,2BAA2B"}

package/build/relations/ReactiveManyToMany.d.mts

@@ -1,8 +1,8 @@
 import { AbstractRelationImpl } from "./AbstractRelationImpl.mjs";
 import { RelationT, RelationU } from "./RelationSymbols.mjs";
-import { IsLoadedCachable } from "../IsLoadedCache.mjs";
+import { IsLoadedCachable } from "../loading/IsLoadedCache.mjs";
 import { ReadOnlyCollection } from "./ReadOnlyCollection.mjs";
-import { MaybeReactedEntity, Reacted, ReactiveHint } from "../reactiveHints.mjs";
+import { MaybeReactedEntity, Reacted, ReactiveHint } from "../reactivity/reactiveHints.mjs";
 import { EntityMetadata, ManyToManyField } from "../EntityMetadata.mjs";
 import "../index.mjs";
 import { Entity } from "../Entity.mjs";

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

@@ -1 +1 @@
-{"version":3,"file":"ReactiveManyToMany.d.mts","names":[],"sources":["../../src/relations/ReactiveManyToMany.ts"],"mappings":";;;;;;;;;;;;;;;UA2BiB,mBAAmB,UAAU,QAAQ,UAAU,gBAAgB,mBAAmB,GAAG;EACpG,KAAK;IAAS;IAAuB;MAA0B,iBAAiB;;;iBAIlE,sBAAsB,UAAU,QAAQ,UAAU,cAAc,UAAU,aAAa,IACrG,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,gBAAgB,mBAAmB,OAC1D,mBAAmB,GAAG;;cAQZ,uBAAuB,UAAU,QAAQ,UAAU,QAAQ,UAAU,aAAa,YACrF,qBAAqB,GAAG,gBACrB,mBAAmB,GAAG,IAAI;;EAkB5B,cAAc;UACb;EAJV,YACE,QAAQ,GACR,OAAO,iBACA,cAAc,GACb,KAAK,QAAQ,QAAQ,GAAG,gBAAgB,mBAAmB;EAO/D,KAAK;IAAS;IAAuB;MAA0B,QAAQ,cAAc;MAgCvF;EAiBJ;MAyCI,kBAAkB;MAIlB,OAAO;EAIX;MAII;EAKJ,YAAY,SAAS;EAIrB;EAOM,0BAA0B;MAS5B,QAAQ;MAIR;MAIA,aAAa;MAIb;MAIA;MAIA;MAIA;MAIA;MAIA;MAIA;EAIJ;EAIA,OACE,OAAO,uBAAuB,GAAG,GAAG,IACpC,YACA,cAAc,GAAG,oBAAoB;EAShC;GAyCN,YAAY;GACZ,YAAY;;;iBAIC,qBACd,+BACC,2BAA2B"}
+{"version":3,"file":"ReactiveManyToMany.d.mts","names":[],"sources":["../../src/relations/ReactiveManyToMany.ts"],"mappings":";;;;;;;;;;;;;;;UAgCiB,mBAAmB,UAAU,QAAQ,UAAU,gBAAgB,mBAAmB,GAAG;EACpG,KAAK;IAAS;IAAuB;MAA0B,iBAAiB;;;iBAIlE,sBAAsB,UAAU,QAAQ,UAAU,cAAc,UAAU,aAAa,IACrG,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,gBAAgB,mBAAmB,OAC1D,mBAAmB,GAAG;;cAQZ,uBAAuB,UAAU,QAAQ,UAAU,QAAQ,UAAU,aAAa,YACrF,qBAAqB,GAAG,gBACrB,mBAAmB,GAAG,IAAI;;EAkB5B,cAAc;UACb;EAJV,YACE,QAAQ,GACR,OAAO,iBACA,cAAc,GACb,KAAK,QAAQ,QAAQ,GAAG,gBAAgB,mBAAmB;EAO/D,KAAK;IAAS;IAAuB;MAA0B,QAAQ,cAAc;MAgCvF;EAiBJ;MAyCI,kBAAkB;MAIlB,OAAO;EAIX;MAII;EAKJ,YAAY,SAAS;EAIrB;EAOM,0BAA0B;MAS5B,QAAQ;MAIR;MAIA,aAAa;MAIb;MAIA;MAIA;MAIA;MAIA;MAIA;MAIA;EAIJ;EAIA,OACE,OAAO,uBAAuB,GAAG,GAAG,IACpC,YACA,cAAc,GAAG,oBAAoB;EAShC;GAyCN,YAAY;GACZ,YAAY;;;iBAIC,qBACd,+BACC,2BAA2B"}

package/build/relations/ReactiveManyToMany.js

@@ -1,12 +1,11 @@
 import { AbstractRelationImpl } from "./AbstractRelationImpl.js";
 import { RelationT, RelationU } from "./RelationSymbols.js";
+import { convertToLoadHint } from "../reactivity/reactiveHints.js";
+import { isLoaded } from "../loading/loadHints.js";
+import { manyToManyBatchLoader } from "../batchloaders/manyToManyBatchLoader.js";
 import { isCascadeDelete } from "./isCascadeDelete.js";
-import "../IsLoadedCache.js";
-import { convertToLoadHint } from "../reactiveHints.js";
-import { isLoaded } from "../loadHints.js";
 import { fail } from "../utils.js";
 import { lazyField } from "../newEntity.js";
-import { manyToManyBatchLoader } from "../batchloaders/manyToManyBatchLoader.js";
 import { getMetadata, getMetadataForField } from "../EntityMetadata.js";
 import { ensureNotDeleted } from "../index.js";
 import { getEmInternalApi } from "../EntityManager.js";

package/build/relations/ReactiveManyToMany.js.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveManyToMany.js","names":["#field","#isCached","#loadPromise","#loadedMode","#isLoaded","#doGet","#loadFromJoinTable","#loaded","#filterDeleted","#syncJoinTableRows","#isCascadeDelete"],"sources":["../../src/relations/ReactiveManyToMany.ts"],"sourcesContent":["import { manyToManyBatchLoader } from \"../batchloaders/manyToManyBatchLoader.ts\";\nimport {\n  type Entity,\n  type EntityMetadata,\n  type ManyToManyField,\n  type ReadOnlyCollection,\n  ensureNotDeleted,\n  fail,\n  getEmInternalApi,\n  getInstanceData,\n  getMetadata,\n  getMetadataForField,\n  isLoaded,\n} from \"../index.ts\";\nimport { type IsLoadedCachable } from \"../IsLoadedCache.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { type MaybeReactedEntity, type Reacted, type ReactiveHint, convertToLoadHint } from \"../reactiveHints.ts\";\nimport { AbstractRelationImpl } from \"./AbstractRelationImpl.ts\";\nimport { isCascadeDelete } from \"./isCascadeDelete.ts\";\nimport { RelationT, RelationU } from \"./RelationSymbols.ts\";\n\n/**\n * A reactive, derived many-to-many collection.\n *\n * Similar to `ReactiveReference` but for collections--membership is calculated from a reactive\n * function and persisted to the underlying join table.\n */\nexport interface ReactiveManyToMany<T extends Entity, U extends Entity> extends ReadOnlyCollection<T, U> {\n  load(opts?: { withDeleted?: boolean; forceReload?: boolean }): Promise<readonly U[]>;\n}\n\n/** Creates a `ReactiveManyToMany`. */\nexport function hasReactiveManyToMany<T extends Entity, U extends Entity, const H extends ReactiveHint<T>>(\n  hint: H,\n  fn: (entity: Reacted<T, H>) => readonly MaybeReactedEntity<U>[],\n): ReactiveManyToMany<T, U> {\n  return lazyField((entity: T, fieldName) => {\n    const m2m = getMetadata(entity).allFields[fieldName] as ManyToManyField;\n    return new ReactiveManyToManyImpl<T, U, H>(entity, m2m, hint, fn);\n  });\n}\n\n/** Implements ReactiveManyToMany, initially a copy/paste of ReactiveReference but for m2m. */\nexport class ReactiveManyToManyImpl<T extends Entity, U extends Entity, H extends ReactiveHint<T>>\n  extends AbstractRelationImpl<T, U[]>\n  implements ReactiveManyToMany<T, U>, IsLoadedCachable\n{\n  readonly #field: ManyToManyField;\n\n  // Could be either the ref-loaded stored array, or full-loaded calculated array\n  #loaded: U[] | undefined;\n  // In ref-mode, we use our materialized FK value (which might be undefined)\n  // If full-mode, we calculate the FK value from the subgraph\n  #loadedMode: \"ref\" | \"full\" | undefined = undefined;\n  // #isLoaded doesn't necessary care if we're ref-mode or full-mode, it's just\n  // whether a caller can call `.get` and not have it blow up.\n  #isLoaded: boolean | undefined = undefined;\n  #isCached: boolean = false;\n  #loadPromise: Promise<ReadonlyArray<U>> | undefined;\n\n  constructor(\n    entity: T,\n    field: ManyToManyField,\n    public reactiveHint: H,\n    private fn: (entity: Reacted<T, H>) => readonly MaybeReactedEntity<U>[],\n  ) {\n    super(entity);\n    this.#field = field;\n    (getInstanceData(entity).relations ??= {})[this.fieldName] = this;\n  }\n\n  async load(opts?: { withDeleted?: boolean; forceReload?: boolean }): Promise<ReadonlyArray<U>> {\n    ensureNotDeleted(this.entity, \"pending\");\n    const { loadHint } = this;\n\n    if (!this.isLoaded || opts?.forceReload) {\n      const { em } = this.entity;\n      const maybeDirty = opts?.forceReload || getEmInternalApi(em).rm.isMaybePendingRecalc(this.entity, this.fieldName);\n\n      if (maybeDirty) {\n        this.#isCached = false;\n        return (this.#loadPromise ??= em.populate(this.entity, { hint: loadHint, ...opts }).then(() => {\n          this.#loadPromise = undefined;\n          this.#loadedMode = \"full\";\n          this.#isLoaded = true;\n          getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n          return this.#doGet(opts);\n        }));\n      } else {\n        // Load from join table (existing materialized state)\n        return (this.#loadPromise ??= this.#loadFromJoinTable().then((loaded) => {\n          this.#loadPromise = undefined;\n          this.#loadedMode = \"ref\";\n          this.#isLoaded = true;\n          this.#loaded = loaded;\n          getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n          return this.#filterDeleted(loaded, opts);\n        }));\n      }\n    }\n    return this.#doGet(opts);\n  }\n\n  get isLoaded(): boolean {\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    // If a WIP mutation has marked our field as potentially dirty, we need to be \"full\" loaded\n    const maybeDirty = getEmInternalApi(this.entity.em).rm.isMaybePendingRecalc(this.entity, this.fieldName);\n    if (maybeDirty) {\n      // If we're dirty, only being \"full\" loaded is good enough to recalc\n      this.#loadedMode = \"full\";\n      this.#isLoaded = isLoaded(this.entity, this.loadHint);\n      this.#isCached = false;\n    } else {\n      // If we've had `.load` called before, assume we're still loaded\n      this.#isLoaded = !!this.#loadedMode;\n    }\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n    this.#isCached = false;\n  }\n\n  #doGet(opts?: { withDeleted?: boolean }): U[] {\n    const { fn } = this;\n    ensureNotDeleted(this.entity, \"pending\");\n    // Fast pass if we've already calculated this (cache invalidation will happen on\n    // any mutation via #resetIsLoaded)..\n    if (this.#isCached) {\n      return this.#filterDeleted(this.#loaded ?? [], opts) as U[];\n    }\n    // Call isLoaded to probe the load hint, and get `#isLoaded` set, but still have\n    // our `if` check the raw `#isLoaded` to know if we should eval-latest or return `loaded`.\n    if (this.isLoaded && this.#loadedMode === \"full\") {\n      const newValue = fn(this.entity as any) as unknown as U[];\n      // Preserve deleted entities that were in the previous loaded value\n      const previousDeleted = (this.#loaded ?? []).filter((e) => e.isDeletedEntity);\n      for (const entity of previousDeleted) {\n        if (!newValue.includes(entity)) newValue.push(entity);\n      }\n      if (!getEmInternalApi(this.entity.em).isValidating) {\n        this.#syncJoinTableRows(newValue);\n      }\n      this.#loaded = newValue;\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    } else if (!!this.#loadedMode) {\n      // We're either loadedMode=ref, or loadedMode=full (but not actually fully loaded),\n      // but in theory loadedMode only gets set in `.load()`, so we should have #loaded\n      // set to some value, even if it's not fully up-to-date.\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    } else {\n      const noun = this.entity.isNewEntity ? \"derived\" : \"loaded\";\n      throw new Error(`${this.entity}.${this.fieldName} has not been ${noun} yet`);\n    }\n    return this.#filterDeleted(this.#loaded ?? [], opts) as U[];\n  }\n\n  get getWithDeleted(): U[] {\n    return this.#doGet({ withDeleted: true });\n  }\n\n  get get(): U[] {\n    return this.#doGet({ withDeleted: false });\n  }\n\n  set(): void {\n    fail(`Cannot set ${this.entity}.${this.fieldName} ReactiveManyToMany directly.`);\n  }\n\n  get loadHint(): any {\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.reactiveHint));\n  }\n\n  setFromOpts(_others: U[]): void {\n    throw new Error(`ReactiveManyToMany ${this.entity}.${this.fieldName} cannot be set via opts`);\n  }\n\n  maybeCascadeDelete(): void {\n    if (this.#isCascadeDelete) {\n      const jr = getEmInternalApi(this.entity.em).joinRows(this);\n      (jr.getOthers(this.columnName, this.entity) as U[]).forEach((e) => this.entity.em.delete(e));\n    }\n  }\n\n  async cleanupOnEntityDeleted(): Promise<void> {\n    const existing = await this.load({ withDeleted: true });\n    const jr = getEmInternalApi(this.entity.em).joinRows(this);\n    for (const entity of existing) jr.addRemove(this, this.entity, entity);\n    this.#loaded = [];\n    this.#isLoaded = false;\n  }\n\n  // Properties needed for JoinRows/ManyToManyCollection compatibility\n  get meta(): EntityMetadata {\n    return getMetadataForField(getMetadata(this.entity), this.fieldName);\n  }\n\n  get fieldName(): string {\n    return this.#field.fieldName;\n  }\n\n  get otherMeta(): EntityMetadata {\n    return this.#field.otherMetadata();\n  }\n\n  get joinTableName(): string {\n    return this.#field.joinTableName;\n  }\n\n  get columnName(): string {\n    return this.#field.columnNames[0];\n  }\n\n  get otherColumnName(): string {\n    return this.#field.columnNames[1];\n  }\n\n  get hasJoinTableId(): boolean {\n    return this.#field.hasJoinTableId;\n  }\n\n  get otherFieldName(): string {\n    return this.#field.otherFieldName;\n  }\n\n  get hasBeenSet(): boolean {\n    return true;\n  }\n\n  get isPreloaded(): boolean {\n    return false;\n  }\n\n  preload(): void {\n    // No-op for now - could implement if needed\n  }\n\n  import(\n    other: ReactiveManyToManyImpl<T, U, H>,\n    _: unknown,\n    mapEntities: (e: U[] | undefined) => U[] | undefined,\n  ): void {\n    this.#loaded = mapEntities(other.#loaded);\n    this.#loadedMode = other.#loadedMode;\n    this.#isLoaded = other.#isLoaded ?? false;\n    // Don't set `#isCached b/c we're not registering ourselves with `isLoadedCache` yet; let\n    // the first caller to `#doGet` do that if needed.\n  }\n\n  public toString(): string {\n    return `ReactiveManyToMany(entity: ${this.entity}, fieldName: ${this.fieldName}, otherMeta: ${this.otherMeta.type})`;\n  }\n\n  get #isCascadeDelete(): boolean {\n    return isCascadeDelete(this, this.#field.fieldName);\n  }\n\n  async #loadFromJoinTable(): Promise<U[]> {\n    const { em } = this.entity;\n    const key = `${this.columnName}=${this.entity.id}`;\n    // Use the existing m2m loader by creating a compatible collection-like object\n    await manyToManyBatchLoader(em, this).load(key);\n    return getEmInternalApi(em).joinRows(this).getOthers(this.columnName, this.entity) as U[];\n  }\n\n  // This is like calling `setField` but for a m2m relation...\n  #syncJoinTableRows(newValue: U[]): void {\n    const jr = getEmInternalApi(this.entity.em).joinRows(this);\n    const newSet = new Set(newValue);\n    const oldSet = new Set(jr.getOthers(this.columnName, this.entity) as U[]);\n    // Find entities to add (in new but not in old)\n    for (const entity of newValue) {\n      if (!oldSet.has(entity)) {\n        jr.addNew(this, this.entity, entity);\n      }\n    }\n    // Find entities to remove (in old but not in new)\n    for (const entity of oldSet) {\n      if (!newSet.has(entity)) {\n        jr.addRemove(this, this.entity, entity);\n      }\n    }\n  }\n\n  #filterDeleted(entities: U[], opts?: { withDeleted?: boolean }): U[] {\n    return opts?.withDeleted === true\n      ? [...entities]\n      : entities.filter((e) => !e.isDeletedEntity && !(e as any).isSoftDeletedEntity);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveManyToMany. */\nexport function isReactiveManyToMany(\n  maybeReactiveManyToMany: any,\n): maybeReactiveManyToMany is ReactiveManyToMany<any, any> {\n  return maybeReactiveManyToMany instanceof ReactiveManyToManyImpl;\n}\n"],"mappings":"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"}
+{"version":3,"file":"ReactiveManyToMany.js","names":["#field","#isCached","#loadPromise","#loadedMode","#isLoaded","#doGet","#loadFromJoinTable","#loaded","#filterDeleted","#syncJoinTableRows","#isCascadeDelete"],"sources":["../../src/relations/ReactiveManyToMany.ts"],"sourcesContent":["import { manyToManyBatchLoader } from \"../batchloaders/manyToManyBatchLoader.ts\";\nimport {\n  type Entity,\n  type EntityMetadata,\n  type ManyToManyField,\n  type ReadOnlyCollection,\n  ensureNotDeleted,\n  fail,\n  getEmInternalApi,\n  getInstanceData,\n  getMetadata,\n  getMetadataForField,\n  isLoaded,\n} from \"../index.ts\";\nimport type { IsLoadedCachable } from \"../loading/IsLoadedCache.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport {\n  type MaybeReactedEntity,\n  type Reacted,\n  type ReactiveHint,\n  convertToLoadHint,\n} from \"../reactivity/reactiveHints.ts\";\nimport { AbstractRelationImpl } from \"./AbstractRelationImpl.ts\";\nimport { isCascadeDelete } from \"./isCascadeDelete.ts\";\nimport { RelationT, RelationU } from \"./RelationSymbols.ts\";\n\n/**\n * A reactive, derived many-to-many collection.\n *\n * Similar to `ReactiveReference` but for collections--membership is calculated from a reactive\n * function and persisted to the underlying join table.\n */\nexport interface ReactiveManyToMany<T extends Entity, U extends Entity> extends ReadOnlyCollection<T, U> {\n  load(opts?: { withDeleted?: boolean; forceReload?: boolean }): Promise<readonly U[]>;\n}\n\n/** Creates a `ReactiveManyToMany`. */\nexport function hasReactiveManyToMany<T extends Entity, U extends Entity, const H extends ReactiveHint<T>>(\n  hint: H,\n  fn: (entity: Reacted<T, H>) => readonly MaybeReactedEntity<U>[],\n): ReactiveManyToMany<T, U> {\n  return lazyField((entity: T, fieldName) => {\n    const m2m = getMetadata(entity).allFields[fieldName] as ManyToManyField;\n    return new ReactiveManyToManyImpl<T, U, H>(entity, m2m, hint, fn);\n  });\n}\n\n/** Implements ReactiveManyToMany, initially a copy/paste of ReactiveReference but for m2m. */\nexport class ReactiveManyToManyImpl<T extends Entity, U extends Entity, H extends ReactiveHint<T>>\n  extends AbstractRelationImpl<T, U[]>\n  implements ReactiveManyToMany<T, U>, IsLoadedCachable\n{\n  readonly #field: ManyToManyField;\n\n  // Could be either the ref-loaded stored array, or full-loaded calculated array\n  #loaded: U[] | undefined;\n  // In ref-mode, we use our materialized FK value (which might be undefined)\n  // If full-mode, we calculate the FK value from the subgraph\n  #loadedMode: \"ref\" | \"full\" | undefined = undefined;\n  // #isLoaded doesn't necessary care if we're ref-mode or full-mode, it's just\n  // whether a caller can call `.get` and not have it blow up.\n  #isLoaded: boolean | undefined = undefined;\n  #isCached: boolean = false;\n  #loadPromise: Promise<ReadonlyArray<U>> | undefined;\n\n  constructor(\n    entity: T,\n    field: ManyToManyField,\n    public reactiveHint: H,\n    private fn: (entity: Reacted<T, H>) => readonly MaybeReactedEntity<U>[],\n  ) {\n    super(entity);\n    this.#field = field;\n    (getInstanceData(entity).relations ??= {})[this.fieldName] = this;\n  }\n\n  async load(opts?: { withDeleted?: boolean; forceReload?: boolean }): Promise<ReadonlyArray<U>> {\n    ensureNotDeleted(this.entity, \"pending\");\n    const { loadHint } = this;\n\n    if (!this.isLoaded || opts?.forceReload) {\n      const { em } = this.entity;\n      const maybeDirty = opts?.forceReload || getEmInternalApi(em).rm.isMaybePendingRecalc(this.entity, this.fieldName);\n\n      if (maybeDirty) {\n        this.#isCached = false;\n        return (this.#loadPromise ??= em.populate(this.entity, { hint: loadHint, ...opts }).then(() => {\n          this.#loadPromise = undefined;\n          this.#loadedMode = \"full\";\n          this.#isLoaded = true;\n          getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n          return this.#doGet(opts);\n        }));\n      } else {\n        // Load from join table (existing materialized state)\n        return (this.#loadPromise ??= this.#loadFromJoinTable().then((loaded) => {\n          this.#loadPromise = undefined;\n          this.#loadedMode = \"ref\";\n          this.#isLoaded = true;\n          this.#loaded = loaded;\n          getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n          return this.#filterDeleted(loaded, opts);\n        }));\n      }\n    }\n    return this.#doGet(opts);\n  }\n\n  get isLoaded(): boolean {\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    // If a WIP mutation has marked our field as potentially dirty, we need to be \"full\" loaded\n    const maybeDirty = getEmInternalApi(this.entity.em).rm.isMaybePendingRecalc(this.entity, this.fieldName);\n    if (maybeDirty) {\n      // If we're dirty, only being \"full\" loaded is good enough to recalc\n      this.#loadedMode = \"full\";\n      this.#isLoaded = isLoaded(this.entity, this.loadHint);\n      this.#isCached = false;\n    } else {\n      // If we've had `.load` called before, assume we're still loaded\n      this.#isLoaded = !!this.#loadedMode;\n    }\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n    this.#isCached = false;\n  }\n\n  #doGet(opts?: { withDeleted?: boolean }): U[] {\n    const { fn } = this;\n    ensureNotDeleted(this.entity, \"pending\");\n    // Fast pass if we've already calculated this (cache invalidation will happen on\n    // any mutation via #resetIsLoaded)..\n    if (this.#isCached) {\n      return this.#filterDeleted(this.#loaded ?? [], opts) as U[];\n    }\n    // Call isLoaded to probe the load hint, and get `#isLoaded` set, but still have\n    // our `if` check the raw `#isLoaded` to know if we should eval-latest or return `loaded`.\n    if (this.isLoaded && this.#loadedMode === \"full\") {\n      const newValue = fn(this.entity as any) as unknown as U[];\n      // Preserve deleted entities that were in the previous loaded value\n      const previousDeleted = (this.#loaded ?? []).filter((e) => e.isDeletedEntity);\n      for (const entity of previousDeleted) {\n        if (!newValue.includes(entity)) newValue.push(entity);\n      }\n      if (!getEmInternalApi(this.entity.em).isValidating) {\n        this.#syncJoinTableRows(newValue);\n      }\n      this.#loaded = newValue;\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    } else if (!!this.#loadedMode) {\n      // We're either loadedMode=ref, or loadedMode=full (but not actually fully loaded),\n      // but in theory loadedMode only gets set in `.load()`, so we should have #loaded\n      // set to some value, even if it's not fully up-to-date.\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    } else {\n      const noun = this.entity.isNewEntity ? \"derived\" : \"loaded\";\n      throw new Error(`${this.entity}.${this.fieldName} has not been ${noun} yet`);\n    }\n    return this.#filterDeleted(this.#loaded ?? [], opts) as U[];\n  }\n\n  get getWithDeleted(): U[] {\n    return this.#doGet({ withDeleted: true });\n  }\n\n  get get(): U[] {\n    return this.#doGet({ withDeleted: false });\n  }\n\n  set(): void {\n    fail(`Cannot set ${this.entity}.${this.fieldName} ReactiveManyToMany directly.`);\n  }\n\n  get loadHint(): any {\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.reactiveHint));\n  }\n\n  setFromOpts(_others: U[]): void {\n    throw new Error(`ReactiveManyToMany ${this.entity}.${this.fieldName} cannot be set via opts`);\n  }\n\n  maybeCascadeDelete(): void {\n    if (this.#isCascadeDelete) {\n      const jr = getEmInternalApi(this.entity.em).joinRows(this);\n      (jr.getOthers(this.columnName, this.entity) as U[]).forEach((e) => this.entity.em.delete(e));\n    }\n  }\n\n  async cleanupOnEntityDeleted(): Promise<void> {\n    const existing = await this.load({ withDeleted: true });\n    const jr = getEmInternalApi(this.entity.em).joinRows(this);\n    for (const entity of existing) jr.addRemove(this, this.entity, entity);\n    this.#loaded = [];\n    this.#isLoaded = false;\n  }\n\n  // Properties needed for JoinRows/ManyToManyCollection compatibility\n  get meta(): EntityMetadata {\n    return getMetadataForField(getMetadata(this.entity), this.fieldName);\n  }\n\n  get fieldName(): string {\n    return this.#field.fieldName;\n  }\n\n  get otherMeta(): EntityMetadata {\n    return this.#field.otherMetadata();\n  }\n\n  get joinTableName(): string {\n    return this.#field.joinTableName;\n  }\n\n  get columnName(): string {\n    return this.#field.columnNames[0];\n  }\n\n  get otherColumnName(): string {\n    return this.#field.columnNames[1];\n  }\n\n  get hasJoinTableId(): boolean {\n    return this.#field.hasJoinTableId;\n  }\n\n  get otherFieldName(): string {\n    return this.#field.otherFieldName;\n  }\n\n  get hasBeenSet(): boolean {\n    return true;\n  }\n\n  get isPreloaded(): boolean {\n    return false;\n  }\n\n  preload(): void {\n    // No-op for now - could implement if needed\n  }\n\n  import(\n    other: ReactiveManyToManyImpl<T, U, H>,\n    _: unknown,\n    mapEntities: (e: U[] | undefined) => U[] | undefined,\n  ): void {\n    this.#loaded = mapEntities(other.#loaded);\n    this.#loadedMode = other.#loadedMode;\n    this.#isLoaded = other.#isLoaded ?? false;\n    // Don't set `#isCached b/c we're not registering ourselves with `isLoadedCache` yet; let\n    // the first caller to `#doGet` do that if needed.\n  }\n\n  public toString(): string {\n    return `ReactiveManyToMany(entity: ${this.entity}, fieldName: ${this.fieldName}, otherMeta: ${this.otherMeta.type})`;\n  }\n\n  get #isCascadeDelete(): boolean {\n    return isCascadeDelete(this, this.#field.fieldName);\n  }\n\n  async #loadFromJoinTable(): Promise<U[]> {\n    const { em } = this.entity;\n    const key = `${this.columnName}=${this.entity.id}`;\n    // Use the existing m2m loader by creating a compatible collection-like object\n    await manyToManyBatchLoader(em, this).load(key);\n    return getEmInternalApi(em).joinRows(this).getOthers(this.columnName, this.entity) as U[];\n  }\n\n  // This is like calling `setField` but for a m2m relation...\n  #syncJoinTableRows(newValue: U[]): void {\n    const jr = getEmInternalApi(this.entity.em).joinRows(this);\n    const newSet = new Set(newValue);\n    const oldSet = new Set(jr.getOthers(this.columnName, this.entity) as U[]);\n    // Find entities to add (in new but not in old)\n    for (const entity of newValue) {\n      if (!oldSet.has(entity)) {\n        jr.addNew(this, this.entity, entity);\n      }\n    }\n    // Find entities to remove (in old but not in new)\n    for (const entity of oldSet) {\n      if (!newSet.has(entity)) {\n        jr.addRemove(this, this.entity, entity);\n      }\n    }\n  }\n\n  #filterDeleted(entities: U[], opts?: { withDeleted?: boolean }): U[] {\n    return opts?.withDeleted === true\n      ? [...entities]\n      : entities.filter((e) => !e.isDeletedEntity && !(e as any).isSoftDeletedEntity);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveManyToMany. */\nexport function isReactiveManyToMany(\n  maybeReactiveManyToMany: any,\n): maybeReactiveManyToMany is ReactiveManyToMany<any, any> {\n  return maybeReactiveManyToMany instanceof ReactiveManyToManyImpl;\n}\n"],"mappings":"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"}

package/build/relations/ReactiveManyToManyOtherSide.cjs

@@ -1,10 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("../JoinRows.cjs");
 const require_relations_AbstractRelationImpl = require("./AbstractRelationImpl.cjs");
 const require_relations_RelationSymbols = require("./RelationSymbols.cjs");
-require("../IsLoadedCache.cjs");
-const require_newEntity = require("../newEntity.cjs");
 const require_batchloaders_manyToManyBatchLoader = require("../batchloaders/manyToManyBatchLoader.cjs");
+const require_newEntity = require("../newEntity.cjs");
 const require_EntityMetadata = require("../EntityMetadata.cjs");
 const require_index = require("../index.cjs");
 const require_EntityManager = require("../EntityManager.cjs");