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

package/build/loading/loadLens.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadLens.d.cts","names":[],"sources":["../../src/loading/loadLens.ts"],"mappings":";;;;;KAkBK,SAAS;EAAO,QAAQ,QAAQ;;;KAGhC,cAAc,WAAW,YAAY;;;;;;;;;;;;;KAiBrC,WAAW,GAAG,KACjB,UAAU,sBACL,YAAY,oBAAoB,MAC/B,cAAc,OACd,cAAc,OAChB,UAAU,qBACR,KACC,yBACC,gBACA;;KAKL,eAAe,KAAK,UAAU,oBAAoB,KAAK,IAAI;KAE3D,cAAc,KAAK,QAAQ;;;;;;;;;;KAWpB,KAAK,GAAG,IAAI,QACrB,WAAW,IAAI,EAAE,WAAW,eAAe,KACxC,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,EAAE,WAAW,oBAAoB,KAC/B,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,KAAK,eAAe,cAAc,EAAE,MAAM,WAAW,GAAG,EAAE;;;;;;;;;;iBAe5C,SAAS,UAAU,QAAQ,GAAG,GAClD,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,IAC/B;EAAQ;EAAuB;IAC9B,QAAQ;;iBAKK,aAAa,UAAU,QAAQ,GAC7C,OAAO,aAAa,KACpB,iBACA;EAAQ;EAAuB;IAC9B,QAAQ;iBA8FK,cAAc,MAAM,gBAAgB;iBAapC,iBAAiB,QAAQ,gBAAgB,mBAAmB,iBAAiB,gBAAgB;;;;;;iBAkC7F,QAAQ,GAAG,GAAG,GAC5B,WAAW,gBACX,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAC9B;;iBAKa,YAAY,GAAG,GAAG,WAAW,gBAAgB,OAAO,aAAa,KAAK,kBAAkB;;iBAqDxF,aAAa,GAAG,GAAG,GAAG,OAAO,aAAa,KAAK,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG;;iBAK9E,iBAAiB,GAAG,OAAO,aAAa,KAAK;;iBAgC7C,eAAe,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAAK,SAAS;;iBAKpF,mBAAmB,UAAU,QAAQ,kBAAkB,SAAS;;iBAUhE,WAAW,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG"}

package/build/{loadLens.d.mts → loading/loadLens.d.mts}

@@ -1,7 +1,7 @@
 import { LoadHint } from "./loadHints.mjs";
