joist-core 2.3.0 → 2.4.0-next.2

package/build/logging/ReactionLogger.d.cts

@@ -0,0 +1,37 @@
+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";
+//#region src/logging/ReactionLogger.d.ts
+declare let globalLogger: ReactionLogger | undefined;
+type WriteFn = (line: string) => void;
+type ReactionWalk = {
+  todo: Entity[];
+  r: Reactable | ReactiveRule;
+  entities: Entity[];
+};
+declare class ReactionLogger {
+  private writeFn;
+  constructor(writeFn?: WriteFn);
+  now(): number;
+  logQueued(entity: Entity, fieldName: string, r: Reactable): void;
+  logQueuedAll(entity: Entity, reason: string, r: Reactable): void;
+  logStartingRecalc(em: EntityManager, kind: "reactables" | "reactiveQueries"): void;
+  logStartingValidate(em: EntityManager, todos: Record<string, Todo>): void;
+  /** Logs completed walks in deterministic shortest-path order. */
+  logWalks(walks: readonly (ReactionWalk | undefined)[], action: "recalc" | "validate"): void;
+  /** After finding the RFs/RQFs/Reactions to recalc, we call their `.load` promise to update. */
+  logLoadingStart(em: EntityManager, actions: ReactiveAction[]): void;
+  /** We've completed loading/evaling the reactions. */
+  logLoadingEnd(em: EntityManager, millis: number): void;
+  private entityCount;
+  private log;
+}
+declare function setReactionLogging(enabled: boolean): void;
+declare function setReactionLogging(logger: ReactionLogger): void;
+/** A shared no-op logger that avoids optional chaining in hot reaction paths. */
+declare const noopReactionLogger: ReactionLogger;
+//#endregion
+export { ReactionLogger, ReactionWalk, globalLogger, noopReactionLogger, setReactionLogging };
+//# sourceMappingURL=ReactionLogger.d.cts.map

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

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

@@ -0,0 +1,37 @@
+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";
+//#region src/logging/ReactionLogger.d.ts
+declare let globalLogger: ReactionLogger | undefined;
+type WriteFn = (line: string) => void;
+type ReactionWalk = {
+  todo: Entity[];
+  r: Reactable | ReactiveRule;
+  entities: Entity[];
+};
+declare class ReactionLogger {
+  private writeFn;
+  constructor(writeFn?: WriteFn);
+  now(): number;
+  logQueued(entity: Entity, fieldName: string, r: Reactable): void;
+  logQueuedAll(entity: Entity, reason: string, r: Reactable): void;
+  logStartingRecalc(em: EntityManager, kind: "reactables" | "reactiveQueries"): void;
+  logStartingValidate(em: EntityManager, todos: Record<string, Todo>): void;
+  /** Logs completed walks in deterministic shortest-path order. */
+  logWalks(walks: readonly (ReactionWalk | undefined)[], action: "recalc" | "validate"): void;
+  /** After finding the RFs/RQFs/Reactions to recalc, we call their `.load` promise to update. */
+  logLoadingStart(em: EntityManager, actions: ReactiveAction[]): void;
+  /** We've completed loading/evaling the reactions. */
+  logLoadingEnd(em: EntityManager, millis: number): void;
+  private entityCount;
+  private log;
+}
+declare function setReactionLogging(enabled: boolean): void;
+declare function setReactionLogging(logger: ReactionLogger): void;
+/** A shared no-op logger that avoids optional chaining in hot reaction paths. */
+declare const noopReactionLogger: ReactionLogger;
+//#endregion
+export { ReactionLogger, ReactionWalk, globalLogger, noopReactionLogger, setReactionLogging };
+//# sourceMappingURL=ReactionLogger.d.mts.map

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

