velocious 1.0.552 → 1.0.555

package/build/src/testing/factory/evaluation-context.d.ts

@@ -0,0 +1,95 @@
+/**
+ * A single factory run's evaluation state. It resolves attributes/transients/
+ * associations lazily and memoizes each name exactly once per run (sharing an
+ * in-flight promise between concurrent dependents). Cycle detection uses a
+ * per-chain path so genuine recursion is reported while concurrent sibling reads
+ * of the same name are allowed.
+ */
+export default class EvaluationContext {
+    /**
+     * Builds an evaluation context.
+     * @param {object} args - Options.
+     * @param {import("./factory-registry.js").default} args.registry - Owning registry.
+     * @param {import("./factory-runner.js").CompiledPlan} args.plan - Compiled run plan.
+     * @param {"attributesFor" | "build" | "create"} args.strategy - Active strategy.
+     */
+    constructor({ registry, plan, strategy }: {
+        registry: import("./factory-registry.js").default;
+        plan: import("./factory-runner.js").CompiledPlan;
+        strategy: "attributesFor" | "build" | "create";
+    });
+    /** @type {import("./factory-registry.js").default} - Owning registry. */
+    registry: import("./factory-registry.js").default;
+    /** @type {import("./factory-runner.js").CompiledPlan} - Compiled run plan. */
+    plan: import("./factory-runner.js").CompiledPlan;
+    /** @type {"attributesFor" | "build" | "create"} - Active strategy. */
+    strategy: "attributesFor" | "build" | "create";
+    /** @type {Map<string, ?>} - Per-run memoized values / in-flight promises. */
+    _memo: Map<string, unknown>;
+    /**
+     * Builds the named evaluator context handed to lazy values and callbacks for a
+     * given dependency path.
+     * @param {string[]} path - Current resolution path (for cycle detection).
+     * @returns {{get: (name: string) => Promise<?>, generate: (name: string) => Promise<?>, association: (factory: string, ...args: Array<?>) => Promise<?>}} - The evaluator context.
+     */
+    contextFor(path: string[]): {
+        get: (name: string) => Promise<unknown>;
+        generate: (name: string) => Promise<unknown>;
+        association: (factory: string, ...args: Array<unknown>) => Promise<unknown>;
+    };
+    /**
+     * Resolves an attribute/transient/association by name, memoizing the result.
+     * @param {string} name - Name to resolve.
+     * @param {string[]} path - Current resolution path.
+     * @returns {Promise<?>} - The resolved value.
+     */
+    _get(name: string, path: string[]): Promise<unknown>;
+    /**
+     * Evaluates a resolved slot, honouring lazy functions and overrides.
+     * @param {import("./factory-runner.js").Slot} slot - Slot to evaluate.
+     * @param {string[]} childPath - Path including this slot's name.
+     * @returns {Promise<?>} - The evaluated value.
+     */
+    _evaluateSlot(slot: import("./factory-runner.js").Slot, childPath: string[]): Promise<unknown>;
+    /**
+     * Resolves a declared/overridden association slot. An explicit object/null
+     * override suppresses nested factory execution and is returned verbatim.
+     * @param {import("./factory-runner.js").Slot} slot - Association slot.
+     * @returns {Promise<?>} - The associated record (or override value).
+     */
+    _resolveAssociationSlot(slot: import("./factory-runner.js").Slot): Promise<unknown>;
+    /**
+     * Runs an explicitly-invoked association from a lazy value's `association(...)`.
+     * @param {string} factoryName - Factory to run.
+     * @param {Array<?>} args - Traits and/or an overrides object.
+     * @param {string[]} _path - Current resolution path (unused; associations open a fresh run).
+     * @returns {Promise<?>} - The associated record, or null under attributesFor.
+     */
+    _explicitAssociation(factoryName: string, args: Array<unknown>, _path: string[]): Promise<unknown>;
+    /**
+     * Resolves every plain attribute slot (used by attributesFor). Transients and
+     * associations are omitted, though transients may still be evaluated on demand
+     * as dependencies.
+     * @returns {Promise<Record<string, ?>>} - The resolved attributes.
+     */
+    resolveAttributes(): Promise<Record<string, unknown>>;
+    /**
+     * Resolves every transient before callbacks that expose them as plain properties.
+     * @returns {Promise<Record<string, ?>>} - Evaluated transient values.
+     */
+    resolveTransients(): Promise<Record<string, unknown>>;
+    /**
+     * Resolves everything needed to construct a record: public attributes,
+     * transients, and associated records.
+     * @returns {Promise<{publicAttributes: Record<string, ?>, transients: Record<string, ?>, associations: Array<{name: string, record: ?}>}>} - Resolved construction inputs.
+     */
+    resolveForConstruction(): Promise<{
+        publicAttributes: Record<string, unknown>;
+        transients: Record<string, unknown>;
+        associations: Array<{
+            name: string;
+            record: unknown;
+        }>;
+    }>;
+}
+//# sourceMappingURL=evaluation-context.d.ts.map