-import { EntityMetadata, Field } from "./EntityMetadata.mjs";
-import { Entity } from "./Entity.mjs";
-//#region src/loadLens.d.ts
+import { EntityMetadata, Field } from "../EntityMetadata.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/loading/loadLens.d.ts
 /** Generically matches on a Reference/Collection's load method. */
 type LoadLike<U> = {
   load(): Promise<U>;

package/build/loading/loadLens.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadLens.d.mts","names":[],"sources":["../../src/loading/loadLens.ts"],"mappings":";;;;;KAkBK,SAAS;EAAO,QAAQ,QAAQ;;;KAGhC,cAAc,WAAW,YAAY;;;;;;;;;;;;;KAiBrC,WAAW,GAAG,KACjB,UAAU,sBACL,YAAY,oBAAoB,MAC/B,cAAc,OACd,cAAc,OAChB,UAAU,qBACR,KACC,yBACC,gBACA;;KAKL,eAAe,KAAK,UAAU,oBAAoB,KAAK,IAAI;KAE3D,cAAc,KAAK,QAAQ;;;;;;;;;;KAWpB,KAAK,GAAG,IAAI,QACrB,WAAW,IAAI,EAAE,WAAW,eAAe,KACxC,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,EAAE,WAAW,oBAAoB,KAC/B,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,KAAK,eAAe,cAAc,EAAE,MAAM,WAAW,GAAG,EAAE;;;;;;;;;;iBAe5C,SAAS,UAAU,QAAQ,GAAG,GAClD,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,IAC/B;EAAQ;EAAuB;IAC9B,QAAQ;;iBAKK,aAAa,UAAU,QAAQ,GAC7C,OAAO,aAAa,KACpB,iBACA;EAAQ;EAAuB;IAC9B,QAAQ;iBA8FK,cAAc,MAAM,gBAAgB;iBAapC,iBAAiB,QAAQ,gBAAgB,mBAAmB,iBAAiB,gBAAgB;;;;;;iBAkC7F,QAAQ,GAAG,GAAG,GAC5B,WAAW,gBACX,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAC9B;;iBAKa,YAAY,GAAG,GAAG,WAAW,gBAAgB,OAAO,aAAa,KAAK,kBAAkB;;iBAqDxF,aAAa,GAAG,GAAG,GAAG,OAAO,aAAa,KAAK,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG;;iBAK9E,iBAAiB,GAAG,OAAO,aAAa,KAAK;;iBAgC7C,eAAe,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAAK,SAAS;;iBAKpF,mBAAmB,UAAU,QAAQ,kBAAkB,SAAS;;iBAUhE,WAAW,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG"}

package/build/{loadLens.js → loading/loadLens.js}

@@ -1,12 +1,11 @@
-import { AbstractRelationImpl } from "./relations/AbstractRelationImpl.js";
-import { isProperty } from "./relations/hasProperty.js";
-import "./loadHints.js";
-import "./relations/index.js";
-import { getMetadata } from "./EntityMetadata.js";
-import { lensDataLoader } from "./dataloaders/lensDataLoader.js";
-import { appendStack } from "./EntityManager.js";
-import { isEntity } from "./Entity.js";
-//#region src/loadLens.ts
+import { AbstractRelationImpl } from "../relations/AbstractRelationImpl.js";
+import { isProperty } from "../relations/hasProperty.js";
+import "../relations/index.js";
+import { getMetadata } from "../EntityMetadata.js";
+import { lensDataLoader } from "../dataloaders/lensDataLoader.js";
+import { appendStack } from "../EntityManager.js";
+import { isEntity } from "../Entity.js";
+//#region src/loading/loadLens.ts
 /**
 * Allows declaratively loading/traversing several layers of references at once.
 *

package/build/loading/loadLens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadLens.js","names":[],"sources":["../../src/loading/loadLens.ts"],"sourcesContent":["import { lensDataLoader } from \"src/dataloaders/lensDataLoader.ts\";\nimport { type Entity, isEntity } from \"src/Entity.ts\";\nimport { appendStack } from \"src/EntityManager.ts\";\nimport {\n  type EntityMetadata,\n  type Field,\n  type ManyToManyField,\n  type ManyToOneField,\n  type OneToManyField,\n  type OneToOneField,\n  type PrimitiveField,\n  getMetadata,\n} from \"src/EntityMetadata.ts\";\nimport type { LoadHint } from \"src/loading/loadHints.ts\";\nimport { AbstractRelationImpl } from \"src/relations/AbstractRelationImpl.ts\";\nimport { isProperty } from \"src/relations/index.ts\";\n\n/** Generically matches on a Reference/Collection's load method. */\ntype LoadLike<U> = { load(): Promise<U> };\n\n/** Generically matches a property or zero-arg method that returns a promise. */\ntype PromiseFnLike<U> = () => PromiseLike<U>;\n\n/**\n * Given a parent type `R` (that is our current lens \"return type\", i.e. `Author` or `Author | undefined` or `Author[]`),\n * and the type `V` of the \"next step\" of the traversal (i.e. itself `Book` or `Book | undefined` or `Book[]`, depending\n * on the relation being traversed), returns `V` mapped to \"the right format\" based on `R`.\n *\n * I.e.:\n *\n * - `Author | undefined` that navigates a `Book` will become `Book | undefined`\n * - `Author` that navigates a `Book | undefined` will also become `Book | undefined`\n * - `Author[]` that navigates a `Book | undefined` will become a `Book[]`\n * - `Author | undefined` that navigates a `Book[]` will become a `Book[]`\n */\n// The extra `[]` around `V` and `ReadonlyArray<any>` are to keep the type as `Array<Foo | undefined>`\n// instead of `Foo[] | undefined[]`.\n// When `P extends ReadonlyArray, i.e. we're in flatMap mode, we're also in filter undefined mode.\ntype MaybeArray<R, V> =\n  R extends ReadonlyArray<any>\n    ? [V] extends [ReadonlyArray<infer U>]\n      ? DropUndefined<U>[]\n      : DropUndefined<V>[]\n    : V extends ReadonlyArray<any>\n      ? V\n      : [R] extends [undefined]\n        ? V | undefined\n        : V;\n\n// ([R] extends [undefined]) ? (V) : V;\n\n/** Given a type T that we come across in the path, de-array it to continue our flatMap-ish semantics. */\ntype MaybeDropArray<T> = T extends ReadonlyArray<infer U> ? U : T;\n\ntype DropUndefined<T> = Exclude<T, undefined>;\n\n/**\n * A type for declaratively walking the object graph.\n *\n * This is not technically a Lens that can `get/set`, but the idea is generally the same.\n *\n * `T` is the type we're on, i.e. when `T = Author` we can do `.firstName` or `.lastName.\n * `R` is either a `T` or `T[]` or `T | undefined` and just captures whether we've hit a\n * list at any point in the lens navigation path.\n */\nexport type Lens<T, R = T> = {\n  [P in keyof T]: T[P] extends LoadLike<infer U>\n    ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>>\n    : T[P] extends PromiseFnLike<infer U>\n      ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>>\n      : Lens<MaybeDropArray<DropUndefined<T[P]>>, MaybeArray<R, T[P]>>;\n};\n\n/**\n * Allows declaratively loading/traversing several layers of references at once.\n *\n * I.e.:\n *\n * ```typescript\n * const publisher = await book.load(b => b.author.publisher);\n * ```\n */\n// For some reason accepting Lens<this, this> does not work when called from within the entity\n// subclass itself, so we use the codegen hammer in our subclass to force the right Lens type\n// in a .load stub that just calls us for the implementation.\nexport async function loadLens<T extends Entity, U, V>(\n  start: T | readonly T[],\n  fn: (lens: Lens<T>) => Lens<U, V>,\n  opts: { forceReload?: boolean; sql?: boolean } = {},\n): Promise<V> {\n  return loadLensPath(start, collectPaths(fn), opts);\n}\n\n/** Loads a precomputed lens path, avoiding repeated lambda/proxy evaluation for long-lived relation declarations. */\nexport function loadLensPath<T extends Entity, V>(\n  start: T | readonly T[],\n  paths: string[],\n  opts: { forceReload?: boolean; sql?: boolean } = {},\n): Promise<V> {\n  // Probe for the meta, so we can track when/if it needs to flip to a collection (even after hitting undefined)\n  const meta = Array.isArray(start)\n    ? isEntity(start[0]) && getMetadata(start[0])\n    : isEntity(start) && getMetadata(start);\n  // This should only happen for `start=[]`, which we know should return `[]`\n  if (!meta) return [] as unknown as Promise<V>;\n\n  // If we're already loaded, just return\n  if (!opts.forceReload && isLensLoadedPath(start, paths)) {\n    // Keep this synchronous to avoid adding a promise turn; this preserves nuanced hook timing in production code.\n    return getLensPath(meta, start, paths) as Promise<V>;\n  }\n\n  return loadLensPathAsync(meta, start, paths, opts);\n}\n\n/**\n * Loads an unloaded lens path, keeping the already-loaded shortcut in `loadLensPath` synchronous.\n *\n * I.e. this avoids adding an extra promise turn for already-loaded paths during concurrent hooks.\n */\nasync function loadLensPathAsync<T extends Entity, V>(\n  meta: EntityMetadata,\n  start: T | readonly T[],\n  paths: string[],\n  opts: { forceReload?: boolean; sql?: boolean },\n): Promise<V> {\n  // See if we can load this via SQL\n  if (opts.sql) {\n    // Are all paths SQL query-able?\n    if (!isAllSqlPaths(meta, paths)) {\n      throw new Error(\"Cannot use loadLens opts.sql with non-SQL paths\");\n    }\n    // If there is only 1 path, don't both with the fancy join\n    if (paths.length > 1) {\n      // TODO We can only do this is _none_ of the paths are loaded, otherwise we'll miss WIP mutations\n      if (isReadOnlyArray(start)) {\n        const em = start[0].em;\n        return (await lensDataLoader(em, meta.cstr, true, paths)\n          .loadMany(start.map((e) => e.idTagged))\n          .catch(function loadLens(err) {\n            throw appendStack(err, new Error());\n          })) as V;\n      } else {\n        const em = start.em;\n        return (await lensDataLoader(em, meta.cstr, false, paths)\n          .load(start.idTagged)\n          .catch(function loadLens(err) {\n            throw appendStack(err, new Error());\n          })) as V;\n      }\n    }\n  }\n\n  // This could be `Entity | Entity[] | undefined` as we keep walking\n  let current: any = start;\n  let currentMeta: EntityMetadata | undefined = meta;\n  let seenSoftDeleted = false;\n  // Now evaluate each step of the path\n  for (const path of paths) {\n    const field = currentMeta?.allFields[path] as\n      | ManyToOneField\n      | ManyToManyField\n      | OneToManyField\n      | OneToOneField\n      | PrimitiveField\n      | undefined;\n    if (Array.isArray(current)) {\n      current = (await Promise.all(current.map((c) => maybeLoad(c, path, opts)))).flat();\n      current = [...new Set(current.filter((c: any) => c !== undefined && !c.isSoftDeletedEntity))];\n      // As soon as we hit `current=[]`, we can early return (...`current=undefined` cannot b/c the next path might flip to a list)\n      if (current.length === 0) return current!;\n    } else if (current) {\n      current = await maybeLoad(current, path, opts);\n      seenSoftDeleted ||= (current as any)?.isSoftDeletedEntity;\n      // If we had been traversing m2o -> m2o (i.e. book -> author) and just hit an o2m/m2m (i.e.\n      // book -> author -> comments), and any of our prior m2os like `author` had been soft deleted,\n      // just filter everything out.\n      //\n      // Otherwise, we keep `book -> author`, even if author is soft-deleted, b/c it changes the return\n      // type from \"author\" to \"author | undefined\".\n      if (Array.isArray(current) && seenSoftDeleted) {\n        return [] as any;\n      }\n    } else {\n      // current is undefined; see if we should flip to a list ... which means we can early return\n      if (field?.kind === \"o2m\" || field?.kind === \"m2m\") return [] as any;\n    }\n    currentMeta = nextMeta(current, field);\n  }\n  return current!;\n}\n\nexport function isAllSqlPaths(meta: EntityMetadata, paths: string[]): boolean {\n  for (let i = 0, current = meta; i < paths.length; i++) {\n    const next = current.allFields[paths[i]];\n    if (next && (next.kind === \"m2o\" || next.kind === \"m2m\" || next.kind === \"o2m\" || next.kind === \"o2o\")) {\n      current = next.otherMetadata();\n    } else {\n      return false;\n    }\n  }\n  return true;\n}\n\n// Given BookReview+[book, author] return [Author, books+bookReviews]\nexport function mapPathsToTarget(source: EntityMetadata, paths: string[]): [EntityMetadata, [EntityMetadata, Field][]] {\n  let other = source;\n  let fields: [EntityMetadata, Field][] = [];\n  for (let i = 0; i < paths.length; i++) {\n    const next = other.allFields[paths[i]];\n    if (next && (next.kind === \"m2o\" || next.kind === \"m2m\" || next.kind === \"o2m\" || next.kind === \"o2o\")) {\n      other = next.otherMetadata();\n      fields.push([other, other.allFields[next.otherFieldName]]);\n    } else {\n      throw new Error(\"Either not an all-SQL path or not supported yet\");\n    }\n  }\n  return [other, fields.reverse()];\n}\n\nfunction maybeLoad(object: any, path: string, opts: { forceReload?: boolean }): unknown {\n  if (object === undefined || object === null) {\n    return undefined;\n  }\n  const value = object[path];\n  if (value && typeof value === \"object\" && \"load\" in value) {\n    return value.load(opts);\n  } else if (value && typeof value === \"function\") {\n    return value.apply(object);\n  } else {\n    return value;\n  }\n}\n\n/**\n * The synchronous version of `loadLens`.\n *\n * This assumes you've first evaluated the lens with `loadLens` and now can access it synchronously.\n */\nexport function getLens<T, U, V>(\n  startMeta: EntityMetadata,\n  start: T | readonly T[],\n  fn: (lens: Lens<T>) => Lens<U, V>,\n): V {\n  return getLensPath(startMeta, start, collectPaths(fn));\n}\n\n/** Synchronously traverses a precomputed lens path. */\nexport function getLensPath<T, V>(startMeta: EntityMetadata, start: T | readonly T[], paths: string[]): V {\n  let currentMeta: EntityMetadata | undefined = startMeta;\n  let current: any = start;\n  let seenSoftDeleted = false;\n  // Now evaluate each step of the path\n  for (const path of paths) {\n    // We might navigate into properties, at which point we won't know the currentMeta\n    const field = currentMeta?.allFields[path] as\n      | ManyToOneField\n      | ManyToManyField\n      | OneToManyField\n      | OneToOneField\n      | PrimitiveField\n      | undefined;\n    if (Array.isArray(current)) {\n      // Use a set to dedup as we go\n      const next = new Set();\n      // This can be a hot path, so avoid `map` and `flat` and just loop\n      for (const c of current) {\n        const value = maybeGet(c, path);\n        if (Array.isArray(value)) for (const v of value) maybeAdd(next, v);\n        else maybeAdd(next, value);\n      }\n      current = [...next];\n    } else if (current) {\n      current = maybeGet(current, path);\n      seenSoftDeleted ||= (current as any)?.isSoftDeletedEntity;\n      // If we had been traversing m2o -> m2o and just hit an o2m/m2m, and any of our\n      // prior m2os had been soft-deleted, just filter everything out.\n      if (Array.isArray(current) && seenSoftDeleted) {\n        return [] as any;\n      }\n    } else {\n      // current is undefined; see if we should flip to a list ... which means we can early return\n      if (field?.kind === \"o2m\" || field?.kind === \"m2m\") return [] as any;\n    }\n    currentMeta = nextMeta(current, field);\n  }\n  return current!;\n}\n\n/** Returns the next runtime metadata, preserving subtype-specific fields after base-typed traversals. */\nfunction nextMeta(current: unknown, field: Field | undefined): EntityMetadata | undefined {\n  const entity = Array.isArray(current) ? current[0] : current;\n  if (isEntity(entity)) return getMetadata(entity);\n  return field && \"otherMetadata\" in field ? field.otherMetadata() : undefined;\n}\n\nfunction maybeAdd(set: Set<any>, value: any) {\n  if (value !== undefined && !value.isSoftDeletedEntity) set.add(value);\n}\n\n/** Returns whether a lens is loaded; primarily for deeply loaded instances in tests. */\nexport function isLensLoaded<T, U, V>(start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>): boolean {\n  return isLensLoadedPath(start, collectPaths(fn));\n}\n\n/** Returns whether a precomputed lens path is loaded; primarily for deeply loaded instances in tests. */\nexport function isLensLoadedPath<T>(start: T | readonly T[], paths: string[]): boolean {\n  // This is a huge copy/paste of `getLens` but we check `isNotLoaded` and early return\n  // as soon as we find any not-loaded relation\n  let current: any = start;\n  let seenSoftDeleted = false;\n  // Now evaluate each step of the path\n  for (const path of paths) {\n    if (Array.isArray(current)) {\n      // Use a set to dedup as we go\n      const next = new Set();\n      for (const c of current) {\n        if (isNotLoaded(c, path)) return false;\n        const value = maybeGet(c, path);\n        if (Array.isArray(value)) for (const v of value) maybeAdd(next, v);\n        else maybeAdd(next, value);\n      }\n      current = [...next];\n    } else {\n      if (isNotLoaded(current, path)) return false;\n      current = maybeGet(current, path);\n      seenSoftDeleted ||= (current as any)?.isSoftDeletedEntity;\n      // If we had been traversing m2o -> m2o and just hit an o2m/m2m, and any of our\n      // prior m2os had been soft deleted, just filter everything out.\n      if (Array.isArray(current) && seenSoftDeleted) {\n        return true;\n      }\n    }\n  }\n  return true;\n}\n\n/** Accepts a lens like `a => a.books.reviews` and returns a hint like `{ books: { reviews: {} } }`. */\nexport function lensToLoadHint<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): LoadHint<T> {\n  return lensPathToLoadHint(collectPaths(fn));\n}\n\n/** Accepts lens paths like `[books, reviews]` and returns a hint like `{ books: { reviews: {} } }`. */\nexport function lensPathToLoadHint<T extends Entity>(paths: string[]): LoadHint<T> {\n  let current = {};\n  for (let i = paths.length - 1; i >= 0; i--) {\n    const path = paths[i];\n    current = { [path]: current };\n  }\n  return current as LoadHint<T>;\n}\n\n/** Accepts a lens like `a => a.books.reviews` and returns the paths like `[books, reviews]`. */\nexport function lensToPath<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): string[] {\n  return [...collectPaths(fn)];\n}\n\nfunction isNotLoaded(object: any, path: string): boolean {\n  const value = object && object[path];\n  if (value instanceof AbstractRelationImpl || isProperty(value)) {\n    return !value.isLoaded;\n  }\n  return false;\n}\n\nfunction maybeGet(object: any, path: string): unknown {\n  if (object === undefined || object === null) {\n    return undefined;\n  }\n  const value = object[path];\n  if (typeof value === \"object\" && \"get\" in value) {\n    return value.get;\n  } else if (value && typeof value === \"function\") {\n    return value.apply(object);\n  } else {\n    return value;\n  }\n}\n\nfunction collectPaths(fn: Function): string[] {\n  const paths: string[] = [];\n  // The proxy collects the path navigations that the user's `fn` lambda invokes.\n  const proxy = new Proxy(\n    {},\n    {\n      get(_, property, receiver) {\n        paths.push(String(property));\n        return receiver;\n      },\n    },\n  );\n  // Invoke the lens function to record the navigation path on our proxy\n  fn(proxy as any);\n  return paths;\n}\n\n// Work around https://github.com/microsoft/TypeScript/issues/17002\nfunction isReadOnlyArray<T>(value: T | readonly T[]): value is readonly T[] {\n  return Array.isArray(value);\n}\n"],"mappings":"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"}

package/build/{withLoaded.cjs → loading/withLoaded.cjs}

@@ -1,16 +1,15 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_relations_Collection = require("./relations/Collection.cjs");
-const require_relations_hasProperty = require("./relations/hasProperty.cjs");
-const require_relations_Reference = require("./relations/Reference.cjs");
-const require_relations_ReactiveGetter = require("./relations/ReactiveGetter.cjs");
-const require_relations_Relation = require("./relations/Relation.cjs");
-const require_loadHints = require("./loadHints.cjs");
-const require_utils = require("./utils.cjs");
-const require_relations_ReactiveField = require("./relations/ReactiveField.cjs");
-const require_relations_AsyncReactiveField = require("./relations/AsyncReactiveField.cjs");
-require("./relations/index.cjs");
-require("./Entity.cjs");
-//#region src/withLoaded.ts
+const require_relations_Collection = require("../relations/Collection.cjs");
+const require_relations_ReactiveGetter = require("../relations/ReactiveGetter.cjs");
+const require_relations_Relation = require("../relations/Relation.cjs");
+const require_loading_loadHints = require("./loadHints.cjs");
+const require_relations_hasProperty = require("../relations/hasProperty.cjs");
+const require_relations_Reference = require("../relations/Reference.cjs");
+const require_relations_ReactiveField = require("../relations/ReactiveField.cjs");
+const require_relations_AsyncReactiveField = require("../relations/AsyncReactiveField.cjs");
+require("../relations/index.cjs");
+const require_utils = require("../utils.cjs");
+//#region src/loading/withLoaded.ts
 function withLoaded(loadedOrPromise) {
 	return require_utils.maybePromiseThen(loadedOrPromise, (loaded) => new Proxy(loaded, { get: (target, prop) => {
 		const value = target[prop];
@@ -20,7 +19,7 @@ function withLoaded(loadedOrPromise) {
 	} }));
 }
 function ensureWithLoaded(entity, hint) {
-	require_loadHints.assertLoaded(entity, hint);
+	require_loading_loadHints.assertLoaded(entity, hint);
 	return withLoaded(entity);
 }
 /**

package/build/loading/withLoaded.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"withLoaded.cjs","names":["maybePromiseThen","isRelation","isProperty","isReactiveField","isReactiveGetter","isAsyncReactiveField","isLoadedReference","isLoadedCollection","isLoadedProperty","isLoadedAsyncReactiveField","fail"],"sources":["../../src/loading/withLoaded.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport { type LoadHint, type Loaded, assertLoaded } from \"src/loading/loadHints.ts\";\nimport { isLoadedAsyncReactiveField } from \"src/relations/AsyncReactiveField.ts\";\nimport {\n  type LoadedCollection,\n  type LoadedProperty,\n  type LoadedReadOnlyCollection,\n  type LoadedReference,\n  type PolymorphicReference,\n  type Property,\n  type Relation,\n  isAsyncReactiveField,\n  isLoadedCollection,\n  isLoadedProperty,\n  isLoadedReference,\n  isProperty,\n  isReactiveField,\n  isReactiveGetter,\n  isRelation,\n} from \"src/relations/index.ts\";\nimport { type MaybePromise, fail, maybePromiseThen } from \"src/utils.ts\";\n\n// This type seems is overly complex for references, but it's necessary in order to ensure that potential\n// undefined references are properly propagated and that polymorphic references don't overwhelm the type system.\nexport type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = {\n  [\n    K in keyof L as L[K] extends { get: unknown } ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K\n  ]: L[K] extends PolymorphicReference<T, infer U, infer N>\n    ? L[K] extends LoadedReference<T, U, N>\n      ? U | N\n      : L[K]\n    : L[K] extends LoadedReference<T, infer U, never>\n      ? U\n      : L[K] extends LoadedReference<T, infer U, undefined>\n        ? U | undefined\n        : L[K] extends LoadedCollection<T, infer U>\n          ? U[]\n          : L[K] extends LoadedReadOnlyCollection<T, infer U>\n            ? // leaving out `readonly U[]` until we're ready to switch\n              U[]\n            : L[K] extends LoadedProperty<T, infer V>\n              ? V\n              : L[K];\n};\n\n/**\n * Allows destructuring against entities to more succinctly access loaded relations.\n *\n * ```typescript\n * // Instead of\n * const author = book.author.get;\n * // Use withLoaded\n * const { author } = withLoaded(book);\n * ```\n *\n * Granted, when accessing one property, this is not a win, but if you're accessing\n * ~3-4 separate loaded properties, then it can be more succinct than using `get`s\n * for each one.\n *\n * This function returns a proxy to an entity, instead of a real entity, and as such its return\n * value should only be used as part of a destructure and never directly assigned to a variable.\n *\n * This is also why the function is not recursive, as returning nested proxies could result in\n * them inadvertently being stored and passed to code that expects a real entity.\n */\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  promise: Promise<L>,\n): Promise<WithLoaded<T, H, L>>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  loaded: L,\n): WithLoaded<T, H, L>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  loadedOrPromise: MaybePromise<L> | L,\n): MaybePromise<WithLoaded<T, H, L>> {\n  return maybePromiseThen(\n    loadedOrPromise,\n    (loaded) =>\n      new Proxy(loaded, {\n        get: (target, prop) => {\n          const value: any = (target as any)[prop];\n          if (\n            isRelation(value) ||\n            isProperty(value) ||\n            isReactiveField(value) ||\n            isReactiveGetter(value) ||\n            isAsyncReactiveField(value)\n          ) {\n            return isLoadedReference(value) ||\n              isLoadedCollection(value) ||\n              isLoadedProperty(value) ||\n              isReactiveField(value) ||\n              isLoadedAsyncReactiveField(value) ||\n              isReactiveGetter(value)\n              ? value.get\n              : fail(`${target}.${String(prop)} is not loaded`);\n          } else if (value instanceof StubbedRelation) {\n            return value.get;\n          } else {\n            return value;\n          }\n        },\n      }) as WithLoaded<T, H, L>,\n  );\n}\n\nexport function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>(\n  entity: T,\n  hint: H,\n): WithLoaded<T, H, Loaded<T, H>> {\n  assertLoaded<T, H>(entity, hint);\n  return withLoaded(entity);\n}\n\n/**\n * Allow stubbing of relations with dummy values.\n *\n * In very advanced use cases (ideally only useful in tests, similar to mocking), it can be helpful\n * to have a relation returned a hard-coded value that doesn't go through the normal o2m/m2m\n * .load/.isLoaded/.get code paths.\n *\n * We'd originally done some of this by poking relation internal implementation details, but\n * using private fields like `#loaded` breaks that, and it was brittle anyway.\n *\n * So StubbedRelation provides a semi-blessed way of doing this, i.e. with code like:\n *\n * ```\n * // Force `author.books` to always be `[]` and never load.\n * Object.defineProperty(author, \"books\", {\n *   get: () => new StubbedRelation([]),\n *  });\n * ```\n */\nexport class StubbedRelation {\n  constructor(private value: any) {}\n\n  get get() {\n    return this.value;\n  }\n\n  get isLoaded() {\n    return true;\n  }\n\n  load() {\n    return this.get;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAuEA,SAAgB,WACd,iBACmC;CACnC,OAAOA,cAAAA,iBACL,kBACC,WACC,IAAI,MAAM,QAAQ,EAChB,MAAM,QAAQ,SAAS;EACrB,MAAM,QAAc,OAAe;EACnC,IACEC,2BAAAA,WAAW,KAAK,KAChBC,8BAAAA,WAAW,KAAK,KAChBC,gCAAAA,gBAAgB,KAAK,KACrBC,iCAAAA,iBAAiB,KAAK,KACtBC,qCAAAA,qBAAqB,KAAK,GAE1B,OAAOC,4BAAAA,kBAAkB,KAAK,KAC5BC,6BAAAA,mBAAmB,KAAK,KACxBC,8BAAAA,iBAAiB,KAAK,KACtBL,gCAAAA,gBAAgB,KAAK,KACrBM,qCAAAA,2BAA2B,KAAK,KAChCL,iCAAAA,iBAAiB,KAAK,IACpB,MAAM,MACNM,cAAAA,KAAK,GAAG,OAAO,GAAG,OAAO,IAAI,EAAE,eAAe;OAC7C,IAAI,iBAAiB,iBAC1B,OAAO,MAAM;OAEb,OAAO;CAEX,EACF,CAAC,CACL;AACF;AAEA,SAAgB,iBACd,QACA,MACgC;CAChC,0BAAA,aAAmB,QAAQ,IAAI;CAC/B,OAAO,WAAW,MAAM;AAC1B;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,kBAAb,MAA6B;CACP;CAApB,YAAY,OAAoB;EAAZ,KAAA,QAAA;CAAa;CAEjC,IAAI,MAAM;EACR,OAAO,KAAK;CACd;CAEA,IAAI,WAAW;EACb,OAAO;CACT;CAEA,OAAO;EACL,OAAO,KAAK;CACd;AACF"}

package/build/{withLoaded.d.cts → loading/withLoaded.d.cts}

@@ -1,13 +1,13 @@
-import { LoadedCollection } from "./relations/Collection.cjs";
-import { LoadedProperty, Property } from "./relations/hasProperty.cjs";
-import { LoadedReference } from "./relations/Reference.cjs";
-import { Relation } from "./relations/Relation.cjs";
-import { PolymorphicReference } from "./relations/PolymorphicReference.cjs";
-import { LoadedReadOnlyCollection } from "./relations/ReadOnlyCollection.cjs";
-import "./relations/index.cjs";
+import { LoadedCollection } from "../relations/Collection.cjs";
+import { LoadedProperty, Property } from "../relations/hasProperty.cjs";
+import { LoadedReference } from "../relations/Reference.cjs";
+import { Relation } from "../relations/Relation.cjs";
+import { PolymorphicReference } from "../relations/PolymorphicReference.cjs";
+import { LoadedReadOnlyCollection } from "../relations/ReadOnlyCollection.cjs";
+import "../relations/index.cjs";
 import { LoadHint, Loaded } from "./loadHints.cjs";
-import { Entity } from "./Entity.cjs";
-//#region src/withLoaded.d.ts
+import { Entity } from "../Entity.cjs";
+//#region src/loading/withLoaded.d.ts
 type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = { [K in keyof L as L[K] extends {
   get: unknown;
 } ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K]: L[K] extends PolymorphicReference<T, infer U, infer N> ? L[K] extends LoadedReference<T, U, N> ? U | N : L[K] : L[K] extends LoadedReference<T, infer U, never> ? U : L[K] extends LoadedReference<T, infer U, undefined> ? U | undefined : L[K] extends LoadedCollection<T, infer U> ? U[] : L[K] extends LoadedReadOnlyCollection<T, infer U> ? U[] : L[K] extends LoadedProperty<T, infer V> ? V : L[K]; };

package/build/loading/withLoaded.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withLoaded.d.cts","names":[],"sources":["../../src/loading/withLoaded.ts"],"mappings":";;;;;;;;;;KAwBY,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,SAEhF,WAAW,KAAK,EAAE;EAAa;IAAiB,IAAI,EAAE,WAAW,qBAAqB,6BAA6B,IAClH,EAAE,WAAW,qBAAqB,SAAS,SAAS,KACnD,EAAE,WAAW,gBAAgB,GAAG,GAAG,KACjC,IAAI,IACJ,EAAE,KACJ,EAAE,WAAW,gBAAgB,SAAS,YACpC,IACA,EAAE,WAAW,gBAAgB,SAAS,gBACpC,gBACA,EAAE,WAAW,iBAAiB,SAAS,KACrC,MACA,EAAE,WAAW,yBAAyB,SAAS,KAE7C,MACA,EAAE,WAAW,eAAe,SAAS,KACnC,IACA,EAAE;;;;;;;;;;;;;;;;;;;;;iBAuBF,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,SAAS,QAAQ,KAChB,QAAQ,WAAW,GAAG,GAAG;iBACZ,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,QAAQ,IACP,WAAW,GAAG,GAAG;iBAmCJ,iBAAiB,UAAU,cAAc,UAAU,SAAS,IAC1E,QAAQ,GACR,MAAM,IACL,WAAW,GAAG,GAAG,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;cAwBjB;UACS;EAApB,YAAoB;MAEhB;MAIA;EAIJ"}

package/build/{withLoaded.d.mts → loading/withLoaded.d.mts}

@@ -1,13 +1,13 @@
-import { LoadedCollection } from "./relations/Collection.mjs";
-import { LoadedProperty, Property } from "./relations/hasProperty.mjs";
-import { LoadedReference } from "./relations/Reference.mjs";
-import { Relation } from "./relations/Relation.mjs";
-import { PolymorphicReference } from "./relations/PolymorphicReference.mjs";
-import { LoadedReadOnlyCollection } from "./relations/ReadOnlyCollection.mjs";
-import "./relations/index.mjs";
+import { LoadedCollection } from "../relations/Collection.mjs";
+import { LoadedProperty, Property } from "../relations/hasProperty.mjs";
+import { LoadedReference } from "../relations/Reference.mjs";
+import { Relation } from "../relations/Relation.mjs";
+import { PolymorphicReference } from "../relations/PolymorphicReference.mjs";
+import { LoadedReadOnlyCollection } from "../relations/ReadOnlyCollection.mjs";
+import "../relations/index.mjs";
 import { LoadHint, Loaded } from "./loadHints.mjs";
-import { Entity } from "./Entity.mjs";
-//#region src/withLoaded.d.ts
+import { Entity } from "../Entity.mjs";
+//#region src/loading/withLoaded.d.ts
 type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = { [K in keyof L as L[K] extends {
   get: unknown;
 } ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K]: L[K] extends PolymorphicReference<T, infer U, infer N> ? L[K] extends LoadedReference<T, U, N> ? U | N : L[K] : L[K] extends LoadedReference<T, infer U, never> ? U : L[K] extends LoadedReference<T, infer U, undefined> ? U | undefined : L[K] extends LoadedCollection<T, infer U> ? U[] : L[K] extends LoadedReadOnlyCollection<T, infer U> ? U[] : L[K] extends LoadedProperty<T, infer V> ? V : L[K]; };

package/build/loading/withLoaded.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withLoaded.d.mts","names":[],"sources":["../../src/loading/withLoaded.ts"],"mappings":";;;;;;;;;;KAwBY,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,SAEhF,WAAW,KAAK,EAAE;EAAa;IAAiB,IAAI,EAAE,WAAW,qBAAqB,6BAA6B,IAClH,EAAE,WAAW,qBAAqB,SAAS,SAAS,KACnD,EAAE,WAAW,gBAAgB,GAAG,GAAG,KACjC,IAAI,IACJ,EAAE,KACJ,EAAE,WAAW,gBAAgB,SAAS,YACpC,IACA,EAAE,WAAW,gBAAgB,SAAS,gBACpC,gBACA,EAAE,WAAW,iBAAiB,SAAS,KACrC,MACA,EAAE,WAAW,yBAAyB,SAAS,KAE7C,MACA,EAAE,WAAW,eAAe,SAAS,KACnC,IACA,EAAE;;;;;;;;;;;;;;;;;;;;;iBAuBF,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,SAAS,QAAQ,KAChB,QAAQ,WAAW,GAAG,GAAG;iBACZ,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,QAAQ,IACP,WAAW,GAAG,GAAG;iBAmCJ,iBAAiB,UAAU,cAAc,UAAU,SAAS,IAC1E,QAAQ,GACR,MAAM,IACL,WAAW,GAAG,GAAG,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;cAwBjB;UACS;EAApB,YAAoB;MAEhB;MAIA;EAIJ"}

package/build/{withLoaded.js → loading/withLoaded.js}

@@ -1,15 +1,14 @@
-import { isLoadedCollection } from "./relations/Collection.js";
-import { isLoadedProperty, isProperty } from "./relations/hasProperty.js";
-import { isLoadedReference } from "./relations/Reference.js";
-import { isReactiveGetter } from "./relations/ReactiveGetter.js";
-import { isRelation } from "./relations/Relation.js";
+import { isLoadedCollection } from "../relations/Collection.js";
+import { isReactiveGetter } from "../relations/ReactiveGetter.js";
+import { isRelation } from "../relations/Relation.js";
 import { assertLoaded } from "./loadHints.js";
-import { fail, maybePromiseThen } from "./utils.js";
-import { isReactiveField } from "./relations/ReactiveField.js";
-import { isAsyncReactiveField, isLoadedAsyncReactiveField } from "./relations/AsyncReactiveField.js";
-import "./relations/index.js";
-import "./Entity.js";
-//#region src/withLoaded.ts
+import { isLoadedProperty, isProperty } from "../relations/hasProperty.js";
+import { isLoadedReference } from "../relations/Reference.js";
+import { isReactiveField } from "../relations/ReactiveField.js";
+import { isAsyncReactiveField, isLoadedAsyncReactiveField } from "../relations/AsyncReactiveField.js";
+import "../relations/index.js";
+import { fail, maybePromiseThen } from "../utils.js";
+//#region src/loading/withLoaded.ts
 function withLoaded(loadedOrPromise) {
 	return maybePromiseThen(loadedOrPromise, (loaded) => new Proxy(loaded, { get: (target, prop) => {
 		const value = target[prop];

package/build/loading/withLoaded.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withLoaded.js","names":[],"sources":["../../src/loading/withLoaded.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport { type LoadHint, type Loaded, assertLoaded } from \"src/loading/loadHints.ts\";\nimport { isLoadedAsyncReactiveField } from \"src/relations/AsyncReactiveField.ts\";\nimport {\n  type LoadedCollection,\n  type LoadedProperty,\n  type LoadedReadOnlyCollection,\n  type LoadedReference,\n  type PolymorphicReference,\n  type Property,\n  type Relation,\n  isAsyncReactiveField,\n  isLoadedCollection,\n  isLoadedProperty,\n  isLoadedReference,\n  isProperty,\n  isReactiveField,\n  isReactiveGetter,\n  isRelation,\n} from \"src/relations/index.ts\";\nimport { type MaybePromise, fail, maybePromiseThen } from \"src/utils.ts\";\n\n// This type seems is overly complex for references, but it's necessary in order to ensure that potential\n// undefined references are properly propagated and that polymorphic references don't overwhelm the type system.\nexport type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = {\n  [\n    K in keyof L as L[K] extends { get: unknown } ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K\n  ]: L[K] extends PolymorphicReference<T, infer U, infer N>\n    ? L[K] extends LoadedReference<T, U, N>\n      ? U | N\n      : L[K]\n    : L[K] extends LoadedReference<T, infer U, never>\n      ? U\n      : L[K] extends LoadedReference<T, infer U, undefined>\n        ? U | undefined\n        : L[K] extends LoadedCollection<T, infer U>\n          ? U[]\n          : L[K] extends LoadedReadOnlyCollection<T, infer U>\n            ? // leaving out `readonly U[]` until we're ready to switch\n              U[]\n            : L[K] extends LoadedProperty<T, infer V>\n              ? V\n              : L[K];\n};\n\n/**\n * Allows destructuring against entities to more succinctly access loaded relations.\n *\n * ```typescript\n * // Instead of\n * const author = book.author.get;\n * // Use withLoaded\n * const { author } = withLoaded(book);\n * ```\n *\n * Granted, when accessing one property, this is not a win, but if you're accessing\n * ~3-4 separate loaded properties, then it can be more succinct than using `get`s\n * for each one.\n *\n * This function returns a proxy to an entity, instead of a real entity, and as such its return\n * value should only be used as part of a destructure and never directly assigned to a variable.\n *\n * This is also why the function is not recursive, as returning nested proxies could result in\n * them inadvertently being stored and passed to code that expects a real entity.\n */\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  promise: Promise<L>,\n): Promise<WithLoaded<T, H, L>>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  loaded: L,\n): WithLoaded<T, H, L>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  loadedOrPromise: MaybePromise<L> | L,\n): MaybePromise<WithLoaded<T, H, L>> {\n  return maybePromiseThen(\n    loadedOrPromise,\n    (loaded) =>\n      new Proxy(loaded, {\n        get: (target, prop) => {\n          const value: any = (target as any)[prop];\n          if (\n            isRelation(value) ||\n            isProperty(value) ||\n            isReactiveField(value) ||\n            isReactiveGetter(value) ||\n            isAsyncReactiveField(value)\n          ) {\n            return isLoadedReference(value) ||\n              isLoadedCollection(value) ||\n              isLoadedProperty(value) ||\n              isReactiveField(value) ||\n              isLoadedAsyncReactiveField(value) ||\n              isReactiveGetter(value)\n              ? value.get\n              : fail(`${target}.${String(prop)} is not loaded`);\n          } else if (value instanceof StubbedRelation) {\n            return value.get;\n          } else {\n            return value;\n          }\n        },\n      }) as WithLoaded<T, H, L>,\n  );\n}\n\nexport function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>(\n  entity: T,\n  hint: H,\n): WithLoaded<T, H, Loaded<T, H>> {\n  assertLoaded<T, H>(entity, hint);\n  return withLoaded(entity);\n}\n\n/**\n * Allow stubbing of relations with dummy values.\n *\n * In very advanced use cases (ideally only useful in tests, similar to mocking), it can be helpful\n * to have a relation returned a hard-coded value that doesn't go through the normal o2m/m2m\n * .load/.isLoaded/.get code paths.\n *\n * We'd originally done some of this by poking relation internal implementation details, but\n * using private fields like `#loaded` breaks that, and it was brittle anyway.\n *\n * So StubbedRelation provides a semi-blessed way of doing this, i.e. with code like:\n *\n * ```\n * // Force `author.books` to always be `[]` and never load.\n * Object.defineProperty(author, \"books\", {\n *   get: () => new StubbedRelation([]),\n *  });\n * ```\n */\nexport class StubbedRelation {\n  constructor(private value: any) {}\n\n  get get() {\n    return this.value;\n  }\n\n  get isLoaded() {\n    return true;\n  }\n\n  load() {\n    return this.get;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAuEA,SAAgB,WACd,iBACmC;CACnC,OAAO,iBACL,kBACC,WACC,IAAI,MAAM,QAAQ,EAChB,MAAM,QAAQ,SAAS;EACrB,MAAM,QAAc,OAAe;EACnC,IACE,WAAW,KAAK,KAChB,WAAW,KAAK,KAChB,gBAAgB,KAAK,KACrB,iBAAiB,KAAK,KACtB,qBAAqB,KAAK,GAE1B,OAAO,kBAAkB,KAAK,KAC5B,mBAAmB,KAAK,KACxB,iBAAiB,KAAK,KACtB,gBAAgB,KAAK,KACrB,2BAA2B,KAAK,KAChC,iBAAiB,KAAK,IACpB,MAAM,MACN,KAAK,GAAG,OAAO,GAAG,OAAO,IAAI,EAAE,eAAe;OAC7C,IAAI,iBAAiB,iBAC1B,OAAO,MAAM;OAEb,OAAO;CAEX,EACF,CAAC,CACL;AACF;AAEA,SAAgB,iBACd,QACA,MACgC;CAChC,aAAmB,QAAQ,IAAI;CAC/B,OAAO,WAAW,MAAM;AAC1B;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,kBAAb,MAA6B;CACP;CAApB,YAAY,OAAoB;EAAZ,KAAA,QAAA;CAAa;CAEjC,IAAI,MAAM;EACR,OAAO,KAAK;CACd;CAEA,IAAI,WAAW;EACb,OAAO;CACT;CAEA,OAAO;EACL,OAAO,KAAK;CACd;AACF"}

package/build/logging/FactoryLogger.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"FactoryLogger.cjs","names":["getCallerName"],"sources":["../../src/logging/FactoryLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\n\nimport { getCallerName } from \"../config.ts\";\nimport { type Entity } from \"../Entity.ts\";\nimport { type EntityMetadata } from \"../EntityMetadata.ts\";\nimport { type UseMapSource } from \"../newTestInstance.ts\";\n\nlet writer: WriteFn | undefined = undefined;\nexport type WriteFn = (line: string) => void;\n\nconst { gray, green, yellow } = ansis;\n\nexport class FactoryLogger {\n  private level = 0;\n  private writeFn: WriteFn;\n  private skipNextLogCreating = false;\n\n  // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n  // adding \"...at...\" stack traces to our output.\n  constructor() {\n    this.writeFn = writer ?? process.stdout.write.bind(process.stdout);\n  }\n\n  logCreating(cstr: any): void {\n    // This was already logged by the parent `field = creating new`\n    if (this.skipNextLogCreating) {\n      this.skipNextLogCreating = false;\n    } else {\n      this.write(\"Creating\", green.bold(`new ${cstr.name}`), gray(`at ${getCallerName(2)}`));\n    }\n  }\n\n  logAddToUseMap(e: Entity, source: UseMapSource): void {\n    if (source === \"sameBranch\" || source === \"diffBranch\") {\n      this.write(`${gray(`created`)} ${e.toString()} ${gray(\"added to scope\")}`);\n    } else {\n      this.write(`${gray(`...adding`)} ${e.toString()} ${gray(\"opt to scope\")}`);\n    }\n  }\n\n  logCreated(e: Entity): void {\n    // This matches the `logAddToUseMap` but for entities not going into scope\n    this.write(`${gray(`created`)} ${e.toString()}`);\n  }\n\n  logFoundExisting(e: Entity): void {\n    // Make this yellow because it reverses the \"new Entity\" we thought we were going to do\n    this.write(`${yellow(`using existing`)} ${e.toString()}`);\n  }\n\n  logFoundOpt(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from opt\")}`);\n  }\n\n  logNotFoundAndCreating(fieldName: string, meta: EntityMetadata): void {\n    this.write(`${gray(`${fieldName} =`)} creating ${green.bold(`new ${meta.type}`)}`);\n    this.skipNextLogCreating = true;\n  }\n\n  logFoundInUseMap(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from scope\")}`);\n  }\n\n  logFoundSingleEntity(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from em\")}`);\n  }\n\n  indent() {\n    this.level++;\n  }\n\n  dedent() {\n    this.level--;\n  }\n\n  private write(...line: string[]): void {\n    this.writeFn(this.prefix() + line.join(\" \") + \"\\n\");\n  }\n\n  private prefix() {\n    return \"  \".repeat(this.level);\n  }\n}\n\n// Allow our test suite observe the logger behavior\nexport function setFactoryWriter(write: WriteFn | undefined): void {\n  writer = write;\n}\n"],"mappings":";;;;;;;;;AAOA,IAAI,SAA8B,KAAA;AAGlC,MAAM,EAAE,MAAM,OAAO,WAAW,MAAA;AAEhC,IAAa,gBAAb,MAA2B;CACzB,QAAgB;CAChB;CACA,sBAA8B;CAI9B,cAAc;EACZ,KAAK,UAAU,UAAU,QAAQ,OAAO,MAAM,KAAK,QAAQ,MAAM;CACnE;CAEA,YAAY,MAAiB;EAE3B,IAAI,KAAK,qBACP,KAAK,sBAAsB;OAE3B,KAAK,MAAM,YAAY,MAAM,KAAK,OAAO,KAAK,MAAM,GAAG,KAAK,MAAMA,eAAAA,cAAc,CAAC,GAAG,CAAC;CAEzF;CAEA,eAAe,GAAW,QAA4B;EACpD,IAAI,WAAW,gBAAgB,WAAW,cACxC,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,gBAAgB,GAAG;OAEzE,KAAK,MAAM,GAAG,KAAK,WAAW,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,cAAc,GAAG;CAE7E;CAEA,WAAW,GAAiB;EAE1B,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,GAAG,EAAE,SAAS,GAAG;CACjD;CAEA,iBAAiB,GAAiB;EAEhC,KAAK,MAAM,GAAG,OAAO,gBAAgB,EAAE,GAAG,EAAE,SAAS,GAAG;CAC1D;CAEA,YAAY,WAAmB,GAAiB;EAC9C,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,UAAU,GAAG;CAC5E;CAEA,uBAAuB,WAAmB,MAA4B;EACpE,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,YAAY,MAAM,KAAK,OAAO,KAAK,MAAM,GAAG;EACjF,KAAK,sBAAsB;CAC7B;CAEA,iBAAiB,WAAmB,GAAiB;EACnD,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,YAAY,GAAG;CAC9E;CAEA,qBAAqB,WAAmB,GAAiB;EACvD,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,SAAS,GAAG;CAC3E;CAEA,SAAS;EACP,KAAK;CACP;CAEA,SAAS;EACP,KAAK;CACP;CAEA,MAAc,GAAG,MAAsB;EACrC,KAAK,QAAQ,KAAK,OAAO,IAAI,KAAK,KAAK,GAAG,IAAI,IAAI;CACpD;CAEA,SAAiB;EACf,OAAO,KAAK,OAAO,KAAK,KAAK;CAC/B;AACF;AAGA,SAAgB,iBAAiB,OAAkC;CACjE,SAAS;AACX"}
+{"version":3,"file":"FactoryLogger.cjs","names":["getCallerName"],"sources":["../../src/logging/FactoryLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\nimport { getCallerName } from \"src/config.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityMetadata } from \"src/EntityMetadata.ts\";\nimport { type UseMapSource } from \"src/newTestInstance.ts\";\n\nlet writer: WriteFn | undefined = undefined;\nexport type WriteFn = (line: string) => void;\n\nconst { gray, green, yellow } = ansis;\n\nexport class FactoryLogger {\n  private level = 0;\n  private writeFn: WriteFn;\n  private skipNextLogCreating = false;\n\n  // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n  // adding \"...at...\" stack traces to our output.\n  constructor() {\n    this.writeFn = writer ?? process.stdout.write.bind(process.stdout);\n  }\n\n  logCreating(cstr: any): void {\n    // This was already logged by the parent `field = creating new`\n    if (this.skipNextLogCreating) {\n      this.skipNextLogCreating = false;\n    } else {\n      this.write(\"Creating\", green.bold(`new ${cstr.name}`), gray(`at ${getCallerName(2)}`));\n    }\n  }\n\n  logAddToUseMap(e: Entity, source: UseMapSource): void {\n    if (source === \"sameBranch\" || source === \"diffBranch\") {\n      this.write(`${gray(`created`)} ${e.toString()} ${gray(\"added to scope\")}`);\n    } else {\n      this.write(`${gray(`...adding`)} ${e.toString()} ${gray(\"opt to scope\")}`);\n    }\n  }\n\n  logCreated(e: Entity): void {\n    // This matches the `logAddToUseMap` but for entities not going into scope\n    this.write(`${gray(`created`)} ${e.toString()}`);\n  }\n\n  logFoundExisting(e: Entity): void {\n    // Make this yellow because it reverses the \"new Entity\" we thought we were going to do\n    this.write(`${yellow(`using existing`)} ${e.toString()}`);\n  }\n\n  logFoundOpt(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from opt\")}`);\n  }\n\n  logNotFoundAndCreating(fieldName: string, meta: EntityMetadata): void {\n    this.write(`${gray(`${fieldName} =`)} creating ${green.bold(`new ${meta.type}`)}`);\n    this.skipNextLogCreating = true;\n  }\n\n  logFoundInUseMap(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from scope\")}`);\n  }\n\n  logFoundSingleEntity(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from em\")}`);\n  }\n\n  indent() {\n    this.level++;\n  }\n\n  dedent() {\n    this.level--;\n  }\n\n  private write(...line: string[]): void {\n    this.writeFn(this.prefix() + line.join(\" \") + \"\\n\");\n  }\n\n  private prefix() {\n    return \"  \".repeat(this.level);\n  }\n}\n\n// Allow our test suite observe the logger behavior\nexport function setFactoryWriter(write: WriteFn | undefined): void {\n  writer = write;\n}\n"],"mappings":";;;;;;;;;AAMA,IAAI,SAA8B,KAAA;AAGlC,MAAM,EAAE,MAAM,OAAO,WAAW,MAAA;AAEhC,IAAa,gBAAb,MAA2B;CACzB,QAAgB;CAChB;CACA,sBAA8B;CAI9B,cAAc;EACZ,KAAK,UAAU,UAAU,QAAQ,OAAO,MAAM,KAAK,QAAQ,MAAM;CACnE;CAEA,YAAY,MAAiB;EAE3B,IAAI,KAAK,qBACP,KAAK,sBAAsB;OAE3B,KAAK,MAAM,YAAY,MAAM,KAAK,OAAO,KAAK,MAAM,GAAG,KAAK,MAAMA,eAAAA,cAAc,CAAC,GAAG,CAAC;CAEzF;CAEA,eAAe,GAAW,QAA4B;EACpD,IAAI,WAAW,gBAAgB,WAAW,cACxC,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,gBAAgB,GAAG;OAEzE,KAAK,MAAM,GAAG,KAAK,WAAW,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,cAAc,GAAG;CAE7E;CAEA,WAAW,GAAiB;EAE1B,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,GAAG,EAAE,SAAS,GAAG;CACjD;CAEA,iBAAiB,GAAiB;EAEhC,KAAK,MAAM,GAAG,OAAO,gBAAgB,EAAE,GAAG,EAAE,SAAS,GAAG;CAC1D;CAEA,YAAY,WAAmB,GAAiB;EAC9C,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,UAAU,GAAG;CAC5E;CAEA,uBAAuB,WAAmB,MAA4B;EACpE,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,YAAY,MAAM,KAAK,OAAO,KAAK,MAAM,GAAG;EACjF,KAAK,sBAAsB;CAC7B;CAEA,iBAAiB,WAAmB,GAAiB;EACnD,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,YAAY,GAAG;CAC9E;CAEA,qBAAqB,WAAmB,GAAiB;EACvD,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,SAAS,GAAG;CAC3E;CAEA,SAAS;EACP,KAAK;CACP;CAEA,SAAS;EACP,KAAK;CACP;CAEA,MAAc,GAAG,MAAsB;EACrC,KAAK,QAAQ,KAAK,OAAO,IAAI,KAAK,KAAK,GAAG,IAAI,IAAI;CACpD;CAEA,SAAiB;EACf,OAAO,KAAK,OAAO,KAAK,KAAK;CAC/B;AACF;AAGA,SAAgB,iBAAiB,OAAkC;CACjE,SAAS;AACX"}

package/build/logging/FactoryLogger.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"FactoryLogger.d.cts","names":[],"sources":["../../src/logging/FactoryLogger.ts"],"mappings":";;;;KAQY,WAAW;cAIV;UACH;UACA;UACA;EAIR;EAIA,YAAY;EASZ,eAAe,GAAG,QAAQ,QAAQ;EAQlC,WAAW,GAAG;EAKd,iBAAiB,GAAG;EAKpB,YAAY,mBAAmB,GAAG;EAIlC,uBAAuB,mBAAmB,MAAM;EAKhD,iBAAiB,mBAAmB,GAAG;EAIvC,qBAAqB,mBAAmB,GAAG;EAI3C;EAIA;UAIQ;UAIA;;iBAMM,iBAAiB,OAAO"}
+{"version":3,"file":"FactoryLogger.d.cts","names":[],"sources":["../../src/logging/FactoryLogger.ts"],"mappings":";;;;KAOY,WAAW;cAIV;UACH;UACA;UACA;EAIR;EAIA,YAAY;EASZ,eAAe,GAAG,QAAQ,QAAQ;EAQlC,WAAW,GAAG;EAKd,iBAAiB,GAAG;EAKpB,YAAY,mBAAmB,GAAG;EAIlC,uBAAuB,mBAAmB,MAAM;EAKhD,iBAAiB,mBAAmB,GAAG;EAIvC,qBAAqB,mBAAmB,GAAG;EAI3C;EAIA;UAIQ;UAIA;;iBAMM,iBAAiB,OAAO"}

package/build/logging/FactoryLogger.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"FactoryLogger.d.mts","names":[],"sources":["../../src/logging/FactoryLogger.ts"],"mappings":";;;;KAQY,WAAW;cAIV;UACH;UACA;UACA;EAIR;EAIA,YAAY;EASZ,eAAe,GAAG,QAAQ,QAAQ;EAQlC,WAAW,GAAG;EAKd,iBAAiB,GAAG;EAKpB,YAAY,mBAAmB,GAAG;EAIlC,uBAAuB,mBAAmB,MAAM;EAKhD,iBAAiB,mBAAmB,GAAG;EAIvC,qBAAqB,mBAAmB,GAAG;EAI3C;EAIA;UAIQ;UAIA;;iBAMM,iBAAiB,OAAO"}
+{"version":3,"file":"FactoryLogger.d.mts","names":[],"sources":["../../src/logging/FactoryLogger.ts"],"mappings":";;;;KAOY,WAAW;cAIV;UACH;UACA;UACA;EAIR;EAIA,YAAY;EASZ,eAAe,GAAG,QAAQ,QAAQ;EAQlC,WAAW,GAAG;EAKd,iBAAiB,GAAG;EAKpB,YAAY,mBAAmB,GAAG;EAIlC,uBAAuB,mBAAmB,MAAM;EAKhD,iBAAiB,mBAAmB,GAAG;EAIvC,qBAAqB,mBAAmB,GAAG;EAI3C;EAIA;UAIQ;UAIA;;iBAMM,iBAAiB,OAAO"}

package/build/logging/FactoryLogger.js.map

@@ -1 +1 @@
-{"version":3,"file":"FactoryLogger.js","names":[],"sources":["../../src/logging/FactoryLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\n\nimport { getCallerName } from \"../config.ts\";\nimport { type Entity } from \"../Entity.ts\";\nimport { type EntityMetadata } from \"../EntityMetadata.ts\";\nimport { type UseMapSource } from \"../newTestInstance.ts\";\n\nlet writer: WriteFn | undefined = undefined;\nexport type WriteFn = (line: string) => void;\n\nconst { gray, green, yellow } = ansis;\n\nexport class FactoryLogger {\n  private level = 0;\n  private writeFn: WriteFn;\n  private skipNextLogCreating = false;\n\n  // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n  // adding \"...at...\" stack traces to our output.\n  constructor() {\n    this.writeFn = writer ?? process.stdout.write.bind(process.stdout);\n  }\n\n  logCreating(cstr: any): void {\n    // This was already logged by the parent `field = creating new`\n    if (this.skipNextLogCreating) {\n      this.skipNextLogCreating = false;\n    } else {\n      this.write(\"Creating\", green.bold(`new ${cstr.name}`), gray(`at ${getCallerName(2)}`));\n    }\n  }\n\n  logAddToUseMap(e: Entity, source: UseMapSource): void {\n    if (source === \"sameBranch\" || source === \"diffBranch\") {\n      this.write(`${gray(`created`)} ${e.toString()} ${gray(\"added to scope\")}`);\n    } else {\n      this.write(`${gray(`...adding`)} ${e.toString()} ${gray(\"opt to scope\")}`);\n    }\n  }\n\n  logCreated(e: Entity): void {\n    // This matches the `logAddToUseMap` but for entities not going into scope\n    this.write(`${gray(`created`)} ${e.toString()}`);\n  }\n\n  logFoundExisting(e: Entity): void {\n    // Make this yellow because it reverses the \"new Entity\" we thought we were going to do\n    this.write(`${yellow(`using existing`)} ${e.toString()}`);\n  }\n\n  logFoundOpt(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from opt\")}`);\n  }\n\n  logNotFoundAndCreating(fieldName: string, meta: EntityMetadata): void {\n    this.write(`${gray(`${fieldName} =`)} creating ${green.bold(`new ${meta.type}`)}`);\n    this.skipNextLogCreating = true;\n  }\n\n  logFoundInUseMap(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from scope\")}`);\n  }\n\n  logFoundSingleEntity(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from em\")}`);\n  }\n\n  indent() {\n    this.level++;\n  }\n\n  dedent() {\n    this.level--;\n  }\n\n  private write(...line: string[]): void {\n    this.writeFn(this.prefix() + line.join(\" \") + \"\\n\");\n  }\n\n  private prefix() {\n    return \"  \".repeat(this.level);\n  }\n}\n\n// Allow our test suite observe the logger behavior\nexport function setFactoryWriter(write: WriteFn | undefined): void {\n  writer = write;\n}\n"],"mappings":";;;;;;AAOA,IAAI,SAA8B,KAAA;AAGlC,MAAM,EAAE,MAAM,OAAO,WAAW;AAEhC,IAAa,gBAAb,MAA2B;CACzB,QAAgB;CAChB;CACA,sBAA8B;CAI9B,cAAc;EACZ,KAAK,UAAU,UAAU,QAAQ,OAAO,MAAM,KAAK,QAAQ,MAAM;CACnE;CAEA,YAAY,MAAiB;EAE3B,IAAI,KAAK,qBACP,KAAK,sBAAsB;OAE3B,KAAK,MAAM,YAAY,MAAM,KAAK,OAAO,KAAK,MAAM,GAAG,KAAK,MAAM,cAAc,CAAC,GAAG,CAAC;CAEzF;CAEA,eAAe,GAAW,QAA4B;EACpD,IAAI,WAAW,gBAAgB,WAAW,cACxC,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,gBAAgB,GAAG;OAEzE,KAAK,MAAM,GAAG,KAAK,WAAW,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,cAAc,GAAG;CAE7E;CAEA,WAAW,GAAiB;EAE1B,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,GAAG,EAAE,SAAS,GAAG;CACjD;CAEA,iBAAiB,GAAiB;EAEhC,KAAK,MAAM,GAAG,OAAO,gBAAgB,EAAE,GAAG,EAAE,SAAS,GAAG;CAC1D;CAEA,YAAY,WAAmB,GAAiB;EAC9C,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,UAAU,GAAG;CAC5E;CAEA,uBAAuB,WAAmB,MAA4B;EACpE,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,YAAY,MAAM,KAAK,OAAO,KAAK,MAAM,GAAG;EACjF,KAAK,sBAAsB;CAC7B;CAEA,iBAAiB,WAAmB,GAAiB;EACnD,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,YAAY,GAAG;CAC9E;CAEA,qBAAqB,WAAmB,GAAiB;EACvD,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,SAAS,GAAG;CAC3E;CAEA,SAAS;EACP,KAAK;CACP;CAEA,SAAS;EACP,KAAK;CACP;CAEA,MAAc,GAAG,MAAsB;EACrC,KAAK,QAAQ,KAAK,OAAO,IAAI,KAAK,KAAK,GAAG,IAAI,IAAI;CACpD;CAEA,SAAiB;EACf,OAAO,KAAK,OAAO,KAAK,KAAK;CAC/B;AACF;AAGA,SAAgB,iBAAiB,OAAkC;CACjE,SAAS;AACX"}
+{"version":3,"file":"FactoryLogger.js","names":[],"sources":["../../src/logging/FactoryLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\nimport { getCallerName } from \"src/config.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityMetadata } from \"src/EntityMetadata.ts\";\nimport { type UseMapSource } from \"src/newTestInstance.ts\";\n\nlet writer: WriteFn | undefined = undefined;\nexport type WriteFn = (line: string) => void;\n\nconst { gray, green, yellow } = ansis;\n\nexport class FactoryLogger {\n  private level = 0;\n  private writeFn: WriteFn;\n  private skipNextLogCreating = false;\n\n  // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n  // adding \"...at...\" stack traces to our output.\n  constructor() {\n    this.writeFn = writer ?? process.stdout.write.bind(process.stdout);\n  }\n\n  logCreating(cstr: any): void {\n    // This was already logged by the parent `field = creating new`\n    if (this.skipNextLogCreating) {\n      this.skipNextLogCreating = false;\n    } else {\n      this.write(\"Creating\", green.bold(`new ${cstr.name}`), gray(`at ${getCallerName(2)}`));\n    }\n  }\n\n  logAddToUseMap(e: Entity, source: UseMapSource): void {\n    if (source === \"sameBranch\" || source === \"diffBranch\") {\n      this.write(`${gray(`created`)} ${e.toString()} ${gray(\"added to scope\")}`);\n    } else {\n      this.write(`${gray(`...adding`)} ${e.toString()} ${gray(\"opt to scope\")}`);\n    }\n  }\n\n  logCreated(e: Entity): void {\n    // This matches the `logAddToUseMap` but for entities not going into scope\n    this.write(`${gray(`created`)} ${e.toString()}`);\n  }\n\n  logFoundExisting(e: Entity): void {\n    // Make this yellow because it reverses the \"new Entity\" we thought we were going to do\n    this.write(`${yellow(`using existing`)} ${e.toString()}`);\n  }\n\n  logFoundOpt(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from opt\")}`);\n  }\n\n  logNotFoundAndCreating(fieldName: string, meta: EntityMetadata): void {\n    this.write(`${gray(`${fieldName} =`)} creating ${green.bold(`new ${meta.type}`)}`);\n    this.skipNextLogCreating = true;\n  }\n\n  logFoundInUseMap(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from scope\")}`);\n  }\n\n  logFoundSingleEntity(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from em\")}`);\n  }\n\n  indent() {\n    this.level++;\n  }\n\n  dedent() {\n    this.level--;\n  }\n\n  private write(...line: string[]): void {\n    this.writeFn(this.prefix() + line.join(\" \") + \"\\n\");\n  }\n\n  private prefix() {\n    return \"  \".repeat(this.level);\n  }\n}\n\n// Allow our test suite observe the logger behavior\nexport function setFactoryWriter(write: WriteFn | undefined): void {\n  writer = write;\n}\n"],"mappings":";;;;;;AAMA,IAAI,SAA8B,KAAA;AAGlC,MAAM,EAAE,MAAM,OAAO,WAAW;AAEhC,IAAa,gBAAb,MAA2B;CACzB,QAAgB;CAChB;CACA,sBAA8B;CAI9B,cAAc;EACZ,KAAK,UAAU,UAAU,QAAQ,OAAO,MAAM,KAAK,QAAQ,MAAM;CACnE;CAEA,YAAY,MAAiB;EAE3B,IAAI,KAAK,qBACP,KAAK,sBAAsB;OAE3B,KAAK,MAAM,YAAY,MAAM,KAAK,OAAO,KAAK,MAAM,GAAG,KAAK,MAAM,cAAc,CAAC,GAAG,CAAC;CAEzF;CAEA,eAAe,GAAW,QAA4B;EACpD,IAAI,WAAW,gBAAgB,WAAW,cACxC,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,gBAAgB,GAAG;OAEzE,KAAK,MAAM,GAAG,KAAK,WAAW,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,cAAc,GAAG;CAE7E;CAEA,WAAW,GAAiB;EAE1B,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,GAAG,EAAE,SAAS,GAAG;CACjD;CAEA,iBAAiB,GAAiB;EAEhC,KAAK,MAAM,GAAG,OAAO,gBAAgB,EAAE,GAAG,EAAE,SAAS,GAAG;CAC1D;CAEA,YAAY,WAAmB,GAAiB;EAC9C,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,UAAU,GAAG;CAC5E;CAEA,uBAAuB,WAAmB,MAA4B;EACpE,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,YAAY,MAAM,KAAK,OAAO,KAAK,MAAM,GAAG;EACjF,KAAK,sBAAsB;CAC7B;CAEA,iBAAiB,WAAmB,GAAiB;EACnD,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,YAAY,GAAG;CAC9E;CAEA,qBAAqB,WAAmB,GAAiB;EACvD,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,SAAS,GAAG;CAC3E;CAEA,SAAS;EACP,KAAK;CACP;CAEA,SAAS;EACP,KAAK;CACP;CAEA,MAAc,GAAG,MAAsB;EACrC,KAAK,QAAQ,KAAK,OAAO,IAAI,KAAK,KAAK,GAAG,IAAI,IAAI;CACpD;CAEA,SAAiB;EACf,OAAO,KAAK,OAAO,KAAK,KAAK;CAC/B;AACF;AAGA,SAAgB,iBAAiB,OAAkC;CACjE,SAAS;AACX"}

package/build/logging/FieldLogger.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"FieldLogger.cjs","names":["#writeFn","#watching","getFuzzyCallerName","isEntity"],"sources":["../../src/logging/FieldLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\n\nimport { getFuzzyCallerName } from \"../config.ts\";\nimport { type Entity, isEntity } from \"../Entity.ts\";\n\nconst { gray, green, yellow, blue, red } = ansis;\nexport type WriteFn = (line: string) => void;\n\nexport type FieldLoggerWatch = {\n  /** The entity name, i.e. `Author` */\n  entity: string;\n  /** The fields, i.e. `[\"firstName\", \"lastName\"]`. */\n  fieldNames?: string[];\n  /** Whether to stop a debugger when the field is set. */\n  breakpoint?: boolean;\n};\n\n/**\n * Logs the setting of fields on entities to a `writeFn`, which defaults to `process.stdout`.\n */\nexport class FieldLogger {\n  readonly #writeFn: WriteFn;\n  readonly #watching: FieldLoggerWatch[] = [];\n\n  constructor(\n    /** The fields to watch, defaults to all fields. */\n    watching: FieldLoggerWatch[],\n    /** An optional/semi-internal write function, mostly for testing. */\n    writeFn?: WriteFn,\n  ) {\n    // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n    this.#writeFn = writeFn ?? ((line) => process.stdout.write(`${line}\\n`));\n    this.#watching = watching ?? [];\n  }\n\n  logCreate(entity: Entity): void {\n    const log = this.shouldLog(entity, \"constructor\");\n    if (!log) return;\n    this.log(green.bold(`${entity.toTaggedString()}`) + \" \" + yellow(`created`), gray(`at ${getFuzzyCallerName()}`));\n    if (log === \"breakpoint\") debugger;\n  }\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {\n    const log = this.shouldLog(entity, fieldName);\n    if (!log) return;\n    const color = this.getColor(value);\n    this.log(\n      green.bold(`${entity.toTaggedString()}`) + yellow(`.${fieldName}`),\n      gray(`=`),\n      color(`${value}`),\n      // We don't know if we'll be called from getField or M2O.set+getField, i.e. how many stack frames to skip\n      // to really get \"the caller's location\", so use `getFuzzyCallerName` instead of `getCallerName`.\n      gray(`at ${getFuzzyCallerName()}`),\n    );\n    if (log === \"breakpoint\") debugger;\n  }\n\n  private log(...line: string[]): void {\n    this.#writeFn(`${line.join(\" \")}`);\n  }\n\n  private shouldLog(entity: Entity, fieldName: string): boolean | \"breakpoint\" {\n    if (this.#watching.length === 0) return true;\n    for (const { entity: entityName, fieldNames, breakpoint } of this.#watching) {\n      if (entity.constructor.name === entityName && (fieldNames === undefined || fieldNames.includes(fieldName))) {\n        return breakpoint ? \"breakpoint\" : true;\n      }\n    }\n    return false;\n  }\n\n  // Do some `typeof` -> color\n  private getColor(value: unknown): typeof red {\n    return typeof value === \"boolean\"\n      ? red // boolean => red\n      : isEntity(value)\n        ? green // entity => green (matches other logging)\n        : blue; // otherwise strings/dates/numbers are blue;\n  }\n}\n\nclass NoopFieldLogger extends FieldLogger {\n  constructor() {\n    super([]);\n  }\n\n  logCreate(entity: Entity): void {}\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {}\n}\n\n/** A shared no-op logger that avoids optional chaining in hot field access paths. */\nexport const noopFieldLogger: FieldLogger = new NoopFieldLogger();\n"],"mappings":";;;;;;;AAKA,MAAM,EAAE,MAAM,OAAO,QAAQ,MAAM,QAAQ,MAAA;;;;AAe3C,IAAa,cAAb,MAAyB;CACvB;CACA,YAAyC,CAAC;CAE1C,YAEE,UAEA,SACA;EAEA,KAAKA,WAAW,aAAa,SAAS,QAAQ,OAAO,MAAM,GAAG,KAAK,GAAG;EACtE,KAAKC,YAAY,YAAY,CAAC;CAChC;CAEA,UAAU,QAAsB;EAC9B,MAAM,MAAM,KAAK,UAAU,QAAQ,aAAa;EAChD,IAAI,CAAC,KAAK;EACV,KAAK,IAAI,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,MAAM,OAAO,SAAS,GAAG,KAAK,MAAMC,eAAAA,mBAAmB,GAAG,CAAC;EAC/G,IAAI,QAAQ,cAAc;CAC5B;CAEA,OAAO,QAAgB,WAAmB,OAAsB;EAC9D,MAAM,MAAM,KAAK,UAAU,QAAQ,SAAS;EAC5C,IAAI,CAAC,KAAK;EACV,MAAM,QAAQ,KAAK,SAAS,KAAK;EACjC,KAAK,IACH,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,OAAO,IAAI,WAAW,GACjE,KAAK,GAAG,GACR,MAAM,GAAG,OAAO,GAGhB,KAAK,MAAMA,eAAAA,mBAAmB,GAAG,CACnC;EACA,IAAI,QAAQ,cAAc;CAC5B;CAEA,IAAY,GAAG,MAAsB;EACnC,KAAKF,SAAS,GAAG,KAAK,KAAK,GAAG,GAAG;CACnC;CAEA,UAAkB,QAAgB,WAA2C;EAC3E,IAAI,KAAKC,UAAU,WAAW,GAAG,OAAO;EACxC,KAAK,MAAM,EAAE,QAAQ,YAAY,YAAY,gBAAgB,KAAKA,WAChE,IAAI,OAAO,YAAY,SAAS,eAAe,eAAe,KAAA,KAAa,WAAW,SAAS,SAAS,IACtG,OAAO,aAAa,eAAe;EAGvC,OAAO;CACT;CAGA,SAAiB,OAA4B;EAC3C,OAAO,OAAO,UAAU,YACpB,MACAE,eAAAA,SAAS,KAAK,IACZ,QACA;CACR;AACF;AAEA,IAAM,kBAAN,cAA8B,YAAY;CACxC,cAAc;EACZ,MAAM,CAAC,CAAC;CACV;CAEA,UAAU,QAAsB,CAAC;CAEjC,OAAO,QAAgB,WAAmB,OAAsB,CAAC;AACnE;;AAGA,MAAa,kBAA+B,IAAI,gBAAgB"}
+{"version":3,"file":"FieldLogger.cjs","names":["#writeFn","#watching","getFuzzyCallerName","isEntity"],"sources":["../../src/logging/FieldLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\nimport { getFuzzyCallerName } from \"src/config.ts\";\nimport { type Entity, isEntity } from \"src/Entity.ts\";\n\nconst { gray, green, yellow, blue, red } = ansis;\nexport type WriteFn = (line: string) => void;\n\nexport type FieldLoggerWatch = {\n  /** The entity name, i.e. `Author` */\n  entity: string;\n  /** The fields, i.e. `[\"firstName\", \"lastName\"]`. */\n  fieldNames?: string[];\n  /** Whether to stop a debugger when the field is set. */\n  breakpoint?: boolean;\n};\n\n/**\n * Logs the setting of fields on entities to a `writeFn`, which defaults to `process.stdout`.\n */\nexport class FieldLogger {\n  readonly #writeFn: WriteFn;\n  readonly #watching: FieldLoggerWatch[] = [];\n\n  constructor(\n    /** The fields to watch, defaults to all fields. */\n    watching: FieldLoggerWatch[],\n    /** An optional/semi-internal write function, mostly for testing. */\n    writeFn?: WriteFn,\n  ) {\n    // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n    this.#writeFn = writeFn ?? ((line) => process.stdout.write(`${line}\\n`));\n    this.#watching = watching ?? [];\n  }\n\n  logCreate(entity: Entity): void {\n    const log = this.shouldLog(entity, \"constructor\");\n    if (!log) return;\n    this.log(green.bold(`${entity.toTaggedString()}`) + \" \" + yellow(`created`), gray(`at ${getFuzzyCallerName()}`));\n    if (log === \"breakpoint\") debugger;\n  }\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {\n    const log = this.shouldLog(entity, fieldName);\n    if (!log) return;\n    const color = this.getColor(value);\n    this.log(\n      green.bold(`${entity.toTaggedString()}`) + yellow(`.${fieldName}`),\n      gray(`=`),\n      color(`${value}`),\n      // We don't know if we'll be called from getField or M2O.set+getField, i.e. how many stack frames to skip\n      // to really get \"the caller's location\", so use `getFuzzyCallerName` instead of `getCallerName`.\n      gray(`at ${getFuzzyCallerName()}`),\n    );\n    if (log === \"breakpoint\") debugger;\n  }\n\n  private log(...line: string[]): void {\n    this.#writeFn(`${line.join(\" \")}`);\n  }\n\n  private shouldLog(entity: Entity, fieldName: string): boolean | \"breakpoint\" {\n    if (this.#watching.length === 0) return true;\n    for (const { entity: entityName, fieldNames, breakpoint } of this.#watching) {\n      if (entity.constructor.name === entityName && (fieldNames === undefined || fieldNames.includes(fieldName))) {\n        return breakpoint ? \"breakpoint\" : true;\n      }\n    }\n    return false;\n  }\n\n  // Do some `typeof` -> color\n  private getColor(value: unknown): typeof red {\n    return typeof value === \"boolean\"\n      ? red // boolean => red\n      : isEntity(value)\n        ? green // entity => green (matches other logging)\n        : blue; // otherwise strings/dates/numbers are blue;\n  }\n}\n\nclass NoopFieldLogger extends FieldLogger {\n  constructor() {\n    super([]);\n  }\n\n  logCreate(entity: Entity): void {}\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {}\n}\n\n/** A shared no-op logger that avoids optional chaining in hot field access paths. */\nexport const noopFieldLogger: FieldLogger = new NoopFieldLogger();\n"],"mappings":";;;;;;;AAIA,MAAM,EAAE,MAAM,OAAO,QAAQ,MAAM,QAAQ,MAAA;;;;AAe3C,IAAa,cAAb,MAAyB;CACvB;CACA,YAAyC,CAAC;CAE1C,YAEE,UAEA,SACA;EAEA,KAAKA,WAAW,aAAa,SAAS,QAAQ,OAAO,MAAM,GAAG,KAAK,GAAG;EACtE,KAAKC,YAAY,YAAY,CAAC;CAChC;CAEA,UAAU,QAAsB;EAC9B,MAAM,MAAM,KAAK,UAAU,QAAQ,aAAa;EAChD,IAAI,CAAC,KAAK;EACV,KAAK,IAAI,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,MAAM,OAAO,SAAS,GAAG,KAAK,MAAMC,eAAAA,mBAAmB,GAAG,CAAC;EAC/G,IAAI,QAAQ,cAAc;CAC5B;CAEA,OAAO,QAAgB,WAAmB,OAAsB;EAC9D,MAAM,MAAM,KAAK,UAAU,QAAQ,SAAS;EAC5C,IAAI,CAAC,KAAK;EACV,MAAM,QAAQ,KAAK,SAAS,KAAK;EACjC,KAAK,IACH,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,OAAO,IAAI,WAAW,GACjE,KAAK,GAAG,GACR,MAAM,GAAG,OAAO,GAGhB,KAAK,MAAMA,eAAAA,mBAAmB,GAAG,CACnC;EACA,IAAI,QAAQ,cAAc;CAC5B;CAEA,IAAY,GAAG,MAAsB;EACnC,KAAKF,SAAS,GAAG,KAAK,KAAK,GAAG,GAAG;CACnC;CAEA,UAAkB,QAAgB,WAA2C;EAC3E,IAAI,KAAKC,UAAU,WAAW,GAAG,OAAO;EACxC,KAAK,MAAM,EAAE,QAAQ,YAAY,YAAY,gBAAgB,KAAKA,WAChE,IAAI,OAAO,YAAY,SAAS,eAAe,eAAe,KAAA,KAAa,WAAW,SAAS,SAAS,IACtG,OAAO,aAAa,eAAe;EAGvC,OAAO;CACT;CAGA,SAAiB,OAA4B;EAC3C,OAAO,OAAO,UAAU,YACpB,MACAE,eAAAA,SAAS,KAAK,IACZ,QACA;CACR;AACF;AAEA,IAAM,kBAAN,cAA8B,YAAY;CACxC,cAAc;EACZ,MAAM,CAAC,CAAC;CACV;CAEA,UAAU,QAAsB,CAAC;CAEjC,OAAO,QAAgB,WAAmB,OAAsB,CAAC;AACnE;;AAGA,MAAa,kBAA+B,IAAI,gBAAgB"}

package/build/logging/FieldLogger.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"FieldLogger.d.cts","names":[],"sources":["../../src/logging/FieldLogger.ts"],"mappings":";;KAMY,WAAW;KAEX;;EAEV;;EAEA;;EAEA;;;;;cAMW;;EAIX,YAEE;;EAAA,UAAU,oBAEV;;EAAA,UAAU;EAOZ,UAAU,QAAQ;EAOlB,OAAO,QAAQ,QAAQ,mBAAmB;UAelC;UAIA;UAWA;;;cAoBG,iBAAiB"}
+{"version":3,"file":"FieldLogger.d.cts","names":[],"sources":["../../src/logging/FieldLogger.ts"],"mappings":";;KAKY,WAAW;KAEX;;EAEV;;EAEA;;EAEA;;;;;cAMW;;EAIX,YAEE;;EAAA,UAAU,oBAEV;;EAAA,UAAU;EAOZ,UAAU,QAAQ;EAOlB,OAAO,QAAQ,QAAQ,mBAAmB;UAelC;UAIA;UAWA;;;cAoBG,iBAAiB"}

package/build/logging/FieldLogger.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"FieldLogger.d.mts","names":[],"sources":["../../src/logging/FieldLogger.ts"],"mappings":";;KAMY,WAAW;KAEX;;EAEV;;EAEA;;EAEA;;;;;cAMW;;EAIX,YAEE;;EAAA,UAAU,oBAEV;;EAAA,UAAU;EAOZ,UAAU,QAAQ;EAOlB,OAAO,QAAQ,QAAQ,mBAAmB;UAelC;UAIA;UAWA;;;cAoBG,iBAAiB"}
+{"version":3,"file":"FieldLogger.d.mts","names":[],"sources":["../../src/logging/FieldLogger.ts"],"mappings":";;KAKY,WAAW;KAEX;;EAEV;;EAEA;;EAEA;;;;;cAMW;;EAIX,YAEE;;EAAA,UAAU,oBAEV;;EAAA,UAAU;EAOZ,UAAU,QAAQ;EAOlB,OAAO,QAAQ,QAAQ,mBAAmB;UAelC;UAIA;UAWA;;;cAoBG,iBAAiB"}