@@ -0,0 +1 @@
+{"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,72 +1,82 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import { groupBy } from "../utils.js";
+import "../config.js";
+import "../EntityManager.js";
+import "../Entity.js";
+import ansis from "ansis";
+//#region src/logging/ReactionLogger.ts
+const { gray, green, yellow, white } = ansis;
+let globalLogger = void 0;
+var ReactionLogger = class {
+	writeFn;
+	constructor(writeFn = process.stdout.write.bind(process.stdout)) {
+		this.writeFn = writeFn;
+	}
+	now() {
+		return performance.now();
+	}
+	logQueued(entity, fieldName, r) {
+		this.log(green.bold(`${entity.toTaggedString()}`) + yellow(`.${fieldName}`), gray(`changed, queuing`), green.bold(`${entity.toTaggedString()}`) + yellow(maybeDotPath(r)) + yellow(r.name));
+	}
+	logQueuedAll(entity, reason, r) {
+		this.log(green.bold(`${entity.toTaggedString()}`), gray(`${reason}, queuing`), green.bold(`${entity.toTaggedString()}`) + green(maybeDotPath(r)) + yellow(r.name));
+	}
+	logStartingRecalc(em, kind) {
+		this.log(white.bold(`Recalculating reactive ${kind === "reactiveQueries" ? "queries" : "fields"} values...`), this.entityCount(em));
+	}
+	logStartingValidate(em, todos) {
+		const count = Object.values(todos).reduce((sum, t) => sum + t.inserts.length + t.updates.length + t.deletes.length, 0);
+		this.log(white.bold(`Validating from ${count} changed entities...`), this.entityCount(em));
+	}
+	/** Logs completed walks in deterministic shortest-path order. */
+	logWalks(walks, action) {
+		const ordered = walks.filter((walk) => walk !== void 0).sort((a, b) => a.r.path.length - b.r.path.length);
+		for (const { todo, r, entities } of ordered) {
+			const from = todo[0].constructor.name;
+			this.log(" ", gray(`Walked`), white(`${todo.length}`), green.bold(`${from}`) + green(`.${r.path.length === 0 ? "(self)" : r.path.join(".")}`), gray("paths, found"), white(`${entities.length}`), green.bold(`${r.cstr.name}`) + green(".") + yellow(r.name), gray(`to ${action}`));
+			if (entities.length > 0) this.log("   ", gray("["), todo.map((e) => e.toTaggedString()).join(" "), gray("] -> ["), [...new Set(entities)].map((e) => e.toTaggedString()).join(" "), gray("]"));
+		}
+	}
+	/** After finding the RFs/RQFs/Reactions to recalc, we call their `.load` promise to update. */
+	logLoadingStart(em, actions) {
+		this.log(" ", gray("Loading"), String(actions.length), gray("actions..."), this.entityCount(em));
+		const ordered = [...actions].sort((a, b) => a.r.path.length - b.r.path.length);
+		[...groupBy(ordered, (a) => `${a.entity.constructor.name},${a.r.name}`).values()].forEach((actions) => {
+			const { r, entity } = actions[0];
+			this.log("   ", green.bold(entity.constructor.name) + green(".") + yellow(r.name), gray("-> ["), String(actions.map((a) => a.entity.toTaggedString()).join(" ")), gray("]"));
+		});
+	}
+	/** We've completed loading/evaling the reactions. */
+	logLoadingEnd(em, millis) {
+		this.log("   ", gray("took"), String(Math.floor(millis)), gray("millis"), this.entityCount(em));
+	}
+	entityCount(em) {
+		return gray("(em.entities=") + em.entities.length + gray(")");
+	}
+	log(...line) {
+		this.writeFn(`${line.join(" ")}\n`);
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReactionLogger = exports.globalLogger = void 0;
-exports.setReactionLogging = setReactionLogging;
-const ansis_1 = __importDefault(require("ansis"));
-const utils_1 = require("../utils");
-const { gray, green, yellow, white } = ansis_1.default;
-exports.globalLogger = undefined;
-class ReactionLogger {
-    writeFn;
-    // We default to process.stdout.write to side-step around Jest's console.log instrumentation
-    constructor(writeFn = process.stdout.write.bind(process.stdout)) {
-        this.writeFn = writeFn;
-    }
-    now() {
-        return performance.now();
-    }
-    logQueued(entity, fieldName, r) {
-        this.log(green.bold(`${entity.toTaggedString()}`) + yellow(`.${fieldName}`), gray(`changed, queuing`), green.bold(`${entity.toTaggedString()}`) + yellow(maybeDotPath(r)) + yellow(r.name));
-    }
-    logQueuedAll(entity, reason, r) {
-        this.log(green.bold(`${entity.toTaggedString()}`), gray(`${reason}, queuing`), green.bold(`${entity.toTaggedString()}`) + green(maybeDotPath(r)) + yellow(r.name));
-    }
-    logStartingRecalc(em, kind) {
-        this.log(white.bold(`Recalculating reactive ${kind === "reactiveQueries" ? "queries" : "fields"} values...`), this.entityCount(em));
-    }
-    // Both EntityManager.runValidation and RM.recalc use `logWalked`
-    logStartingValidate(em, todos) {
-        const count = Object.values(todos).reduce((sum, t) => sum + t.inserts.length + t.updates.length + t.deletes.length, 0);
-        this.log(white.bold(`Validating from ${count} changed entities...`), this.entityCount(em));
-    }
-    logWalked(todo, r, entities, action) {
-        // Keep for future debugging...
-        const from = todo[0].constructor.name;
-        this.log(" ", // indent
-        gray(`Walked`), white(`${todo.length}`), green.bold(`${from}`) + green(`.${r.path.length === 0 ? "(self)" : r.path.join(".")}`), gray("paths, found"), white(`${entities.length}`), green.bold(`${r.cstr.name}`) + green(".") + yellow(r.name), gray(`to ${action}`));
-        if (entities.length > 0) {
-            this.log("   ", // indent
-            gray("["), todo.map((e) => e.toTaggedString()).join(" "), gray("] -> ["), [...new Set(entities)].map((e) => e.toTaggedString()).join(" "), gray("]"));
-        }
-    }
-    /** After finding the RFs/RQFs/Reactions to recalc, we call their `.load` promise to update. */
-    logLoadingStart(em, actions) {
-        this.log(" ", gray("Loading"), String(actions.length), gray("actions..."), this.entityCount(em));
-        // Group by the action name
-        [...(0, utils_1.groupBy)(actions, (a) => `${a.entity.constructor.name},${a.r.name}`).values()].forEach((actions) => {
-            const { r, entity } = actions[0];
-            this.log("   ", green.bold(entity.constructor.name) + green(".") + yellow(r.name), gray("-> ["), String(actions.map((a) => a.entity.toTaggedString()).join(" ")), gray("]"));
-        });
-    }
-    /** We've completed loading/evaling the reactions. */
-    logLoadingEnd(em, millis) {
-        this.log("   ", gray("took"), String(Math.floor(millis)), gray("millis"), this.entityCount(em));
-    }
-    entityCount(em) {
-        return gray("(em.entities=") + em.entities.length + gray(")");
-    }
-    log(...line) {
-        this.writeFn(`${line.join(" ")}\n`);
-    }
-}
-exports.ReactionLogger = ReactionLogger;
 function setReactionLogging(arg) {
-    exports.globalLogger = typeof arg === "boolean" ? (arg ? new ReactionLogger() : undefined) : arg;
+	globalLogger = typeof arg === "boolean" ? arg ? new ReactionLogger() : void 0 : arg;
 }
 function maybeDotPath(r) {
-    return r.path.length > 0 ? `.${r.path.join(".")}.` : ".";
+	return r.path.length > 0 ? `.${r.path.join(".")}.` : ".";
 }
+var NoopReactionLogger = class extends ReactionLogger {
+	now() {
+		return 0;
+	}
+	logQueued(entity, fieldName, r) {}
+	logQueuedAll(entity, reason, r) {}
+	logStartingRecalc(em, kind) {}
+	logStartingValidate(em, todos) {}
+	logWalks(walks, action) {}
+	logLoadingStart(em, actions) {}
+	logLoadingEnd(em, millis) {}
+};
+/** A shared no-op logger that avoids optional chaining in hot reaction paths. */
+const noopReactionLogger = new NoopReactionLogger();
+//#endregion
+export { ReactionLogger, globalLogger, noopReactionLogger, setReactionLogging };
+
 //# sourceMappingURL=ReactionLogger.js.map

package/build/logging/ReactionLogger.js.map

@@ -1 +1 @@
-{"version":3,"file":"ReactionLogger.js","sourceRoot":"","sources":["../../src/logging/ReactionLogger.ts"],"names":[],"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":";;;;;;AAQA,MAAM,EAAE,MAAM,OAAO,QAAQ,UAAU;AAEvC,IAAW,eAA2C,KAAA;AAQtD,IAAa,iBAAb,MAA4B;CAC1B;CAGA,YAAY,UAAmB,QAAQ,OAAO,MAAM,KAAK,QAAQ,MAAM,GAAG;EACxE,KAAK,UAAU;CACjB;CAEA,MAAc;EACZ,OAAO,YAAY,IAAI;CACzB;CAEA,UAAU,QAAgB,WAAmB,GAAoB;EAC/D,KAAK,IACH,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,OAAO,IAAI,WAAW,GACjE,KAAK,kBAAkB,GACvB,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,OAAO,aAAa,CAAC,CAAC,IAAI,OAAO,EAAE,IAAI,CACpF;CACF;CAEA,aAAa,QAAgB,QAAgB,GAAoB;EAC/D,KAAK,IACH,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,GACvC,KAAK,GAAG,OAAO,UAAU,GACzB,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,MAAM,aAAa,CAAC,CAAC,IAAI,OAAO,EAAE,IAAI,CACnF;CACF;CAEA,kBAAkB,IAAmB,MAA8C;EACjF,KAAK,IACH,MAAM,KAAK,0BAA0B,SAAS,oBAAoB,YAAY,SAAS,WAAW,GAClG,KAAK,YAAY,EAAE,CACrB;CACF;CAEA,oBAAoB,IAAmB,OAAmC;EACxE,MAAM,QAAQ,OAAO,OAAO,KAAK,CAAC,CAAC,QAChC,KAAK,MAAM,MAAM,EAAE,QAAQ,SAAS,EAAE,QAAQ,SAAS,EAAE,QAAQ,QAClE,CACF;EACA,KAAK,IAAI,MAAM,KAAK,mBAAmB,MAAM,qBAAqB,GAAG,KAAK,YAAY,EAAE,CAAC;CAC3F;;CAGA,SAAS,OAA8C,QAAqC;EAC1F,MAAM,UAAU,MAAM,QAAQ,SAAS,SAAS,KAAA,CAAS,CAAC,CAAC,MAAM,GAAG,MAAM,EAAE,EAAE,KAAK,SAAS,EAAE,EAAE,KAAK,MAAM;EAC3G,KAAK,MAAM,EAAE,MAAM,GAAG,cAAc,SAAS;GAC3C,MAAM,OAAO,KAAK,EAAE,CAAC,YAAY;GACjC,KAAK,IACH,KACA,KAAK,QAAQ,GACb,MAAM,GAAG,KAAK,QAAQ,GACtB,MAAM,KAAK,GAAG,MAAM,IAAI,MAAM,IAAI,EAAE,KAAK,WAAW,IAAI,WAAW,EAAE,KAAK,KAAK,GAAG,GAAG,GACrF,KAAK,cAAc,GACnB,MAAM,GAAG,SAAS,QAAQ,GAC1B,MAAM,KAAK,GAAG,EAAE,KAAK,MAAM,IAAI,MAAM,GAAG,IAAI,OAAO,EAAE,IAAI,GACzD,KAAK,MAAM,QAAQ,CACrB;GACA,IAAI,SAAS,SAAS,GACpB,KAAK,IACH,OACA,KAAK,GAAG,GACR,KAAK,KAAK,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,GAAG,GAC5C,KAAK,QAAQ,GACb,CAAC,GAAG,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,GAAG,GAC9D,KAAK,GAAG,CACV;EAEJ;CACF;;CAGA,gBAAgB,IAAmB,SAAiC;EAClE,KAAK,IAAI,KAAK,KAAK,SAAS,GAAG,OAAO,QAAQ,MAAM,GAAG,KAAK,YAAY,GAAG,KAAK,YAAY,EAAE,CAAC;EAC/F,MAAM,UAAU,CAAC,GAAG,OAAO,CAAC,CAAC,MAAM,GAAG,MAAM,EAAE,EAAE,KAAK,SAAS,EAAE,EAAE,KAAK,MAAM;EAC7E,CAAC,GAAG,QAAQ,UAAU,MAAM,GAAG,EAAE,OAAO,YAAY,KAAK,GAAG,EAAE,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,YAAY;GACrG,MAAM,EAAE,GAAG,WAAW,QAAQ;GAC9B,KAAK,IACH,OACA,MAAM,KAAK,OAAO,YAAY,IAAI,IAAI,MAAM,GAAG,IAAI,OAAO,EAAE,IAAI,GAChE,KAAK,MAAM,GACX,OAAO,QAAQ,KAAK,MAAM,EAAE,OAAO,eAAe,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,GAC9D,KAAK,GAAG,CACV;EACF,CAAC;CACH;;CAGA,cAAc,IAAmB,QAAsB;EACrD,KAAK,IAAI,OAAO,KAAK,MAAM,GAAG,OAAO,KAAK,MAAM,MAAM,CAAC,GAAG,KAAK,QAAQ,GAAG,KAAK,YAAY,EAAE,CAAC;CAChG;CAEA,YAAoB,IAA2B;EAC7C,OAAO,KAAK,eAAe,IAAI,GAAG,SAAS,SAAS,KAAK,GAAG;CAC9D;CAEA,IAAY,GAAG,MAAsB;EACnC,KAAK,QAAQ,GAAG,KAAK,KAAK,GAAG,EAAE,GAAG;CACpC;AACF;AAIA,SAAgB,mBAAmB,KAAqC;CACtE,eAAe,OAAO,QAAQ,YAAa,MAAM,IAAI,eAAe,IAAI,KAAA,IAAa;AACvF;AAEA,SAAS,aAAa,GAAsB;CAC1C,OAAO,EAAE,KAAK,SAAS,IAAI,IAAI,EAAE,KAAK,KAAK,GAAG,EAAE,KAAK;AACvD;AAEA,IAAM,qBAAN,cAAiC,eAAe;CAC9C,MAAc;EACZ,OAAO;CACT;CAEA,UAAU,QAAgB,WAAmB,GAAoB,CAAC;CAElE,aAAa,QAAgB,QAAgB,GAAoB,CAAC;CAElE,kBAAkB,IAAmB,MAA8C,CAAC;CAEpF,oBAAoB,IAAmB,OAAmC,CAAC;CAE3E,SAAS,OAA8C,QAAqC,CAAC;CAE7F,gBAAgB,IAAmB,SAAiC,CAAC;CAErE,cAAc,IAAmB,QAAsB,CAAC;AAC1D;;AAGA,MAAa,qBAAqC,IAAI,mBAAmB"}

package/build/newEntity.cjs

@@ -0,0 +1,89 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_utils = require("./utils.cjs");
+const require_getProperties = require("./getProperties.cjs");
+const require_EntityMetadata = require("./EntityMetadata.cjs");
+require("./EntityManager.cjs");
+require("./Entity.cjs");
+const require_BaseEntity = require("./BaseEntity.cjs");
+//#region src/newEntity.ts
+const lazySymbol = Symbol("lazy");
+/**
+* Constructs an instance of `cstr` but with relations all made lazy.
+*
+* Specifically we avoid going through `new` b/c that invokes the `constructor` which instantiates
+* the instance-level class fields/relations like `books = hasMany`.
+*
+* Instead, we just call `Object.create`, which does not make any constructor/super calls, and instead
+* let any `this.books` accesses resolve to the getters we've installed on the prototype.
+*/
+function newEntity(em, cstr, isNew) {
+	if (!Object.hasOwn(cstr, lazySymbol)) {
+		moveRelationsToGetters(cstr);
+		cstr[lazySymbol] = true;
+	}
+	const meta = require_EntityMetadata.getMetadata(cstr);
+	if (meta.ctiAbstract) require_utils.fail(`Cannot create an instance of abstract entity ${meta.type}`);
+	const entity = Object.create(cstr.prototype);
+	require_BaseEntity.baseEntityCstr(em, entity, isNew);
+	return entity;
+}
+function moveRelationsToGetters(cstr) {
+	let transientFieldsValue = {};
+	for (const [fieldName, value] of require_getProperties.getLazyFields(require_EntityMetadata.getMetadata(cstr))) if (value instanceof LazyRelation) Object.defineProperty(cstr.prototype, fieldName, { get() {
+		return (this.__data.relations ??= {})[fieldName] ??= value.create(this, fieldName);
+	} });
+	else if (fieldName === "transientFields") transientFieldsValue = value;
+	const needsClone = require_utils.hasAnyKey(transientFieldsValue);
+	Object.defineProperty(cstr.prototype, "transientFields", { get() {
+		const copy = needsClone ? structuredClone(transientFieldsValue) : {};
+		Object.defineProperty(this, "transientFields", { value: copy });
+		return copy;
+	} });
+}
+/**
+* A function for `has...` methods to integrate with the `newEntity` lazy field system.
+*
+* We need TypeScript to still see `books = hasMany(...)` as being typed as `Many<Book>`,
+* so this method's return type is `R` i.e. the `Many<Book>` relation type.
+*
+* But at runtime we actually want this to be a `LazyRelation` that can be rewritten
+* into a getter, and only invoked when the relation is actually accessed.
+*/
+function lazyField(fn) {
+	return new LazyRelation(fn);
+}
+/**
+* Easily resolves `otherMetadata` fields for lazy relations.
+*
+* When `lazyRelation`s are initialized for their first/only time, i.e. the `books = hasBooks(authorMetadata)`
+* call that `getFakeInstance` does, it's when the class bodies are still being evaled, which is before the
+* `metadata.ts` file has run.
+*
+* This means that any `authorMetadata` consts would still be undefined.
+*
+* So instead we just do not bother passing metadata consts to `has...` methods, and instead let the methods
+* one-time resolve `otherMetadata` on their first invocation, which will be after the `metadata.ts` file has
+* finished importing, and the consts are all defined.
+*/
+function resolveOtherMeta(entity, fieldName) {
+	const meta = require_EntityMetadata.getMetadata(entity);
+	return (meta.allFields[fieldName] ?? require_utils.fail(`Could not find field ${meta.type}.${fieldName}`)).otherMetadata();
+}
+/** Wraps `has...` relation constructors in an easily-identifiable container. */
+var LazyRelation = class {
+	#fn;
+	constructor(fn) {
+		this.#fn = fn;
+	}
+	/** Called by our getters to lazily create the relation on first access. */
+	create(entity, fieldName) {
+		return this.#fn(entity, fieldName);
+	}
+};
+//#endregion
+exports.LazyRelation = LazyRelation;
+exports.lazyField = lazyField;
+exports.newEntity = newEntity;
+exports.resolveOtherMeta = resolveOtherMeta;
+
+//# sourceMappingURL=newEntity.cjs.map

package/build/newEntity.cjs.map

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

package/build/newEntity.d.cts

@@ -0,0 +1,48 @@
+import { EntityMetadata } from "./EntityMetadata.cjs";
+import { EntityConstructor, EntityManager } from "./EntityManager.cjs";
+import { Entity } from "./Entity.cjs";
+//#region src/newEntity.d.ts
+/**
+ * Constructs an instance of `cstr` but with relations all made lazy.
+ *
+ * Specifically we avoid going through `new` b/c that invokes the `constructor` which instantiates
+ * the instance-level class fields/relations like `books = hasMany`.
+ *
+ * Instead, we just call `Object.create`, which does not make any constructor/super calls, and instead
+ * let any `this.books` accesses resolve to the getters we've installed on the prototype.
+ */
+declare function newEntity<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>, isNew: boolean): T;
+/**
+ * A function for `has...` methods to integrate with the `newEntity` lazy field system.
+ *
+ * We need TypeScript to still see `books = hasMany(...)` as being typed as `Many<Book>`,
+ * so this method's return type is `R` i.e. the `Many<Book>` relation type.
+ *
+ * But at runtime we actually want this to be a `LazyRelation` that can be rewritten
+ * into a getter, and only invoked when the relation is actually accessed.
+ */
+declare function lazyField<T extends Entity, R>(fn: (entity: T, fieldName: string) => R): R;
+/**
+ * Easily resolves `otherMetadata` fields for lazy relations.
+ *
+ * When `lazyRelation`s are initialized for their first/only time, i.e. the `books = hasBooks(authorMetadata)`
+ * call that `getFakeInstance` does, it's when the class bodies are still being evaled, which is before the
+ * `metadata.ts` file has run.
+ *
+ * This means that any `authorMetadata` consts would still be undefined.
+ *
+ * So instead we just do not bother passing metadata consts to `has...` methods, and instead let the methods
+ * one-time resolve `otherMetadata` on their first invocation, which will be after the `metadata.ts` file has
+ * finished importing, and the consts are all defined.
+ */
+declare function resolveOtherMeta(entity: Entity, fieldName: string): EntityMetadata;
+/** Wraps `has...` relation constructors in an easily-identifiable container. */
+declare class LazyRelation<T extends Entity> {
+  #private;
+  constructor(fn: (entity: T, fieldName: string) => any);
+  /** Called by our getters to lazily create the relation on first access. */
+  create(entity: T, fieldName: string): any;
+}
+//#endregion
+export { LazyRelation, lazyField, newEntity, resolveOtherMeta };
+//# sourceMappingURL=newEntity.d.cts.map

package/build/newEntity.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"newEntity.d.cts","names":[],"sources":["../src/newEntity.ts"],"mappings":";;;;;;;;;;;;;iBAmBgB,UAAU,UAAU,QAAQ,IAAI,eAAe,MAAM,kBAAkB,IAAI,iBAAiB;;;;;;;;;;iBAuD5F,UAAU,UAAU,QAAQ,GAAG,KAAK,QAAQ,GAAG,sBAAsB,IAAI;;;;;;;;;;;;;;iBAiBzE,iBAAiB,QAAQ,QAAQ,oBAAoB;;cAOxD,aAAa,UAAU;;EAElC,YAAY,KAAK,QAAQ,GAAG;;EAK5B,OAAO,QAAQ,GAAG"}

package/build/newEntity.d.mts

@@ -0,0 +1,48 @@
+import { EntityMetadata } from "./EntityMetadata.mjs";
+import { EntityConstructor, EntityManager } from "./EntityManager.mjs";
+import { Entity } from "./Entity.mjs";
+//#region src/newEntity.d.ts
+/**
+ * Constructs an instance of `cstr` but with relations all made lazy.
+ *
+ * Specifically we avoid going through `new` b/c that invokes the `constructor` which instantiates
+ * the instance-level class fields/relations like `books = hasMany`.
+ *
+ * Instead, we just call `Object.create`, which does not make any constructor/super calls, and instead
+ * let any `this.books` accesses resolve to the getters we've installed on the prototype.
+ */
+declare function newEntity<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>, isNew: boolean): T;
+/**
+ * A function for `has...` methods to integrate with the `newEntity` lazy field system.
+ *
+ * We need TypeScript to still see `books = hasMany(...)` as being typed as `Many<Book>`,
+ * so this method's return type is `R` i.e. the `Many<Book>` relation type.
+ *
+ * But at runtime we actually want this to be a `LazyRelation` that can be rewritten
+ * into a getter, and only invoked when the relation is actually accessed.
+ */
+declare function lazyField<T extends Entity, R>(fn: (entity: T, fieldName: string) => R): R;
+/**
+ * Easily resolves `otherMetadata` fields for lazy relations.
+ *
+ * When `lazyRelation`s are initialized for their first/only time, i.e. the `books = hasBooks(authorMetadata)`
+ * call that `getFakeInstance` does, it's when the class bodies are still being evaled, which is before the
+ * `metadata.ts` file has run.
+ *
+ * This means that any `authorMetadata` consts would still be undefined.
+ *
+ * So instead we just do not bother passing metadata consts to `has...` methods, and instead let the methods
+ * one-time resolve `otherMetadata` on their first invocation, which will be after the `metadata.ts` file has
+ * finished importing, and the consts are all defined.
+ */
+declare function resolveOtherMeta(entity: Entity, fieldName: string): EntityMetadata;
+/** Wraps `has...` relation constructors in an easily-identifiable container. */
+declare class LazyRelation<T extends Entity> {
+  #private;
+  constructor(fn: (entity: T, fieldName: string) => any);
+  /** Called by our getters to lazily create the relation on first access. */
+  create(entity: T, fieldName: string): any;
+}
+//#endregion
+export { LazyRelation, lazyField, newEntity, resolveOtherMeta };
+//# sourceMappingURL=newEntity.d.mts.map

package/build/newEntity.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"newEntity.d.mts","names":[],"sources":["../src/newEntity.ts"],"mappings":";;;;;;;;;;;;;iBAmBgB,UAAU,UAAU,QAAQ,IAAI,eAAe,MAAM,kBAAkB,IAAI,iBAAiB;;;;;;;;;;iBAuD5F,UAAU,UAAU,QAAQ,GAAG,KAAK,QAAQ,GAAG,sBAAsB,IAAI;;;;;;;;;;;;;;iBAiBzE,iBAAiB,QAAQ,QAAQ,oBAAoB;;cAOxD,aAAa,UAAU;;EAElC,YAAY,KAAK,QAAQ,GAAG;;EAK5B,OAAO,QAAQ,GAAG"}