package/build/src/testing/factory/evaluation-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation-context.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/evaluation-context.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH;IACE;;;;;;OAMG;IACH,0CAJG;QAAsD,QAAQ,EAAtD,OAAO,uBAAuB,EAAE,OAAO;QACU,IAAI,EAArD,OAAO,qBAAqB,EAAE,YAAY;QACC,QAAQ,EAAnD,eAAe,GAAG,OAAO,GAAG,QAAQ;KAC9C,EAaA;IAXC,yEAAyE;IACzE,UADW,OAAO,uBAAuB,EAAE,OAAO,CAC1B;IAExB,8EAA8E;IAC9E,MADW,OAAO,qBAAqB,EAAE,YAAY,CACrC;IAEhB,sEAAsE;IACtE,UADW,eAAe,GAAG,OAAO,GAAG,QAAQ,CACvB;IAExB,6EAA6E;IAC7E,OADW,GAAG,CAAC,MAAM,EAAE,OAAC,CAAC,CACH;IAGxB;;;;;OAKG;IACH,iBAHW,MAAM,EAAE,GACN;QAAC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAC,CAAC,CAAC;QAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAC,CAAC,CAAC;QAAC,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAC,CAAC,KAAK,OAAO,CAAC,OAAC,CAAC,CAAA;KAAC,CAQxJ;IAED;;;;;OAKG;IACH,WAJW,MAAM,QACN,MAAM,EAAE,GACN,OAAO,CAAC,OAAC,CAAC,CAqBtB;IAED;;;;;OAKG;IACH,oBAJW,OAAO,qBAAqB,EAAE,IAAI,aAClC,MAAM,EAAE,GACN,OAAO,CAAC,OAAC,CAAC,CAYtB;IAED;;;;;OAKG;IACH,8BAHW,OAAO,qBAAqB,EAAE,IAAI,GAChC,OAAO,CAAC,OAAC,CAAC,CAgBtB;IAED;;;;;;OAMG;IACH,kCALW,MAAM,QACN,KAAK,CAAC,OAAC,CAAC,SACR,MAAM,EAAE,GACN,OAAO,CAAC,OAAC,CAAC,CAkBtB;IAED;;;;;OAKG;IACH,qBAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAatC;IAED;;;OAGG;IACH,qBAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAWtC;IAED;;;;OAIG;IACH,0BAFa,OAAO,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,YAAY,EAAE,KAAK,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,OAAC,CAAA;SAAC,CAAC,CAAA;KAAC,CAAC,CAqBzI;CACF"}

package/build/src/testing/factory/evaluation-context.js