package/build/logging/FieldLogger.js.map

@@ -1 +1 @@
-{"version":3,"file":"FieldLogger.js","names":["#writeFn","#watching"],"sources":["../../src/logging/FieldLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\n\nimport { getFuzzyCallerName } from \"../config.ts\";\nimport { type Entity, isEntity } from \"../Entity.ts\";\n\nconst { gray, green, yellow, blue, red } = ansis;\nexport type WriteFn = (line: string) => void;\n\nexport type FieldLoggerWatch = {\n  /** The entity name, i.e. `Author` */\n  entity: string;\n  /** The fields, i.e. `[\"firstName\", \"lastName\"]`. */\n  fieldNames?: string[];\n  /** Whether to stop a debugger when the field is set. */\n  breakpoint?: boolean;\n};\n\n/**\n * Logs the setting of fields on entities to a `writeFn`, which defaults to `process.stdout`.\n */\nexport class FieldLogger {\n  readonly #writeFn: WriteFn;\n  readonly #watching: FieldLoggerWatch[] = [];\n\n  constructor(\n    /** The fields to watch, defaults to all fields. */\n    watching: FieldLoggerWatch[],\n    /** An optional/semi-internal write function, mostly for testing. */\n    writeFn?: WriteFn,\n  ) {\n    // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n    this.#writeFn = writeFn ?? ((line) => process.stdout.write(`${line}\\n`));\n    this.#watching = watching ?? [];\n  }\n\n  logCreate(entity: Entity): void {\n    const log = this.shouldLog(entity, \"constructor\");\n    if (!log) return;\n    this.log(green.bold(`${entity.toTaggedString()}`) + \" \" + yellow(`created`), gray(`at ${getFuzzyCallerName()}`));\n    if (log === \"breakpoint\") debugger;\n  }\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {\n    const log = this.shouldLog(entity, fieldName);\n    if (!log) return;\n    const color = this.getColor(value);\n    this.log(\n      green.bold(`${entity.toTaggedString()}`) + yellow(`.${fieldName}`),\n      gray(`=`),\n      color(`${value}`),\n      // We don't know if we'll be called from getField or M2O.set+getField, i.e. how many stack frames to skip\n      // to really get \"the caller's location\", so use `getFuzzyCallerName` instead of `getCallerName`.\n      gray(`at ${getFuzzyCallerName()}`),\n    );\n    if (log === \"breakpoint\") debugger;\n  }\n\n  private log(...line: string[]): void {\n    this.#writeFn(`${line.join(\" \")}`);\n  }\n\n  private shouldLog(entity: Entity, fieldName: string): boolean | \"breakpoint\" {\n    if (this.#watching.length === 0) return true;\n    for (const { entity: entityName, fieldNames, breakpoint } of this.#watching) {\n      if (entity.constructor.name === entityName && (fieldNames === undefined || fieldNames.includes(fieldName))) {\n        return breakpoint ? \"breakpoint\" : true;\n      }\n    }\n    return false;\n  }\n\n  // Do some `typeof` -> color\n  private getColor(value: unknown): typeof red {\n    return typeof value === \"boolean\"\n      ? red // boolean => red\n      : isEntity(value)\n        ? green // entity => green (matches other logging)\n        : blue; // otherwise strings/dates/numbers are blue;\n  }\n}\n\nclass NoopFieldLogger extends FieldLogger {\n  constructor() {\n    super([]);\n  }\n\n  logCreate(entity: Entity): void {}\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {}\n}\n\n/** A shared no-op logger that avoids optional chaining in hot field access paths. */\nexport const noopFieldLogger: FieldLogger = new NoopFieldLogger();\n"],"mappings":";;;;AAKA,MAAM,EAAE,MAAM,OAAO,QAAQ,MAAM,QAAQ;;;;AAe3C,IAAa,cAAb,MAAyB;CACvB;CACA,YAAyC,CAAC;CAE1C,YAEE,UAEA,SACA;EAEA,KAAKA,WAAW,aAAa,SAAS,QAAQ,OAAO,MAAM,GAAG,KAAK,GAAG;EACtE,KAAKC,YAAY,YAAY,CAAC;CAChC;CAEA,UAAU,QAAsB;EAC9B,MAAM,MAAM,KAAK,UAAU,QAAQ,aAAa;EAChD,IAAI,CAAC,KAAK;EACV,KAAK,IAAI,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,MAAM,OAAO,SAAS,GAAG,KAAK,MAAM,mBAAmB,GAAG,CAAC;EAC/G,IAAI,QAAQ,cAAc;CAC5B;CAEA,OAAO,QAAgB,WAAmB,OAAsB;EAC9D,MAAM,MAAM,KAAK,UAAU,QAAQ,SAAS;EAC5C,IAAI,CAAC,KAAK;EACV,MAAM,QAAQ,KAAK,SAAS,KAAK;EACjC,KAAK,IACH,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,OAAO,IAAI,WAAW,GACjE,KAAK,GAAG,GACR,MAAM,GAAG,OAAO,GAGhB,KAAK,MAAM,mBAAmB,GAAG,CACnC;EACA,IAAI,QAAQ,cAAc;CAC5B;CAEA,IAAY,GAAG,MAAsB;EACnC,KAAKD,SAAS,GAAG,KAAK,KAAK,GAAG,GAAG;CACnC;CAEA,UAAkB,QAAgB,WAA2C;EAC3E,IAAI,KAAKC,UAAU,WAAW,GAAG,OAAO;EACxC,KAAK,MAAM,EAAE,QAAQ,YAAY,YAAY,gBAAgB,KAAKA,WAChE,IAAI,OAAO,YAAY,SAAS,eAAe,eAAe,KAAA,KAAa,WAAW,SAAS,SAAS,IACtG,OAAO,aAAa,eAAe;EAGvC,OAAO;CACT;CAGA,SAAiB,OAA4B;EAC3C,OAAO,OAAO,UAAU,YACpB,MACA,SAAS,KAAK,IACZ,QACA;CACR;AACF;AAEA,IAAM,kBAAN,cAA8B,YAAY;CACxC,cAAc;EACZ,MAAM,CAAC,CAAC;CACV;CAEA,UAAU,QAAsB,CAAC;CAEjC,OAAO,QAAgB,WAAmB,OAAsB,CAAC;AACnE;;AAGA,MAAa,kBAA+B,IAAI,gBAAgB"}
+{"version":3,"file":"FieldLogger.js","names":["#writeFn","#watching"],"sources":["../../src/logging/FieldLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\nimport { getFuzzyCallerName } from \"src/config.ts\";\nimport { type Entity, isEntity } from \"src/Entity.ts\";\n\nconst { gray, green, yellow, blue, red } = ansis;\nexport type WriteFn = (line: string) => void;\n\nexport type FieldLoggerWatch = {\n  /** The entity name, i.e. `Author` */\n  entity: string;\n  /** The fields, i.e. `[\"firstName\", \"lastName\"]`. */\n  fieldNames?: string[];\n  /** Whether to stop a debugger when the field is set. */\n  breakpoint?: boolean;\n};\n\n/**\n * Logs the setting of fields on entities to a `writeFn`, which defaults to `process.stdout`.\n */\nexport class FieldLogger {\n  readonly #writeFn: WriteFn;\n  readonly #watching: FieldLoggerWatch[] = [];\n\n  constructor(\n    /** The fields to watch, defaults to all fields. */\n    watching: FieldLoggerWatch[],\n    /** An optional/semi-internal write function, mostly for testing. */\n    writeFn?: WriteFn,\n  ) {\n    // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n    this.#writeFn = writeFn ?? ((line) => process.stdout.write(`${line}\\n`));\n    this.#watching = watching ?? [];\n  }\n\n  logCreate(entity: Entity): void {\n    const log = this.shouldLog(entity, \"constructor\");\n    if (!log) return;\n    this.log(green.bold(`${entity.toTaggedString()}`) + \" \" + yellow(`created`), gray(`at ${getFuzzyCallerName()}`));\n    if (log === \"breakpoint\") debugger;\n  }\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {\n    const log = this.shouldLog(entity, fieldName);\n    if (!log) return;\n    const color = this.getColor(value);\n    this.log(\n      green.bold(`${entity.toTaggedString()}`) + yellow(`.${fieldName}`),\n      gray(`=`),\n      color(`${value}`),\n      // We don't know if we'll be called from getField or M2O.set+getField, i.e. how many stack frames to skip\n      // to really get \"the caller's location\", so use `getFuzzyCallerName` instead of `getCallerName`.\n      gray(`at ${getFuzzyCallerName()}`),\n    );\n    if (log === \"breakpoint\") debugger;\n  }\n\n  private log(...line: string[]): void {\n    this.#writeFn(`${line.join(\" \")}`);\n  }\n\n  private shouldLog(entity: Entity, fieldName: string): boolean | \"breakpoint\" {\n    if (this.#watching.length === 0) return true;\n    for (const { entity: entityName, fieldNames, breakpoint } of this.#watching) {\n      if (entity.constructor.name === entityName && (fieldNames === undefined || fieldNames.includes(fieldName))) {\n        return breakpoint ? \"breakpoint\" : true;\n      }\n    }\n    return false;\n  }\n\n  // Do some `typeof` -> color\n  private getColor(value: unknown): typeof red {\n    return typeof value === \"boolean\"\n      ? red // boolean => red\n      : isEntity(value)\n        ? green // entity => green (matches other logging)\n        : blue; // otherwise strings/dates/numbers are blue;\n  }\n}\n\nclass NoopFieldLogger extends FieldLogger {\n  constructor() {\n    super([]);\n  }\n\n  logCreate(entity: Entity): void {}\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {}\n}\n\n/** A shared no-op logger that avoids optional chaining in hot field access paths. */\nexport const noopFieldLogger: FieldLogger = new NoopFieldLogger();\n"],"mappings":";;;;AAIA,MAAM,EAAE,MAAM,OAAO,QAAQ,MAAM,QAAQ;;;;AAe3C,IAAa,cAAb,MAAyB;CACvB;CACA,YAAyC,CAAC;CAE1C,YAEE,UAEA,SACA;EAEA,KAAKA,WAAW,aAAa,SAAS,QAAQ,OAAO,MAAM,GAAG,KAAK,GAAG;EACtE,KAAKC,YAAY,YAAY,CAAC;CAChC;CAEA,UAAU,QAAsB;EAC9B,MAAM,MAAM,KAAK,UAAU,QAAQ,aAAa;EAChD,IAAI,CAAC,KAAK;EACV,KAAK,IAAI,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,MAAM,OAAO,SAAS,GAAG,KAAK,MAAM,mBAAmB,GAAG,CAAC;EAC/G,IAAI,QAAQ,cAAc;CAC5B;CAEA,OAAO,QAAgB,WAAmB,OAAsB;EAC9D,MAAM,MAAM,KAAK,UAAU,QAAQ,SAAS;EAC5C,IAAI,CAAC,KAAK;EACV,MAAM,QAAQ,KAAK,SAAS,KAAK;EACjC,KAAK,IACH,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,OAAO,IAAI,WAAW,GACjE,KAAK,GAAG,GACR,MAAM,GAAG,OAAO,GAGhB,KAAK,MAAM,mBAAmB,GAAG,CACnC;EACA,IAAI,QAAQ,cAAc;CAC5B;CAEA,IAAY,GAAG,MAAsB;EACnC,KAAKD,SAAS,GAAG,KAAK,KAAK,GAAG,GAAG;CACnC;CAEA,UAAkB,QAAgB,WAA2C;EAC3E,IAAI,KAAKC,UAAU,WAAW,GAAG,OAAO;EACxC,KAAK,MAAM,EAAE,QAAQ,YAAY,YAAY,gBAAgB,KAAKA,WAChE,IAAI,OAAO,YAAY,SAAS,eAAe,eAAe,KAAA,KAAa,WAAW,SAAS,SAAS,IACtG,OAAO,aAAa,eAAe;EAGvC,OAAO;CACT;CAGA,SAAiB,OAA4B;EAC3C,OAAO,OAAO,UAAU,YACpB,MACA,SAAS,KAAK,IACZ,QACA;CACR;AACF;AAEA,IAAM,kBAAN,cAA8B,YAAY;CACxC,cAAc;EACZ,MAAM,CAAC,CAAC;CACV;CAEA,UAAU,QAAsB,CAAC;CAEjC,OAAO,QAAgB,WAAmB,OAAsB,CAAC;AACnE;;AAGA,MAAa,kBAA+B,IAAI,gBAAgB"}

package/build/logging/ReactionLogger.cjs

@@ -1,7 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
-require("../Todo.cjs");
-require("../ReactionsManager.cjs");
 const require_utils = require("../utils.cjs");
 require("../config.cjs");
 require("../EntityManager.cjs");

package/build/logging/ReactionLogger.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ReactionLogger.cjs","names":["groupBy"],"sources":["../../src/logging/ReactionLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\n\nimport { type Reactable, type ReactiveRule } from \"../config.ts\";\nimport { type Entity } from \"../Entity.ts\";\nimport { type EntityManager } from \"../EntityManager.ts\";\nimport { type ReactiveAction } from \"../ReactionsManager.ts\";\nimport { type Todo } from \"../Todo.ts\";\nimport { groupBy } from \"../utils.ts\";\n\nconst { gray, green, yellow, white } = ansis;\n\nexport let globalLogger: ReactionLogger | undefined = undefined;\ntype WriteFn = (line: string) => void;\nexport type ReactionWalk = {\n  todo: Entity[];\n  r: Reactable | ReactiveRule;\n  entities: Entity[];\n};\n\nexport class ReactionLogger {\n  private writeFn: WriteFn;\n\n  // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n  constructor(writeFn: WriteFn = process.stdout.write.bind(process.stdout)) {\n    this.writeFn = writeFn;\n  }\n\n  now(): number {\n    return performance.now();\n  }\n\n  logQueued(entity: Entity, fieldName: string, r: Reactable): void {\n    this.log(\n      green.bold(`${entity.toTaggedString()}`) + yellow(`.${fieldName}`),\n      gray(`changed, queuing`),\n      green.bold(`${entity.toTaggedString()}`) + yellow(maybeDotPath(r)) + yellow(r.name),\n    );\n  }\n\n  logQueuedAll(entity: Entity, reason: string, r: Reactable): void {\n    this.log(\n      green.bold(`${entity.toTaggedString()}`),\n      gray(`${reason}, queuing`),\n      green.bold(`${entity.toTaggedString()}`) + green(maybeDotPath(r)) + yellow(r.name),\n    );\n  }\n\n  logStartingRecalc(em: EntityManager, kind: \"reactables\" | \"reactiveQueries\"): void {\n    this.log(\n      white.bold(`Recalculating reactive ${kind === \"reactiveQueries\" ? \"queries\" : \"fields\"} values...`),\n      this.entityCount(em),\n    );\n  }\n\n  logStartingValidate(em: EntityManager, todos: Record<string, Todo>): void {\n    const count = Object.values(todos).reduce(\n      (sum, t) => sum + t.inserts.length + t.updates.length + t.deletes.length,\n      0,\n    );\n    this.log(white.bold(`Validating from ${count} changed entities...`), this.entityCount(em));\n  }\n\n  /** Logs completed walks in deterministic shortest-path order. */\n  logWalks(walks: readonly (ReactionWalk | undefined)[], action: \"recalc\" | \"validate\"): void {\n    const ordered = walks.filter((walk) => walk !== undefined).sort((a, b) => a.r.path.length - b.r.path.length);\n    for (const { todo, r, entities } of ordered) {\n      const from = todo[0].constructor.name;\n      this.log(\n        \" \", // indent\n        gray(`Walked`),\n        white(`${todo.length}`),\n        green.bold(`${from}`) + green(`.${r.path.length === 0 ? \"(self)\" : r.path.join(\".\")}`),\n        gray(\"paths, found\"),\n        white(`${entities.length}`),\n        green.bold(`${r.cstr.name}`) + green(\".\") + yellow(r.name),\n        gray(`to ${action}`),\n      );\n      if (entities.length > 0) {\n        this.log(\n          \"   \", // indent\n          gray(\"[\"),\n          todo.map((e) => e.toTaggedString()).join(\" \"),\n          gray(\"] -> [\"),\n          [...new Set(entities)].map((e) => e.toTaggedString()).join(\" \"),\n          gray(\"]\"),\n        );\n      }\n    }\n  }\n\n  /** After finding the RFs/RQFs/Reactions to recalc, we call their `.load` promise to update. */\n  logLoadingStart(em: EntityManager, actions: ReactiveAction[]): void {\n    this.log(\" \", gray(\"Loading\"), String(actions.length), gray(\"actions...\"), this.entityCount(em));\n    const ordered = [...actions].sort((a, b) => a.r.path.length - b.r.path.length);\n    [...groupBy(ordered, (a) => `${a.entity.constructor.name},${a.r.name}`).values()].forEach((actions) => {\n      const { r, entity } = actions[0];\n      this.log(\n        \"   \",\n        green.bold(entity.constructor.name) + green(\".\") + yellow(r.name),\n        gray(\"-> [\"),\n        String(actions.map((a) => a.entity.toTaggedString()).join(\" \")),\n        gray(\"]\"),\n      );\n    });\n  }\n\n  /** We've completed loading/evaling the reactions. */\n  logLoadingEnd(em: EntityManager, millis: number): void {\n    this.log(\"   \", gray(\"took\"), String(Math.floor(millis)), gray(\"millis\"), this.entityCount(em));\n  }\n\n  private entityCount(em: EntityManager): string {\n    return gray(\"(em.entities=\") + em.entities.length + gray(\")\");\n  }\n\n  private log(...line: string[]): void {\n    this.writeFn(`${line.join(\" \")}\\n`);\n  }\n}\n\nexport function setReactionLogging(enabled: boolean): void;\nexport function setReactionLogging(logger: ReactionLogger): void;\nexport function setReactionLogging(arg: boolean | ReactionLogger): void {\n  globalLogger = typeof arg === \"boolean\" ? (arg ? new ReactionLogger() : undefined) : arg;\n}\n\nfunction maybeDotPath(r: Reactable): string {\n  return r.path.length > 0 ? `.${r.path.join(\".\")}.` : \".\";\n}\n\nclass NoopReactionLogger extends ReactionLogger {\n  now(): number {\n    return 0;\n  }\n\n  logQueued(entity: Entity, fieldName: string, r: Reactable): void {}\n\n  logQueuedAll(entity: Entity, reason: string, r: Reactable): void {}\n\n  logStartingRecalc(em: EntityManager, kind: \"reactables\" | \"reactiveQueries\"): void {}\n\n  logStartingValidate(em: EntityManager, todos: Record<string, Todo>): void {}\n\n  logWalks(walks: readonly (ReactionWalk | undefined)[], action: \"recalc\" | \"validate\"): void {}\n\n  logLoadingStart(em: EntityManager, actions: ReactiveAction[]): void {}\n\n  logLoadingEnd(em: EntityManager, millis: number): void {}\n}\n\n/** A shared no-op logger that avoids optional chaining in hot reaction paths. */\nexport const noopReactionLogger: ReactionLogger = new NoopReactionLogger();\n"],"mappings":"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"}
+{"version":3,"file":"ReactionLogger.cjs","names":["groupBy"],"sources":["../../src/logging/ReactionLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\nimport { type Reactable, type ReactiveRule } from \"src/config.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityManager } from \"src/EntityManager.ts\";\nimport type { Todo } from \"src/flush/Todo.ts\";\nimport type { ReactiveAction } from \"src/reactivity/ReactionsManager.ts\";\nimport { groupBy } from \"src/utils.ts\";\n\nconst { gray, green, yellow, white } = ansis;\n\nexport let globalLogger: ReactionLogger | undefined = undefined;\ntype WriteFn = (line: string) => void;\nexport type ReactionWalk = {\n  todo: Entity[];\n  r: Reactable | ReactiveRule;\n  entities: Entity[];\n};\n\nexport class ReactionLogger {\n  private writeFn: WriteFn;\n\n  // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n  constructor(writeFn: WriteFn = process.stdout.write.bind(process.stdout)) {\n    this.writeFn = writeFn;\n  }\n\n  now(): number {\n    return performance.now();\n  }\n\n  logQueued(entity: Entity, fieldName: string, r: Reactable): void {\n    this.log(\n      green.bold(`${entity.toTaggedString()}`) + yellow(`.${fieldName}`),\n      gray(`changed, queuing`),\n      green.bold(`${entity.toTaggedString()}`) + yellow(maybeDotPath(r)) + yellow(r.name),\n    );\n  }\n\n  logQueuedAll(entity: Entity, reason: string, r: Reactable): void {\n    this.log(\n      green.bold(`${entity.toTaggedString()}`),\n      gray(`${reason}, queuing`),\n      green.bold(`${entity.toTaggedString()}`) + green(maybeDotPath(r)) + yellow(r.name),\n    );\n  }\n\n  logStartingRecalc(em: EntityManager, kind: \"reactables\" | \"reactiveQueries\"): void {\n    this.log(\n      white.bold(`Recalculating reactive ${kind === \"reactiveQueries\" ? \"queries\" : \"fields\"} values...`),\n      this.entityCount(em),\n    );\n  }\n\n  logStartingValidate(em: EntityManager, todos: Record<string, Todo>): void {\n    const count = Object.values(todos).reduce(\n      (sum, t) => sum + t.inserts.length + t.updates.length + t.deletes.length,\n      0,\n    );\n    this.log(white.bold(`Validating from ${count} changed entities...`), this.entityCount(em));\n  }\n\n  /** Logs completed walks in deterministic shortest-path order. */\n  logWalks(walks: readonly (ReactionWalk | undefined)[], action: \"recalc\" | \"validate\"): void {\n    const ordered = walks.filter((walk) => walk !== undefined).sort((a, b) => a.r.path.length - b.r.path.length);\n    for (const { todo, r, entities } of ordered) {\n      const from = todo[0].constructor.name;\n      this.log(\n        \" \", // indent\n        gray(`Walked`),\n        white(`${todo.length}`),\n        green.bold(`${from}`) + green(`.${r.path.length === 0 ? \"(self)\" : r.path.join(\".\")}`),\n        gray(\"paths, found\"),\n        white(`${entities.length}`),\n        green.bold(`${r.cstr.name}`) + green(\".\") + yellow(r.name),\n        gray(`to ${action}`),\n      );\n      if (entities.length > 0) {\n        this.log(\n          \"   \", // indent\n          gray(\"[\"),\n          todo.map((e) => e.toTaggedString()).join(\" \"),\n          gray(\"] -> [\"),\n          [...new Set(entities)].map((e) => e.toTaggedString()).join(\" \"),\n          gray(\"]\"),\n        );\n      }\n    }\n  }\n\n  /** After finding the RFs/RQFs/Reactions to recalc, we call their `.load` promise to update. */\n  logLoadingStart(em: EntityManager, actions: ReactiveAction[]): void {\n    this.log(\" \", gray(\"Loading\"), String(actions.length), gray(\"actions...\"), this.entityCount(em));\n    const ordered = [...actions].sort((a, b) => a.r.path.length - b.r.path.length);\n    [...groupBy(ordered, (a) => `${a.entity.constructor.name},${a.r.name}`).values()].forEach((actions) => {\n      const { r, entity } = actions[0];\n      this.log(\n        \"   \",\n        green.bold(entity.constructor.name) + green(\".\") + yellow(r.name),\n        gray(\"-> [\"),\n        String(actions.map((a) => a.entity.toTaggedString()).join(\" \")),\n        gray(\"]\"),\n      );\n    });\n  }\n\n  /** We've completed loading/evaling the reactions. */\n  logLoadingEnd(em: EntityManager, millis: number): void {\n    this.log(\"   \", gray(\"took\"), String(Math.floor(millis)), gray(\"millis\"), this.entityCount(em));\n  }\n\n  private entityCount(em: EntityManager): string {\n    return gray(\"(em.entities=\") + em.entities.length + gray(\")\");\n  }\n\n  private log(...line: string[]): void {\n    this.writeFn(`${line.join(\" \")}\\n`);\n  }\n}\n\nexport function setReactionLogging(enabled: boolean): void;\nexport function setReactionLogging(logger: ReactionLogger): void;\nexport function setReactionLogging(arg: boolean | ReactionLogger): void {\n  globalLogger = typeof arg === \"boolean\" ? (arg ? new ReactionLogger() : undefined) : arg;\n}\n\nfunction maybeDotPath(r: Reactable): string {\n  return r.path.length > 0 ? `.${r.path.join(\".\")}.` : \".\";\n}\n\nclass NoopReactionLogger extends ReactionLogger {\n  now(): number {\n    return 0;\n  }\n\n  logQueued(entity: Entity, fieldName: string, r: Reactable): void {}\n\n  logQueuedAll(entity: Entity, reason: string, r: Reactable): void {}\n\n  logStartingRecalc(em: EntityManager, kind: \"reactables\" | \"reactiveQueries\"): void {}\n\n  logStartingValidate(em: EntityManager, todos: Record<string, Todo>): void {}\n\n  logWalks(walks: readonly (ReactionWalk | undefined)[], action: \"recalc\" | \"validate\"): void {}\n\n  logLoadingStart(em: EntityManager, actions: ReactiveAction[]): void {}\n\n  logLoadingEnd(em: EntityManager, millis: number): void {}\n}\n\n/** A shared no-op logger that avoids optional chaining in hot reaction paths. */\nexport const noopReactionLogger: ReactionLogger = new NoopReactionLogger();\n"],"mappings":"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"}