@@ -0,0 +1,175 @@
+// @ts-check
+import { FactoryCycleError, UndefinedAttributeError } from "./errors.js";
+/**
+ * A single factory run's evaluation state. It resolves attributes/transients/
+ * associations lazily and memoizes each name exactly once per run (sharing an
+ * in-flight promise between concurrent dependents). Cycle detection uses a
+ * per-chain path so genuine recursion is reported while concurrent sibling reads
+ * of the same name are allowed.
+ */
+export default class EvaluationContext {
+    /**
+     * Builds an evaluation context.
+     * @param {object} args - Options.
+     * @param {import("./factory-registry.js").default} args.registry - Owning registry.
+     * @param {import("./factory-runner.js").CompiledPlan} args.plan - Compiled run plan.
+     * @param {"attributesFor" | "build" | "create"} args.strategy - Active strategy.
+     */
+    constructor({ registry, plan, strategy }) {
+        /** @type {import("./factory-registry.js").default} - Owning registry. */
+        this.registry = registry;
+        /** @type {import("./factory-runner.js").CompiledPlan} - Compiled run plan. */
+        this.plan = plan;
+        /** @type {"attributesFor" | "build" | "create"} - Active strategy. */
+        this.strategy = strategy;
+        /** @type {Map<string, ?>} - Per-run memoized values / in-flight promises. */
+        this._memo = new Map();
+    }
+    /**
+     * Builds the named evaluator context handed to lazy values and callbacks for a
+     * given dependency path.
+     * @param {string[]} path - Current resolution path (for cycle detection).
+     * @returns {{get: (name: string) => Promise<?>, generate: (name: string) => Promise<?>, association: (factory: string, ...args: Array<?>) => Promise<?>}} - The evaluator context.
+     */
+    contextFor(path) {
+        return {
+            get: (name) => this._get(name, path),
+            generate: (name) => this.registry._generateScoped(name, this.plan.chainNames),
+            association: (factory, ...args) => this._explicitAssociation(factory, args, path)
+        };
+    }
+    /**
+     * Resolves an attribute/transient/association by name, memoizing the result.
+     * @param {string} name - Name to resolve.
+     * @param {string[]} path - Current resolution path.
+     * @returns {Promise<?>} - The resolved value.
+     */
+    _get(name, path) {
+        if (path.includes(name)) {
+            throw new FactoryCycleError(`Attribute dependency cycle detected: ${[...path, name].join(" -> ")}`);
+        }
+        if (this._memo.has(name))
+            return this._memo.get(name);
+        const slot = this.plan.resolved.get(name);
+        if (!slot) {
+            throw new UndefinedAttributeError(`Unknown attribute "${name}" referenced while evaluating factory "${this.plan.factoryName}"`);
+        }
+        const promise = this._evaluateSlot(slot, [...path, name]);
+        this._memo.set(name, promise);
+        promise.then((value) => this._memo.set(name, value), () => { });
+        return promise;
+    }
+    /**
+     * Evaluates a resolved slot, honouring lazy functions and overrides.
+     * @param {import("./factory-runner.js").Slot} slot - Slot to evaluate.
+     * @param {string[]} childPath - Path including this slot's name.
+     * @returns {Promise<?>} - The evaluated value.
+     */
+    async _evaluateSlot(slot, childPath) {
+        if (slot.slotKind === "association") {
+            return await this._resolveAssociationSlot(slot);
+        }
+        if (typeof slot.value === "function" && !slot.isOverride) {
+            return await slot.value(this.contextFor(childPath));
+        }
+        return slot.value;
+    }
+    /**
+     * Resolves a declared/overridden association slot. An explicit object/null
+     * override suppresses nested factory execution and is returned verbatim.
+     * @param {import("./factory-runner.js").Slot} slot - Association slot.
+     * @returns {Promise<?>} - The associated record (or override value).
+     */
+    async _resolveAssociationSlot(slot) {
+        if (slot.isOverride)
+            return slot.value;
+        if (this.strategy === "attributesFor")
+            return null;
+        const declaration = /** @type {import("./association-declaration.js").default} */ (slot.value);
+        const associationStrategy = declaration.strategy || (this.strategy === "create" ? "build" : this.strategy);
+        return await this.registry._runFactory({
+            factoryName: declaration.factory,
+            traits: declaration.traits,
+            overrides: declaration.overrides,
+            strategy: /** @type {"build" | "create"} */ (associationStrategy)
+        });
+    }
+    /**
+     * Runs an explicitly-invoked association from a lazy value's `association(...)`.
+     * @param {string} factoryName - Factory to run.
+     * @param {Array<?>} args - Traits and/or an overrides object.
+     * @param {string[]} _path - Current resolution path (unused; associations open a fresh run).
+     * @returns {Promise<?>} - The associated record, or null under attributesFor.
+     */
+    _explicitAssociation(factoryName, args, _path) {
+        if (this.strategy === "attributesFor")
+            return Promise.resolve(null);
+        /** @type {string[]} */
+        const traits = [];
+        /** @type {Record<string, ?>} */
+        let overrides = {};
+        for (const arg of args) {
+            if (typeof arg === "string")
+                traits.push(arg);
+            else if (arg && typeof arg === "object")
+                overrides = arg;
+        }
+        const associationStrategy = this.strategy === "create" ? "build" : this.strategy;
+        return this.registry._runFactory({ factoryName, traits, overrides, strategy: associationStrategy });
+    }
+    /**
+     * Resolves every plain attribute slot (used by attributesFor). Transients and
+     * associations are omitted, though transients may still be evaluated on demand
+     * as dependencies.
+     * @returns {Promise<Record<string, ?>>} - The resolved attributes.
+     */
+    async resolveAttributes() {
+        /** @type {Record<string, ?>} */
+        const attributes = {};
+        for (const [name, slot] of this.plan.resolved) {
+            if (slot.slotKind === "attribute") {
+                attributes[name] = await this._get(name, []);
+            }
+        }
+        return attributes;
+    }
+    /**
+     * Resolves every transient before callbacks that expose them as plain properties.
+     * @returns {Promise<Record<string, ?>>} - Evaluated transient values.
+     */
+    async resolveTransients() {
+        /** @type {Record<string, ?>} */
+        const transients = {};
+        for (const [name, slot] of this.plan.resolved) {
+            if (slot.slotKind === "transient")
+                transients[name] = await this._get(name, []);
+        }
+        return transients;
+    }
+    /**
+     * Resolves everything needed to construct a record: public attributes,
+     * transients, and associated records.
+     * @returns {Promise<{publicAttributes: Record<string, ?>, transients: Record<string, ?>, associations: Array<{name: string, record: ?}>}>} - Resolved construction inputs.
+     */
+    async resolveForConstruction() {
+        /** @type {Record<string, ?>} */
+        const publicAttributes = {};
+        /** @type {Record<string, ?>} */
+        const transients = {};
+        /** @type {Array<{name: string, record: ?}>} */
+        const associations = [];
+        for (const [name, slot] of this.plan.resolved) {
+            if (slot.slotKind === "attribute") {
+                publicAttributes[name] = await this._get(name, []);
+            }
+            else if (slot.slotKind === "transient") {
+                transients[name] = await this._get(name, []);
+            }
+            else if (slot.slotKind === "association") {
+                associations.push({ name, record: await this._get(name, []) });
+            }
+        }
+        return { publicAttributes, transients, associations };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluation-context.js","sourceRoot":"","sources":["../../../../src/testing/factory/evaluation-context.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {FactoryCycleError, UndefinedAttributeError} from \"./errors.js\"\n\n/**\n * A single factory run's evaluation state. It resolves attributes/transients/\n * associations lazily and memoizes each name exactly once per run (sharing an\n * in-flight promise between concurrent dependents). Cycle detection uses a\n * per-chain path so genuine recursion is reported while concurrent sibling reads\n * of the same name are allowed.\n */\nexport default class EvaluationContext {\n  /**\n   * Builds an evaluation context.\n   * @param {object} args - Options.\n   * @param {import(\"./factory-registry.js\").default} args.registry - Owning registry.\n   * @param {import(\"./factory-runner.js\").CompiledPlan} args.plan - Compiled run plan.\n   * @param {\"attributesFor\" | \"build\" | \"create\"} args.strategy - Active strategy.\n   */\n  constructor({registry, plan, strategy}) {\n    /** @type {import(\"./factory-registry.js\").default} - Owning registry. */\n    this.registry = registry\n\n    /** @type {import(\"./factory-runner.js\").CompiledPlan} - Compiled run plan. */\n    this.plan = plan\n\n    /** @type {\"attributesFor\" | \"build\" | \"create\"} - Active strategy. */\n    this.strategy = strategy\n\n    /** @type {Map<string, ?>} - Per-run memoized values / in-flight promises. */\n    this._memo = new Map()\n  }\n\n  /**\n   * Builds the named evaluator context handed to lazy values and callbacks for a\n   * given dependency path.\n   * @param {string[]} path - Current resolution path (for cycle detection).\n   * @returns {{get: (name: string) => Promise<?>, generate: (name: string) => Promise<?>, association: (factory: string, ...args: Array<?>) => Promise<?>}} - The evaluator context.\n   */\n  contextFor(path) {\n    return {\n      get: (name) => this._get(name, path),\n      generate: (name) => this.registry._generateScoped(name, this.plan.chainNames),\n      association: (factory, ...args) => this._explicitAssociation(factory, args, path)\n    }\n  }\n\n  /**\n   * Resolves an attribute/transient/association by name, memoizing the result.\n   * @param {string} name - Name to resolve.\n   * @param {string[]} path - Current resolution path.\n   * @returns {Promise<?>} - The resolved value.\n   */\n  _get(name, path) {\n    if (path.includes(name)) {\n      throw new FactoryCycleError(`Attribute dependency cycle detected: ${[...path, name].join(\" -> \")}`)\n    }\n\n    if (this._memo.has(name)) return this._memo.get(name)\n\n    const slot = this.plan.resolved.get(name)\n\n    if (!slot) {\n      throw new UndefinedAttributeError(`Unknown attribute \"${name}\" referenced while evaluating factory \"${this.plan.factoryName}\"`)\n    }\n\n    const promise = this._evaluateSlot(slot, [...path, name])\n\n    this._memo.set(name, promise)\n    promise.then((value) => this._memo.set(name, value), () => {})\n\n    return promise\n  }\n\n  /**\n   * Evaluates a resolved slot, honouring lazy functions and overrides.\n   * @param {import(\"./factory-runner.js\").Slot} slot - Slot to evaluate.\n   * @param {string[]} childPath - Path including this slot's name.\n   * @returns {Promise<?>} - The evaluated value.\n   */\n  async _evaluateSlot(slot, childPath) {\n    if (slot.slotKind === \"association\") {\n      return await this._resolveAssociationSlot(slot)\n    }\n\n    if (typeof slot.value === \"function\" && !slot.isOverride) {\n      return await slot.value(this.contextFor(childPath))\n    }\n\n    return slot.value\n  }\n\n  /**\n   * Resolves a declared/overridden association slot. An explicit object/null\n   * override suppresses nested factory execution and is returned verbatim.\n   * @param {import(\"./factory-runner.js\").Slot} slot - Association slot.\n   * @returns {Promise<?>} - The associated record (or override value).\n   */\n  async _resolveAssociationSlot(slot) {\n    if (slot.isOverride) return slot.value\n\n    if (this.strategy === \"attributesFor\") return null\n\n    const declaration = /** @type {import(\"./association-declaration.js\").default} */ (slot.value)\n    const associationStrategy = declaration.strategy || (this.strategy === \"create\" ? \"build\" : this.strategy)\n\n    return await this.registry._runFactory({\n      factoryName: declaration.factory,\n      traits: declaration.traits,\n      overrides: declaration.overrides,\n      strategy: /** @type {\"build\" | \"create\"} */ (associationStrategy)\n    })\n  }\n\n  /**\n   * Runs an explicitly-invoked association from a lazy value's `association(...)`.\n   * @param {string} factoryName - Factory to run.\n   * @param {Array<?>} args - Traits and/or an overrides object.\n   * @param {string[]} _path - Current resolution path (unused; associations open a fresh run).\n   * @returns {Promise<?>} - The associated record, or null under attributesFor.\n   */\n  _explicitAssociation(factoryName, args, _path) {\n    if (this.strategy === \"attributesFor\") return Promise.resolve(null)\n\n    /** @type {string[]} */\n    const traits = []\n    /** @type {Record<string, ?>} */\n    let overrides = {}\n\n    for (const arg of args) {\n      if (typeof arg === \"string\") traits.push(arg)\n      else if (arg && typeof arg === \"object\") overrides = arg\n    }\n\n    const associationStrategy = this.strategy === \"create\" ? \"build\" : this.strategy\n\n    return this.registry._runFactory({factoryName, traits, overrides, strategy: associationStrategy})\n  }\n\n  /**\n   * Resolves every plain attribute slot (used by attributesFor). Transients and\n   * associations are omitted, though transients may still be evaluated on demand\n   * as dependencies.\n   * @returns {Promise<Record<string, ?>>} - The resolved attributes.\n   */\n  async resolveAttributes() {\n    /** @type {Record<string, ?>} */\n    const attributes = {}\n\n    for (const [name, slot] of this.plan.resolved) {\n      if (slot.slotKind === \"attribute\") {\n        attributes[name] = await this._get(name, [])\n      }\n    }\n\n    return attributes\n  }\n\n  /**\n   * Resolves every transient before callbacks that expose them as plain properties.\n   * @returns {Promise<Record<string, ?>>} - Evaluated transient values.\n   */\n  async resolveTransients() {\n    /** @type {Record<string, ?>} */\n    const transients = {}\n\n    for (const [name, slot] of this.plan.resolved) {\n      if (slot.slotKind === \"transient\") transients[name] = await this._get(name, [])\n    }\n\n    return transients\n  }\n\n  /**\n   * Resolves everything needed to construct a record: public attributes,\n   * transients, and associated records.\n   * @returns {Promise<{publicAttributes: Record<string, ?>, transients: Record<string, ?>, associations: Array<{name: string, record: ?}>}>} - Resolved construction inputs.\n   */\n  async resolveForConstruction() {\n    /** @type {Record<string, ?>} */\n    const publicAttributes = {}\n    /** @type {Record<string, ?>} */\n    const transients = {}\n    /** @type {Array<{name: string, record: ?}>} */\n    const associations = []\n\n    for (const [name, slot] of this.plan.resolved) {\n      if (slot.slotKind === \"attribute\") {\n        publicAttributes[name] = await this._get(name, [])\n      } else if (slot.slotKind === \"transient\") {\n        transients[name] = await this._get(name, [])\n      } else if (slot.slotKind === \"association\") {\n        associations.push({name, record: await this._get(name, [])})\n      }\n    }\n\n    return {publicAttributes, transients, associations}\n  }\n}\n"]}