package/build/logging/ReactionLogger.d.cts

@@ -1,5 +1,5 @@
-import { Todo } from "../Todo.cjs";
-import { ReactiveAction } from "../ReactionsManager.cjs";
+import { Todo } from "../flush/Todo.cjs";
+import { ReactiveAction } from "../reactivity/ReactionsManager.cjs";
 import { Reactable, ReactiveRule } from "../config.cjs";
 import { EntityManager } from "../EntityManager.cjs";
 import { Entity } from "../Entity.cjs";

package/build/logging/ReactionLogger.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactionLogger.d.cts","names":[],"sources":["../../src/logging/ReactionLogger.ts"],"mappings":";;;;;;YAWW,cAAc;KACpB,WAAW;KACJ;EACV,MAAM;EACN,GAAG,YAAY;EACf,UAAU;;cAGC;UACH;EAGR,YAAY,UAAS;EAIrB;EAIA,UAAU,QAAQ,QAAQ,mBAAmB,GAAG;EAQhD,aAAa,QAAQ,QAAQ,gBAAgB,GAAG;EAQhD,kBAAkB,IAAI,eAAe;EAOrC,oBAAoB,IAAI,eAAe,OAAO,eAAe;;EAS7D,SAAS,iBAAiB,6BAA6B;;EA4BvD,gBAAgB,IAAI,eAAe,SAAS;;EAgB5C,cAAc,IAAI,eAAe;UAIzB;UAIA;;iBAKM,mBAAmB;iBACnB,mBAAmB,QAAQ;;cA8B9B,oBAAoB"}
+{"version":3,"file":"ReactionLogger.d.cts","names":[],"sources":["../../src/logging/ReactionLogger.ts"],"mappings":";;;;;;YAUW,cAAc;KACpB,WAAW;KACJ;EACV,MAAM;EACN,GAAG,YAAY;EACf,UAAU;;cAGC;UACH;EAGR,YAAY,UAAS;EAIrB;EAIA,UAAU,QAAQ,QAAQ,mBAAmB,GAAG;EAQhD,aAAa,QAAQ,QAAQ,gBAAgB,GAAG;EAQhD,kBAAkB,IAAI,eAAe;EAOrC,oBAAoB,IAAI,eAAe,OAAO,eAAe;;EAS7D,SAAS,iBAAiB,6BAA6B;;EA4BvD,gBAAgB,IAAI,eAAe,SAAS;;EAgB5C,cAAc,IAAI,eAAe;UAIzB;UAIA;;iBAKM,mBAAmB;iBACnB,mBAAmB,QAAQ;;cA8B9B,oBAAoB"}

package/build/logging/ReactionLogger.d.mts

@@ -1,5 +1,5 @@
-import { Todo } from "../Todo.mjs";
-import { ReactiveAction } from "../ReactionsManager.mjs";
+import { Todo } from "../flush/Todo.mjs";
+import { ReactiveAction } from "../reactivity/ReactionsManager.mjs";
 import { Reactable, ReactiveRule } from "../config.mjs";
 import { EntityManager } from "../EntityManager.mjs";
 import { Entity } from "../Entity.mjs";

package/build/logging/ReactionLogger.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactionLogger.d.mts","names":[],"sources":["../../src/logging/ReactionLogger.ts"],"mappings":";;;;;;YAWW,cAAc;KACpB,WAAW;KACJ;EACV,MAAM;EACN,GAAG,YAAY;EACf,UAAU;;cAGC;UACH;EAGR,YAAY,UAAS;EAIrB;EAIA,UAAU,QAAQ,QAAQ,mBAAmB,GAAG;EAQhD,aAAa,QAAQ,QAAQ,gBAAgB,GAAG;EAQhD,kBAAkB,IAAI,eAAe;EAOrC,oBAAoB,IAAI,eAAe,OAAO,eAAe;;EAS7D,SAAS,iBAAiB,6BAA6B;;EA4BvD,gBAAgB,IAAI,eAAe,SAAS;;EAgB5C,cAAc,IAAI,eAAe;UAIzB;UAIA;;iBAKM,mBAAmB;iBACnB,mBAAmB,QAAQ;;cA8B9B,oBAAoB"}
+{"version":3,"file":"ReactionLogger.d.mts","names":[],"sources":["../../src/logging/ReactionLogger.ts"],"mappings":";;;;;;YAUW,cAAc;KACpB,WAAW;KACJ;EACV,MAAM;EACN,GAAG,YAAY;EACf,UAAU;;cAGC;UACH;EAGR,YAAY,UAAS;EAIrB;EAIA,UAAU,QAAQ,QAAQ,mBAAmB,GAAG;EAQhD,aAAa,QAAQ,QAAQ,gBAAgB,GAAG;EAQhD,kBAAkB,IAAI,eAAe;EAOrC,oBAAoB,IAAI,eAAe,OAAO,eAAe;;EAS7D,SAAS,iBAAiB,6BAA6B;;EA4BvD,gBAAgB,IAAI,eAAe,SAAS;;EAgB5C,cAAc,IAAI,eAAe;UAIzB;UAIA;;iBAKM,mBAAmB;iBACnB,mBAAmB,QAAQ;;cA8B9B,oBAAoB"}