package/build/src/testing/factory/events.d.ts

@@ -0,0 +1,21 @@
+declare const FactoryEventEmitter_base: typeof import("eventemitter3").EventEmitter;
+/**
+ * A small factory event emitter used for debug/performance hooks. It emits
+ * `start`, `success` and `failure` events carrying the factory name, strategy,
+ * requested traits, a per-invocation correlation id and (on completion) a
+ * duration. It deliberately never emits resolved attribute values, which may
+ * contain secrets.
+ */
+export default class FactoryEventEmitter extends FactoryEventEmitter_base {
+    /** Builds the emitter. */
+    constructor();
+    /** @type {number} - Monotonic invocation counter for correlation ids. */
+    _invocationCounter: number;
+    /**
+     * Allocates the next per-invocation correlation id.
+     * @returns {string} - A unique-per-registry correlation id.
+     */
+    nextInvocationId(): string;
+}
+export {};
+//# sourceMappingURL=events.d.ts.map

package/build/src/testing/factory/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/events.js"],"names":[],"mappings":";AAIA;;;;;;GAMG;AACH;IACE,0BAA0B;IAC1B,cAKC;IAFC,yEAAyE;IACzE,oBADW,MAAM,CACU;IAG7B;;;OAGG;IACH,oBAFa,MAAM,CAMlB;CACF"}