package/build/logging/ReactionLogger.js

@@ -1,5 +1,3 @@
-import "../Todo.js";
-import "../ReactionsManager.js";
 import { groupBy } from "../utils.js";
 import "../config.js";
 import "../EntityManager.js";

package/build/logging/ReactionLogger.js.map

@@ -1 +1 @@
-{"version":3,"file":"ReactionLogger.js","names":[],"sources":["../../src/logging/ReactionLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\n\nimport { type Reactable, type ReactiveRule } from \"../config.ts\";\nimport { type Entity } from \"../Entity.ts\";\nimport { type EntityManager } from \"../EntityManager.ts\";\nimport { type ReactiveAction } from \"../ReactionsManager.ts\";\nimport { type Todo } from \"../Todo.ts\";\nimport { groupBy } from \"../utils.ts\";\n\nconst { gray, green, yellow, white } = ansis;\n\nexport let globalLogger: ReactionLogger | undefined = undefined;\ntype WriteFn = (line: string) => void;\nexport type ReactionWalk = {\n  todo: Entity[];\n  r: Reactable | ReactiveRule;\n  entities: Entity[];\n};\n\nexport class ReactionLogger {\n  private writeFn: WriteFn;\n\n  // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n  constructor(writeFn: WriteFn = process.stdout.write.bind(process.stdout)) {\n    this.writeFn = writeFn;\n  }\n\n  now(): number {\n    return performance.now();\n  }\n\n  logQueued(entity: Entity, fieldName: string, r: Reactable): void {\n    this.log(\n      green.bold(`${entity.toTaggedString()}`) + yellow(`.${fieldName}`),\n      gray(`changed, queuing`),\n      green.bold(`${entity.toTaggedString()}`) + yellow(maybeDotPath(r)) + yellow(r.name),\n    );\n  }\n\n  logQueuedAll(entity: Entity, reason: string, r: Reactable): void {\n    this.log(\n      green.bold(`${entity.toTaggedString()}`),\n      gray(`${reason}, queuing`),\n      green.bold(`${entity.toTaggedString()}`) + green(maybeDotPath(r)) + yellow(r.name),\n    );\n  }\n\n  logStartingRecalc(em: EntityManager, kind: \"reactables\" | \"reactiveQueries\"): void {\n    this.log(\n      white.bold(`Recalculating reactive ${kind === \"reactiveQueries\" ? \"queries\" : \"fields\"} values...`),\n      this.entityCount(em),\n    );\n  }\n\n  logStartingValidate(em: EntityManager, todos: Record<string, Todo>): void {\n    const count = Object.values(todos).reduce(\n      (sum, t) => sum + t.inserts.length + t.updates.length + t.deletes.length,\n      0,\n    );\n    this.log(white.bold(`Validating from ${count} changed entities...`), this.entityCount(em));\n  }\n\n  /** Logs completed walks in deterministic shortest-path order. */\n  logWalks(walks: readonly (ReactionWalk | undefined)[], action: \"recalc\" | \"validate\"): void {\n    const ordered = walks.filter((walk) => walk !== undefined).sort((a, b) => a.r.path.length - b.r.path.length);\n    for (const { todo, r, entities } of ordered) {\n      const from = todo[0].constructor.name;\n      this.log(\n        \" \", // indent\n        gray(`Walked`),\n        white(`${todo.length}`),\n        green.bold(`${from}`) + green(`.${r.path.length === 0 ? \"(self)\" : r.path.join(\".\")}`),\n        gray(\"paths, found\"),\n        white(`${entities.length}`),\n        green.bold(`${r.cstr.name}`) + green(\".\") + yellow(r.name),\n        gray(`to ${action}`),\n      );\n      if (entities.length > 0) {\n        this.log(\n          \"   \", // indent\n          gray(\"[\"),\n          todo.map((e) => e.toTaggedString()).join(\" \"),\n          gray(\"] -> [\"),\n          [...new Set(entities)].map((e) => e.toTaggedString()).join(\" \"),\n          gray(\"]\"),\n        );\n      }\n    }\n  }\n\n  /** After finding the RFs/RQFs/Reactions to recalc, we call their `.load` promise to update. */\n  logLoadingStart(em: EntityManager, actions: ReactiveAction[]): void {\n    this.log(\" \", gray(\"Loading\"), String(actions.length), gray(\"actions...\"), this.entityCount(em));\n    const ordered = [...actions].sort((a, b) => a.r.path.length - b.r.path.length);\n    [...groupBy(ordered, (a) => `${a.entity.constructor.name},${a.r.name}`).values()].forEach((actions) => {\n      const { r, entity } = actions[0];\n      this.log(\n        \"   \",\n        green.bold(entity.constructor.name) + green(\".\") + yellow(r.name),\n        gray(\"-> [\"),\n        String(actions.map((a) => a.entity.toTaggedString()).join(\" \")),\n        gray(\"]\"),\n      );\n    });\n  }\n\n  /** We've completed loading/evaling the reactions. */\n  logLoadingEnd(em: EntityManager, millis: number): void {\n    this.log(\"   \", gray(\"took\"), String(Math.floor(millis)), gray(\"millis\"), this.entityCount(em));\n  }\n\n  private entityCount(em: EntityManager): string {\n    return gray(\"(em.entities=\") + em.entities.length + gray(\")\");\n  }\n\n  private log(...line: string[]): void {\n    this.writeFn(`${line.join(\" \")}\\n`);\n  }\n}\n\nexport function setReactionLogging(enabled: boolean): void;\nexport function setReactionLogging(logger: ReactionLogger): void;\nexport function setReactionLogging(arg: boolean | ReactionLogger): void {\n  globalLogger = typeof arg === \"boolean\" ? (arg ? new ReactionLogger() : undefined) : arg;\n}\n\nfunction maybeDotPath(r: Reactable): string {\n  return r.path.length > 0 ? `.${r.path.join(\".\")}.` : \".\";\n}\n\nclass NoopReactionLogger extends ReactionLogger {\n  now(): number {\n    return 0;\n  }\n\n  logQueued(entity: Entity, fieldName: string, r: Reactable): void {}\n\n  logQueuedAll(entity: Entity, reason: string, r: Reactable): void {}\n\n  logStartingRecalc(em: EntityManager, kind: \"reactables\" | \"reactiveQueries\"): void {}\n\n  logStartingValidate(em: EntityManager, todos: Record<string, Todo>): void {}\n\n  logWalks(walks: readonly (ReactionWalk | undefined)[], action: \"recalc\" | \"validate\"): void {}\n\n  logLoadingStart(em: EntityManager, actions: ReactiveAction[]): void {}\n\n  logLoadingEnd(em: EntityManager, millis: number): void {}\n}\n\n/** A shared no-op logger that avoids optional chaining in hot reaction paths. */\nexport const noopReactionLogger: ReactionLogger = new NoopReactionLogger();\n"],"mappings":"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"}
+{"version":3,"file":"ReactionLogger.js","names":[],"sources":["../../src/logging/ReactionLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\nimport { type Reactable, type ReactiveRule } from \"src/config.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityManager } from \"src/EntityManager.ts\";\nimport type { Todo } from \"src/flush/Todo.ts\";\nimport type { ReactiveAction } from \"src/reactivity/ReactionsManager.ts\";\nimport { groupBy } from \"src/utils.ts\";\n\nconst { gray, green, yellow, white } = ansis;\n\nexport let globalLogger: ReactionLogger | undefined = undefined;\ntype WriteFn = (line: string) => void;\nexport type ReactionWalk = {\n  todo: Entity[];\n  r: Reactable | ReactiveRule;\n  entities: Entity[];\n};\n\nexport class ReactionLogger {\n  private writeFn: WriteFn;\n\n  // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n  constructor(writeFn: WriteFn = process.stdout.write.bind(process.stdout)) {\n    this.writeFn = writeFn;\n  }\n\n  now(): number {\n    return performance.now();\n  }\n\n  logQueued(entity: Entity, fieldName: string, r: Reactable): void {\n    this.log(\n      green.bold(`${entity.toTaggedString()}`) + yellow(`.${fieldName}`),\n      gray(`changed, queuing`),\n      green.bold(`${entity.toTaggedString()}`) + yellow(maybeDotPath(r)) + yellow(r.name),\n    );\n  }\n\n  logQueuedAll(entity: Entity, reason: string, r: Reactable): void {\n    this.log(\n      green.bold(`${entity.toTaggedString()}`),\n      gray(`${reason}, queuing`),\n      green.bold(`${entity.toTaggedString()}`) + green(maybeDotPath(r)) + yellow(r.name),\n    );\n  }\n\n  logStartingRecalc(em: EntityManager, kind: \"reactables\" | \"reactiveQueries\"): void {\n    this.log(\n      white.bold(`Recalculating reactive ${kind === \"reactiveQueries\" ? \"queries\" : \"fields\"} values...`),\n      this.entityCount(em),\n    );\n  }\n\n  logStartingValidate(em: EntityManager, todos: Record<string, Todo>): void {\n    const count = Object.values(todos).reduce(\n      (sum, t) => sum + t.inserts.length + t.updates.length + t.deletes.length,\n      0,\n    );\n    this.log(white.bold(`Validating from ${count} changed entities...`), this.entityCount(em));\n  }\n\n  /** Logs completed walks in deterministic shortest-path order. */\n  logWalks(walks: readonly (ReactionWalk | undefined)[], action: \"recalc\" | \"validate\"): void {\n    const ordered = walks.filter((walk) => walk !== undefined).sort((a, b) => a.r.path.length - b.r.path.length);\n    for (const { todo, r, entities } of ordered) {\n      const from = todo[0].constructor.name;\n      this.log(\n        \" \", // indent\n        gray(`Walked`),\n        white(`${todo.length}`),\n        green.bold(`${from}`) + green(`.${r.path.length === 0 ? \"(self)\" : r.path.join(\".\")}`),\n        gray(\"paths, found\"),\n        white(`${entities.length}`),\n        green.bold(`${r.cstr.name}`) + green(\".\") + yellow(r.name),\n        gray(`to ${action}`),\n      );\n      if (entities.length > 0) {\n        this.log(\n          \"   \", // indent\n          gray(\"[\"),\n          todo.map((e) => e.toTaggedString()).join(\" \"),\n          gray(\"] -> [\"),\n          [...new Set(entities)].map((e) => e.toTaggedString()).join(\" \"),\n          gray(\"]\"),\n        );\n      }\n    }\n  }\n\n  /** After finding the RFs/RQFs/Reactions to recalc, we call their `.load` promise to update. */\n  logLoadingStart(em: EntityManager, actions: ReactiveAction[]): void {\n    this.log(\" \", gray(\"Loading\"), String(actions.length), gray(\"actions...\"), this.entityCount(em));\n    const ordered = [...actions].sort((a, b) => a.r.path.length - b.r.path.length);\n    [...groupBy(ordered, (a) => `${a.entity.constructor.name},${a.r.name}`).values()].forEach((actions) => {\n      const { r, entity } = actions[0];\n      this.log(\n        \"   \",\n        green.bold(entity.constructor.name) + green(\".\") + yellow(r.name),\n        gray(\"-> [\"),\n        String(actions.map((a) => a.entity.toTaggedString()).join(\" \")),\n        gray(\"]\"),\n      );\n    });\n  }\n\n  /** We've completed loading/evaling the reactions. */\n  logLoadingEnd(em: EntityManager, millis: number): void {\n    this.log(\"   \", gray(\"took\"), String(Math.floor(millis)), gray(\"millis\"), this.entityCount(em));\n  }\n\n  private entityCount(em: EntityManager): string {\n    return gray(\"(em.entities=\") + em.entities.length + gray(\")\");\n  }\n\n  private log(...line: string[]): void {\n    this.writeFn(`${line.join(\" \")}\\n`);\n  }\n}\n\nexport function setReactionLogging(enabled: boolean): void;\nexport function setReactionLogging(logger: ReactionLogger): void;\nexport function setReactionLogging(arg: boolean | ReactionLogger): void {\n  globalLogger = typeof arg === \"boolean\" ? (arg ? new ReactionLogger() : undefined) : arg;\n}\n\nfunction maybeDotPath(r: Reactable): string {\n  return r.path.length > 0 ? `.${r.path.join(\".\")}.` : \".\";\n}\n\nclass NoopReactionLogger extends ReactionLogger {\n  now(): number {\n    return 0;\n  }\n\n  logQueued(entity: Entity, fieldName: string, r: Reactable): void {}\n\n  logQueuedAll(entity: Entity, reason: string, r: Reactable): void {}\n\n  logStartingRecalc(em: EntityManager, kind: \"reactables\" | \"reactiveQueries\"): void {}\n\n  logStartingValidate(em: EntityManager, todos: Record<string, Todo>): void {}\n\n  logWalks(walks: readonly (ReactionWalk | undefined)[], action: \"recalc\" | \"validate\"): void {}\n\n  logLoadingStart(em: EntityManager, actions: ReactiveAction[]): void {}\n\n  logLoadingEnd(em: EntityManager, millis: number): void {}\n}\n\n/** A shared no-op logger that avoids optional chaining in hot reaction paths. */\nexport const noopReactionLogger: ReactionLogger = new NoopReactionLogger();\n"],"mappings":"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"}