package/build/src/testing/factory/events.js

@@ -0,0 +1,26 @@
+// @ts-check
+import EventEmitter from "../../utils/event-emitter.js";
+/**
+ * A small factory event emitter used for debug/performance hooks. It emits
+ * `start`, `success` and `failure` events carrying the factory name, strategy,
+ * requested traits, a per-invocation correlation id and (on completion) a
+ * duration. It deliberately never emits resolved attribute values, which may
+ * contain secrets.
+ */
+export default class FactoryEventEmitter extends EventEmitter {
+    /** Builds the emitter. */
+    constructor() {
+        super();
+        /** @type {number} - Monotonic invocation counter for correlation ids. */
+        this._invocationCounter = 0;
+    }
+    /**
+     * Allocates the next per-invocation correlation id.
+     * @returns {string} - A unique-per-registry correlation id.
+     */
+    nextInvocationId() {
+        this._invocationCounter += 1;
+        return `factory-invocation-${this._invocationCounter}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3Rlc3RpbmcvZmFjdG9yeS9ldmVudHMuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaLE9BQU8sWUFBWSxNQUFNLDhCQUE4QixDQUFBO0FBRXZEOzs7Ozs7R0FNRztBQUNILE1BQU0sQ0FBQyxPQUFPLE9BQU8sbUJBQW9CLFNBQVEsWUFBWTtJQUMzRCwwQkFBMEI7SUFDMUI7UUFDRSxLQUFLLEVBQUUsQ0FBQTtRQUVQLHlFQUF5RTtRQUN6RSxJQUFJLENBQUMsa0JBQWtCLEdBQUcsQ0FBQyxDQUFBO0lBQzdCLENBQUM7SUFFRDs7O09BR0c7SUFDSCxnQkFBZ0I7UUFDZCxJQUFJLENBQUMsa0JBQWtCLElBQUksQ0FBQyxDQUFBO1FBRTVCLE9BQU8sc0JBQXNCLElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUFBO0lBQ3hELENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuXG5pbXBvcnQgRXZlbnRFbWl0dGVyIGZyb20gXCIuLi8uLi91dGlscy9ldmVudC1lbWl0dGVyLmpzXCJcblxuLyoqXG4gKiBBIHNtYWxsIGZhY3RvcnkgZXZlbnQgZW1pdHRlciB1c2VkIGZvciBkZWJ1Zy9wZXJmb3JtYW5jZSBob29rcy4gSXQgZW1pdHNcbiAqIGBzdGFydGAsIGBzdWNjZXNzYCBhbmQgYGZhaWx1cmVgIGV2ZW50cyBjYXJyeWluZyB0aGUgZmFjdG9yeSBuYW1lLCBzdHJhdGVneSxcbiAqIHJlcXVlc3RlZCB0cmFpdHMsIGEgcGVyLWludm9jYXRpb24gY29ycmVsYXRpb24gaWQgYW5kIChvbiBjb21wbGV0aW9uKSBhXG4gKiBkdXJhdGlvbi4gSXQgZGVsaWJlcmF0ZWx5IG5ldmVyIGVtaXRzIHJlc29sdmVkIGF0dHJpYnV0ZSB2YWx1ZXMsIHdoaWNoIG1heVxuICogY29udGFpbiBzZWNyZXRzLlxuICovXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBGYWN0b3J5RXZlbnRFbWl0dGVyIGV4dGVuZHMgRXZlbnRFbWl0dGVyIHtcbiAgLyoqIEJ1aWxkcyB0aGUgZW1pdHRlci4gKi9cbiAgY29uc3RydWN0b3IoKSB7XG4gICAgc3VwZXIoKVxuXG4gICAgLyoqIEB0eXBlIHtudW1iZXJ9IC0gTW9ub3RvbmljIGludm9jYXRpb24gY291bnRlciBmb3IgY29ycmVsYXRpb24gaWRzLiAqL1xuICAgIHRoaXMuX2ludm9jYXRpb25Db3VudGVyID0gMFxuICB9XG5cbiAgLyoqXG4gICAqIEFsbG9jYXRlcyB0aGUgbmV4dCBwZXItaW52b2NhdGlvbiBjb3JyZWxhdGlvbiBpZC5cbiAgICogQHJldHVybnMge3N0cmluZ30gLSBBIHVuaXF1ZS1wZXItcmVnaXN0cnkgY29ycmVsYXRpb24gaWQuXG4gICAqL1xuICBuZXh0SW52b2NhdGlvbklkKCkge1xuICAgIHRoaXMuX2ludm9jYXRpb25Db3VudGVyICs9IDFcblxuICAgIHJldHVybiBgZmFjdG9yeS1pbnZvY2F0aW9uLSR7dGhpcy5faW52b2NhdGlvbkNvdW50ZXJ9YFxuICB9XG59XG4iXX0=

package/build/src/testing/factory/factory-definition.d.ts

@@ -0,0 +1,39 @@
+/**
+ * An immutable compiled factory. Definitions never mutate after compilation;
+ * `modify` produces a replacement rather than editing an existing one. Parent and
+ * trait references are resolved lazily at evaluation time, so a child may be
+ * declared before its parent.
+ */
+export default class FactoryDefinition {
+    /**
+     * Builds a factory definition.
+     * @param {object} args - Options.
+     * @param {string} args.name - Factory name.
+     * @param {(new (attributes?: Record<string, ?>) => ?) | null} args.modelClass - Model class, or null to inherit from a parent.
+     * @param {string | null} args.parentName - Parent factory name, or null.
+     * @param {string[]} args.aliases - Alias names that reference this same definition.
+     * @param {import("./declarations.js").Declaration[]} args.declarations - Ordered own declarations.
+     * @param {Map<string, import("./trait-definition.js").default>} args.localTraits - Factory-local traits keyed by name.
+     */
+    constructor({ name, modelClass, parentName, aliases, declarations, localTraits }: {
+        name: string;
+        modelClass: (new (attributes?: Record<string, unknown>) => unknown) | null;
+        parentName: string | null;
+        aliases: string[];
+        declarations: import("./declarations.js").Declaration[];
+        localTraits: Map<string, import("./trait-definition.js").default>;
+    });
+    /** @type {string} - Factory name. */
+    name: string;
+    /** @type {(new (attributes?: Record<string, ?>) => ?) | null} - Model class or null. */
+    modelClass: (new (attributes?: Record<string, unknown>) => unknown) | null;
+    /** @type {string | null} - Parent factory name or null. */
+    parentName: string | null;
+    /** @type {Array<string>} - Alias names. */
+    aliases: Array<string>;
+    /** @type {Array<import("./declarations.js").Declaration>} - Ordered own declarations. */
+    declarations: Array<import("./declarations.js").Declaration>;
+    /** @type {Map<string, import("./trait-definition.js").default>} - Factory-local traits. */
+    localTraits: Map<string, import("./trait-definition.js").default>;
+}
+//# sourceMappingURL=factory-definition.d.ts.map

package/build/src/testing/factory/factory-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory-definition.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/factory-definition.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH;IACE;;;;;;;;;OASG;IACH,kFAPG;QAAqB,IAAI,EAAjB,MAAM;QACmD,UAAU,EAAnE,CAAC,KAAK,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,KAAK,OAAC,CAAC,GAAG,IAAI;QAC9B,UAAU,EAA9B,MAAM,GAAG,IAAI;QACE,OAAO,EAAtB,MAAM,EAAE;QACwC,YAAY,EAA5D,OAAO,mBAAmB,EAAE,WAAW,EAAE;QACkB,WAAW,EAAtE,GAAG,CAAC,MAAM,EAAE,OAAO,uBAAuB,EAAE,OAAO,CAAC;KAC9D,EAqBA;IAnBC,qCAAqC;IACrC,MADW,MAAM,CACD;IAEhB,wFAAwF;IACxF,YADW,CAAC,KAAK,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,KAAK,OAAC,CAAC,GAAG,IAAI,CACjC;IAE5B,2DAA2D;IAC3D,YADW,MAAM,GAAG,IAAI,CACI;IAE5B,2CAA2C;IAC3C,SADW,KAAK,CAAC,MAAM,CAAC,CACiD;IAEzE,yFAAyF;IACzF,cADW,KAAK,CAAC,OAAO,mBAAmB,EAAE,WAAW,CAAC,CAC2D;IAEpH,2FAA2F;IAC3F,aADW,GAAG,CAAC,MAAM,EAAE,OAAO,uBAAuB,EAAE,OAAO,CAAC,CACjC;CAIjC"}

package/build/src/testing/factory/factory-definition.js

@@ -0,0 +1,35 @@
+// @ts-check
+/**
+ * An immutable compiled factory. Definitions never mutate after compilation;
+ * `modify` produces a replacement rather than editing an existing one. Parent and
+ * trait references are resolved lazily at evaluation time, so a child may be
+ * declared before its parent.
+ */
+export default class FactoryDefinition {
+    /**
+     * Builds a factory definition.
+     * @param {object} args - Options.
+     * @param {string} args.name - Factory name.
+     * @param {(new (attributes?: Record<string, ?>) => ?) | null} args.modelClass - Model class, or null to inherit from a parent.
+     * @param {string | null} args.parentName - Parent factory name, or null.
+     * @param {string[]} args.aliases - Alias names that reference this same definition.
+     * @param {import("./declarations.js").Declaration[]} args.declarations - Ordered own declarations.
+     * @param {Map<string, import("./trait-definition.js").default>} args.localTraits - Factory-local traits keyed by name.
+     */
+    constructor({ name, modelClass, parentName, aliases, declarations, localTraits }) {
+        /** @type {string} - Factory name. */
+        this.name = name;
+        /** @type {(new (attributes?: Record<string, ?>) => ?) | null} - Model class or null. */
+        this.modelClass = modelClass;
+        /** @type {string | null} - Parent factory name or null. */
+        this.parentName = parentName;
+        /** @type {Array<string>} - Alias names. */
+        this.aliases = /** @type {Array<string>} */ (Object.freeze([...aliases]));
+        /** @type {Array<import("./declarations.js").Declaration>} - Ordered own declarations. */
+        this.declarations = /** @type {Array<import("./declarations.js").Declaration>} */ (Object.freeze([...declarations]));
+        /** @type {Map<string, import("./trait-definition.js").default>} - Factory-local traits. */
+        this.localTraits = localTraits;
+        Object.freeze(this);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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