package/build/newEntity.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"newEntity.cjs","names":["getMetadata","getLazyFields","hasAnyKey","fail","#fn"],"sources":["../src/newEntity.ts"],"sourcesContent":["import { baseEntityCstr } from \"./BaseEntity.ts\";\nimport { type Entity } from \"./Entity.ts\";\nimport { type EntityConstructor, type EntityManager } from \"./EntityManager.ts\";\nimport { type EntityMetadata, getMetadata } from \"./EntityMetadata.ts\";\nimport { getLazyFields } from \"./getProperties.ts\";\nimport { fail, hasAnyKey } from \"./utils.ts\";\n\n// Marks a constructor like Author has having had our relation getters installed\nconst lazySymbol = Symbol(\"lazy\");\n\n/**\n * Constructs an instance of `cstr` but with relations all made lazy.\n *\n * Specifically we avoid going through `new` b/c that invokes the `constructor` which instantiates\n * the instance-level class fields/relations like `books = hasMany`.\n *\n * Instead, we just call `Object.create`, which does not make any constructor/super calls, and instead\n * let any `this.books` accesses resolve to the getters we've installed on the prototype.\n */\nexport function newEntity<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>, isNew: boolean): T {\n  if (!Object.hasOwn(cstr, lazySymbol)) {\n    moveRelationsToGetters(cstr);\n    (cstr as any)[lazySymbol] = true;\n  }\n  const meta = getMetadata(cstr);\n  if (meta.ctiAbstract) fail(`Cannot create an instance of abstract entity ${meta.type}`);\n  // This side-steps the `Author` constructor that initializes fields instance-level fields, which instead\n  // we've shoved up to be getters on the prototype, and the only instance field we expect to have is `__data`,\n  // which is set by the `baseEntityCstr` call.\n  const entity = Object.create(cstr.prototype) as T;\n  baseEntityCstr(em, entity as any, isNew);\n  return entity;\n}\n\nfunction moveRelationsToGetters(cstr: EntityConstructor<any>): void {\n  let transientFieldsValue: any = {};\n  for (const [fieldName, value] of getLazyFields(getMetadata(cstr))) {\n    if (value instanceof LazyRelation) {\n      Object.defineProperty(cstr.prototype, fieldName, {\n        get(this: any) {\n          return ((this.__data.relations ??= {})[fieldName] ??= value.create(this, fieldName));\n        },\n      });\n    } else if (fieldName === \"transientFields\") {\n      // We'll define transientFields for all entities outside the loop\n      transientFieldsValue = value;\n    }\n  }\n  // Most entities have no transientFields, so skip the structuredClone for the empty default\n  const needsClone = hasAnyKey(transientFieldsValue);\n  Object.defineProperty(cstr.prototype, \"transientFields\", {\n    get(this: any) {\n      // This prototype-level `get` will only ever be called once per instance, b/c when we're\n      // called for the first/only time, we set an instance-level `this.transientFields` that, for\n      // all future calls, will resolve to the instance's own copy of the fields.\n      //\n      // This has the pleasant upshot of making the instance-level `transientFields` lazy, and\n      // they will not be created on an instance until they're actually asked for.\n      const copy = needsClone ? structuredClone(transientFieldsValue) : {};\n      Object.defineProperty(this, \"transientFields\", { value: copy });\n      return copy;\n    },\n  });\n}\n\n/**\n * A function for `has...` methods to integrate with the `newEntity` lazy field system.\n *\n * We need TypeScript to still see `books = hasMany(...)` as being typed as `Many<Book>`,\n * so this method's return type is `R` i.e. the `Many<Book>` relation type.\n *\n * But at runtime we actually want this to be a `LazyRelation` that can be rewritten\n * into a getter, and only invoked when the relation is actually accessed.\n */\nexport function lazyField<T extends Entity, R>(fn: (entity: T, fieldName: string) => R): R {\n  return new LazyRelation(fn) as R;\n}\n\n/**\n * Easily resolves `otherMetadata` fields for lazy relations.\n *\n * When `lazyRelation`s are initialized for their first/only time, i.e. the `books = hasBooks(authorMetadata)`\n * call that `getFakeInstance` does, it's when the class bodies are still being evaled, which is before the\n * `metadata.ts` file has run.\n *\n * This means that any `authorMetadata` consts would still be undefined.\n *\n * So instead we just do not bother passing metadata consts to `has...` methods, and instead let the methods\n * one-time resolve `otherMetadata` on their first invocation, which will be after the `metadata.ts` file has\n * finished importing, and the consts are all defined.\n */\nexport function resolveOtherMeta(entity: Entity, fieldName: string): EntityMetadata {\n  const meta = getMetadata(entity);\n  const field: any = meta.allFields[fieldName] ?? fail(`Could not find field ${meta.type}.${fieldName}`);\n  return field.otherMetadata();\n}\n\n/** Wraps `has...` relation constructors in an easily-identifiable container. */\nexport class LazyRelation<T extends Entity> {\n  #fn: (entity: T, fieldName: string) => any;\n  constructor(fn: (entity: T, fieldName: string) => any) {\n    this.#fn = fn;\n  }\n\n  /** Called by our getters to lazily create the relation on first access. */\n  create(entity: T, fieldName: string) {\n    return this.#fn(entity, fieldName);\n  }\n}\n"],"mappings":";;;;;;;;AAQA,MAAM,aAAa,OAAO,MAAM;;;;;;;;;;AAWhC,SAAgB,UAA4B,IAAmB,MAA4B,OAAmB;CAC5G,IAAI,CAAC,OAAO,OAAO,MAAM,UAAU,GAAG;EACpC,uBAAuB,IAAI;EAC3B,KAAc,cAAc;CAC9B;CACA,MAAM,OAAOA,uBAAAA,YAAY,IAAI;CAC7B,IAAI,KAAK,aAAa,cAAA,KAAK,gDAAgD,KAAK,MAAM;CAItF,MAAM,SAAS,OAAO,OAAO,KAAK,SAAS;CAC3C,mBAAA,eAAe,IAAI,QAAe,KAAK;CACvC,OAAO;AACT;AAEA,SAAS,uBAAuB,MAAoC;CAClE,IAAI,uBAA4B,CAAC;CACjC,KAAK,MAAM,CAAC,WAAW,UAAUC,sBAAAA,cAAcD,uBAAAA,YAAY,IAAI,CAAC,GAC9D,IAAI,iBAAiB,cACnB,OAAO,eAAe,KAAK,WAAW,WAAW,EAC/C,MAAe;EACb,OAAQ,CAAC,KAAK,OAAO,cAAc,CAAC,EAAA,CAAG,eAAe,MAAM,OAAO,MAAM,SAAS;CACpF,EACF,CAAC;MACI,IAAI,cAAc,mBAEvB,uBAAuB;CAI3B,MAAM,aAAaE,cAAAA,UAAU,oBAAoB;CACjD,OAAO,eAAe,KAAK,WAAW,mBAAmB,EACvD,MAAe;EAOb,MAAM,OAAO,aAAa,gBAAgB,oBAAoB,IAAI,CAAC;EACnE,OAAO,eAAe,MAAM,mBAAmB,EAAE,OAAO,KAAK,CAAC;EAC9D,OAAO;CACT,EACF,CAAC;AACH;;;;;;;;;;AAWA,SAAgB,UAA+B,IAA4C;CACzF,OAAO,IAAI,aAAa,EAAE;AAC5B;;;;;;;;;;;;;;AAeA,SAAgB,iBAAiB,QAAgB,WAAmC;CAClF,MAAM,OAAOF,uBAAAA,YAAY,MAAM;CAE/B,QADmB,KAAK,UAAU,cAAcG,cAAAA,KAAK,wBAAwB,KAAK,KAAK,GAAG,WAAW,EAAA,CACxF,cAAc;AAC7B;;AAGA,IAAa,eAAb,MAA4C;CAC1C;CACA,YAAY,IAA2C;EACrD,KAAKC,MAAM;CACb;;CAGA,OAAO,QAAW,WAAmB;EACnC,OAAO,KAAKA,IAAI,QAAQ,SAAS;CACnC;AACF"}
+{"version":3,"file":"newEntity.cjs","names":["getMetadata","getLazyFields","hasAnyKey","fail","#fn"],"sources":["../src/newEntity.ts"],"sourcesContent":["import { baseEntityCstr } from \"src/BaseEntity.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityConstructor, type EntityManager } from \"src/EntityManager.ts\";\nimport { type EntityMetadata, getMetadata } from \"src/EntityMetadata.ts\";\nimport { getLazyFields } from \"src/getProperties.ts\";\nimport { fail, hasAnyKey } from \"src/utils.ts\";\n\n// Marks a constructor like Author has having had our relation getters installed\nconst lazySymbol = Symbol(\"lazy\");\n\n/**\n * Constructs an instance of `cstr` but with relations all made lazy.\n *\n * Specifically we avoid going through `new` b/c that invokes the `constructor` which instantiates\n * the instance-level class fields/relations like `books = hasMany`.\n *\n * Instead, we just call `Object.create`, which does not make any constructor/super calls, and instead\n * let any `this.books` accesses resolve to the getters we've installed on the prototype.\n */\nexport function newEntity<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>, isNew: boolean): T {\n  if (!Object.hasOwn(cstr, lazySymbol)) {\n    moveRelationsToGetters(cstr);\n    (cstr as any)[lazySymbol] = true;\n  }\n  const meta = getMetadata(cstr);\n  if (meta.ctiAbstract) fail(`Cannot create an instance of abstract entity ${meta.type}`);\n  // This side-steps the `Author` constructor that initializes fields instance-level fields, which instead\n  // we've shoved up to be getters on the prototype, and the only instance field we expect to have is `__data`,\n  // which is set by the `baseEntityCstr` call.\n  const entity = Object.create(cstr.prototype) as T;\n  baseEntityCstr(em, entity as any, isNew);\n  return entity;\n}\n\nfunction moveRelationsToGetters(cstr: EntityConstructor<any>): void {\n  let transientFieldsValue: any = {};\n  for (const [fieldName, value] of getLazyFields(getMetadata(cstr))) {\n    if (value instanceof LazyRelation) {\n      Object.defineProperty(cstr.prototype, fieldName, {\n        get(this: any) {\n          return ((this.__data.relations ??= {})[fieldName] ??= value.create(this, fieldName));\n        },\n      });\n    } else if (fieldName === \"transientFields\") {\n      // We'll define transientFields for all entities outside the loop\n      transientFieldsValue = value;\n    }\n  }\n  // Most entities have no transientFields, so skip the structuredClone for the empty default\n  const needsClone = hasAnyKey(transientFieldsValue);\n  Object.defineProperty(cstr.prototype, \"transientFields\", {\n    get(this: any) {\n      // This prototype-level `get` will only ever be called once per instance, b/c when we're\n      // called for the first/only time, we set an instance-level `this.transientFields` that, for\n      // all future calls, will resolve to the instance's own copy of the fields.\n      //\n      // This has the pleasant upshot of making the instance-level `transientFields` lazy, and\n      // they will not be created on an instance until they're actually asked for.\n      const copy = needsClone ? structuredClone(transientFieldsValue) : {};\n      Object.defineProperty(this, \"transientFields\", { value: copy });\n      return copy;\n    },\n  });\n}\n\n/**\n * A function for `has...` methods to integrate with the `newEntity` lazy field system.\n *\n * We need TypeScript to still see `books = hasMany(...)` as being typed as `Many<Book>`,\n * so this method's return type is `R` i.e. the `Many<Book>` relation type.\n *\n * But at runtime we actually want this to be a `LazyRelation` that can be rewritten\n * into a getter, and only invoked when the relation is actually accessed.\n */\nexport function lazyField<T extends Entity, R>(fn: (entity: T, fieldName: string) => R): R {\n  return new LazyRelation(fn) as R;\n}\n\n/**\n * Easily resolves `otherMetadata` fields for lazy relations.\n *\n * When `lazyRelation`s are initialized for their first/only time, i.e. the `books = hasBooks(authorMetadata)`\n * call that `getFakeInstance` does, it's when the class bodies are still being evaled, which is before the\n * `metadata.ts` file has run.\n *\n * This means that any `authorMetadata` consts would still be undefined.\n *\n * So instead we just do not bother passing metadata consts to `has...` methods, and instead let the methods\n * one-time resolve `otherMetadata` on their first invocation, which will be after the `metadata.ts` file has\n * finished importing, and the consts are all defined.\n */\nexport function resolveOtherMeta(entity: Entity, fieldName: string): EntityMetadata {\n  const meta = getMetadata(entity);\n  const field: any = meta.allFields[fieldName] ?? fail(`Could not find field ${meta.type}.${fieldName}`);\n  return field.otherMetadata();\n}\n\n/** Wraps `has...` relation constructors in an easily-identifiable container. */\nexport class LazyRelation<T extends Entity> {\n  #fn: (entity: T, fieldName: string) => any;\n  constructor(fn: (entity: T, fieldName: string) => any) {\n    this.#fn = fn;\n  }\n\n  /** Called by our getters to lazily create the relation on first access. */\n  create(entity: T, fieldName: string) {\n    return this.#fn(entity, fieldName);\n  }\n}\n"],"mappings":";;;;;;;;AAQA,MAAM,aAAa,OAAO,MAAM;;;;;;;;;;AAWhC,SAAgB,UAA4B,IAAmB,MAA4B,OAAmB;CAC5G,IAAI,CAAC,OAAO,OAAO,MAAM,UAAU,GAAG;EACpC,uBAAuB,IAAI;EAC3B,KAAc,cAAc;CAC9B;CACA,MAAM,OAAOA,uBAAAA,YAAY,IAAI;CAC7B,IAAI,KAAK,aAAa,cAAA,KAAK,gDAAgD,KAAK,MAAM;CAItF,MAAM,SAAS,OAAO,OAAO,KAAK,SAAS;CAC3C,mBAAA,eAAe,IAAI,QAAe,KAAK;CACvC,OAAO;AACT;AAEA,SAAS,uBAAuB,MAAoC;CAClE,IAAI,uBAA4B,CAAC;CACjC,KAAK,MAAM,CAAC,WAAW,UAAUC,sBAAAA,cAAcD,uBAAAA,YAAY,IAAI,CAAC,GAC9D,IAAI,iBAAiB,cACnB,OAAO,eAAe,KAAK,WAAW,WAAW,EAC/C,MAAe;EACb,OAAQ,CAAC,KAAK,OAAO,cAAc,CAAC,EAAA,CAAG,eAAe,MAAM,OAAO,MAAM,SAAS;CACpF,EACF,CAAC;MACI,IAAI,cAAc,mBAEvB,uBAAuB;CAI3B,MAAM,aAAaE,cAAAA,UAAU,oBAAoB;CACjD,OAAO,eAAe,KAAK,WAAW,mBAAmB,EACvD,MAAe;EAOb,MAAM,OAAO,aAAa,gBAAgB,oBAAoB,IAAI,CAAC;EACnE,OAAO,eAAe,MAAM,mBAAmB,EAAE,OAAO,KAAK,CAAC;EAC9D,OAAO;CACT,EACF,CAAC;AACH;;;;;;;;;;AAWA,SAAgB,UAA+B,IAA4C;CACzF,OAAO,IAAI,aAAa,EAAE;AAC5B;;;;;;;;;;;;;;AAeA,SAAgB,iBAAiB,QAAgB,WAAmC;CAClF,MAAM,OAAOF,uBAAAA,YAAY,MAAM;CAE/B,QADmB,KAAK,UAAU,cAAcG,cAAAA,KAAK,wBAAwB,KAAK,KAAK,GAAG,WAAW,EAAA,CACxF,cAAc;AAC7B;;AAGA,IAAa,eAAb,MAA4C;CAC1C;CACA,YAAY,IAA2C;EACrD,KAAKC,MAAM;CACb;;CAGA,OAAO,QAAW,WAAmB;EACnC,OAAO,KAAKA,IAAI,QAAQ,SAAS;CACnC;AACF"}