@composurecdk/core 0.7.0 → 0.8.0

package/dist/commonjs/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/builder.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,KAAK,WAAW,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC;AAElC;;;GAGG;AACH,UAAU,eAAe,CAAC,KAAK,SAAS,MAAM;IAC5C,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,UAAU,eAA+C,CAAC;AAEvE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,MAAM,EAAE,CAAC,IAAI;KAC7C,CAAC,IAAI,MAAM,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;CACjF,GAAG;KACD,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACjG,GAAG;IACF;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,IAAI,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;CAC5B,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CAAC,KAAK,SAAS,MAAM,EAAE,CAAC,SAAS,eAAe,CAAC,KAAK,CAAC,EAC5E,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,EAC3B,QAAQ,GAAE,CAAqB,GAC9B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,CA+CpB"}

package/dist/commonjs/builder.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COPY_STATE = void 0;
+exports.Builder = Builder;
+/**
+ * Optional hook a builder class can implement to clone non-`props` state
+ * during {@link IBuilder.copy}.
+ *
+ * The default `.copy()` shallow-clones `props` and wraps a fresh instance.
+ * State stored outside `props` (private fields, internal accumulators) is
+ * invisible to that default. A class with such state defines a method
+ * keyed by this symbol to copy it onto the new instance.
+ *
+ * See ADR-0005 for the full protocol, including how decorator layers
+ * participate.
+ *
+ * @example
+ * ```ts
+ * class StackBuilder {
+ *   props: Partial<StackProps> = {};
+ *   readonly #tags: [string, string][] = [];
+ *
+ *   [COPY_STATE](target: StackBuilder): void {
+ *     target.#tags.push(...this.#tags);
+ *   }
+ * }
+ * ```
+ */
+exports.COPY_STATE = Symbol.for("composurecdk.builder.copyState");
+/**
+ * Creates a fluent builder wrapping an instance of `T`.
+ *
+ * The builder is backed by a {@link Proxy} that intercepts property access:
+ * - For `copy`: returns a function that produces an independent builder with
+ *   the same configured state (see {@link IBuilder.copy}).
+ * - For keys in `Props`: returns a getter/setter function. When called with a
+ *   value, it sets the prop and returns the builder. When called with no args,
+ *   it returns the current value.
+ * - For methods on `T` that return `T`: wraps them to return the builder instead.
+ * - For all other members: delegates directly to the underlying instance.
+ *
+ * @param constructor - The class to instantiate and wrap.
+ * @param instance - Optional pre-existing instance to wrap. Defaults to
+ *   `new constructor()`. Used internally by {@link IBuilder.copy} to wrap a
+ *   freshly cloned instance without re-running the constructor for new state.
+ * @returns A fluent {@link IBuilder} wrapping `instance`.
+ */
+function Builder(constructor, instance = new constructor()) {
+    const methods = new Set(Object.getOwnPropertyNames(Object.getPrototypeOf(instance)).filter((key) => key !== "constructor" && typeof instance[key] === "function"));
+    const proxy = new Proxy(instance, {
+        get(target, prop) {
+            if (typeof prop === "symbol") {
+                return Reflect.get(target, prop);
+            }
+            if (prop === "copy") {
+                return () => {
+                    const next = new constructor();
+                    next.props = { ...target.props };
+                    const hook = target[exports.COPY_STATE];
+                    if (typeof hook === "function") {
+                        hook.call(target, next);
+                    }
+                    return Builder(constructor, next);
+                };
+            }
+            // Props getter/setter
+            if (!methods.has(prop)) {
+                return (...args) => {
+                    if (args.length === 0) {
+                        return target.props[prop];
+                    }
+                    target.props[prop] = args[0];
+                    return proxy;
+                };
+            }
+            // Method on target — wrap to return proxy for chainable methods
+            const method = target[prop];
+            return (...args) => {
+                const result = method.apply(target, args);
+                return result === target ? proxy : result;
+            };
+        },
+    });
+    return proxy;
+}
+//# sourceMappingURL=builder.js.map

package/dist/commonjs/builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.js","sourceRoot":"","sources":["../../src/builder.ts"],"names":[],"mappings":";;;AAwGA,0BAkDC;AA7ID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACU,QAAA,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,gCAAgC,CAAC,CAAC;AAiDvE;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,OAAO,CACrB,WAA2B,EAC3B,WAAc,IAAI,WAAW,EAAE;IAE/B,MAAM,OAAO,GAAG,IAAI,GAAG,CACrB,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAChE,CAAC,GAAG,EAAE,EAAE,CACN,GAAG,KAAK,aAAa,IAAI,OAAQ,QAAoC,CAAC,GAAG,CAAC,KAAK,UAAU,CAC5F,CACF,CAAC;IAEF,MAAM,KAAK,GAAuB,IAAI,KAAK,CAAC,QAAQ,EAAE;QACpD,GAAG,CAAC,MAAS,EAAE,IAAqB;YAClC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC7B,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAY,CAAC;YAC9C,CAAC;YAED,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;gBACpB,OAAO,GAAG,EAAE;oBACV,MAAM,IAAI,GAAG,IAAI,WAAW,EAAE,CAAC;oBAC/B,IAAI,CAAC,KAAK,GAAG,EAAE,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC;oBACjC,MAAM,IAAI,GAAI,MAA6C,CAAC,kBAAU,CAAC,CAAC;oBACxE,IAAI,OAAO,IAAI,KAAK,UAAU,EAAE,CAAC;wBAC9B,IAA0B,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;oBACjD,CAAC;oBACD,OAAO,OAAO,CAAW,WAAW,EAAE,IAAI,CAAC,CAAC;gBAC9C,CAAC,CAAC;YACJ,CAAC;YAED,sBAAsB;YACtB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACvB,OAAO,CAAC,GAAG,IAAe,EAAE,EAAE;oBAC5B,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBACtB,OAAO,MAAM,CAAC,KAAK,CAAC,IAAmB,CAAC,CAAC;oBAC3C,CAAC;oBACD,MAAM,CAAC,KAAK,CAAC,IAAmB,CAAC,GAAG,IAAI,CAAC,CAAC,CAAuB,CAAC;oBAClE,OAAO,KAAK,CAAC;gBACf,CAAC,CAAC;YACJ,CAAC;YAED,gEAAgE;YAChE,MAAM,MAAM,GAAI,MAAkC,CAAC,IAAI,CAAiC,CAAC;YACzF,OAAO,CAAC,GAAG,IAAe,EAAE,EAAE;gBAC5B,MAAM,MAAM,GAAY,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;gBACnD,OAAO,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;YAC5C,CAAC,CAAC;QACJ,CAAC;KACF,CAAuB,CAAC;IAEzB,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/commonjs/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../src/compose.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;;GAMG;AACH,KAAK,WAAW,CAAC,CAAC,SAAS;KAAG,QAAQ,IAAI,MAAM,CAAC,GAAG,SAAS;CAAE,IAAI;KAChE,QAAQ,IAAI,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC;CACxD,CAAC;AAEF;;;;;;GAMG;AACH,KAAK,UAAU,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,IAAI,CAAC,MAAM,UAAU,CAAC,EAAE,CAAC;AA+BrF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,MAAM,IAAI,CAC7C,KAAK,EAAE,UAAU,EACjB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,CAAC,EACV,eAAe,EAAE;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,UAAU;CAAE,KACrD,IAAI,CAAC;AAEV;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAE,SAAQ,SAAS,CAC7F,WAAW,CAAC,UAAU,CAAC,CACxB;IACC;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,CAAC,MAAM,EAAE;SAAG,CAAC,IAAI,MAAM,UAAU,CAAC,CAAC,EAAE,UAAU;KAAE,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAAC;IAE3F;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iBAAiB,CAAC,QAAQ,EAAE,aAAa,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAAC;IAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,UAAU,CAAC,IAAI,EAAE,cAAc,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAAC;CACzF;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAE,SAAQ,SAAS,CAC/F,WAAW,CAAC,UAAU,CAAC,CACxB;IACC;;;;;;OAMG;IACH,UAAU,CAAC,IAAI,EAAE,cAAc,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAAC;CACzF;AA0HD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EAClE,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE;KAAG,QAAQ,IAAI,MAAM,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;CAAE,GACvE,cAAc,CAAC,UAAU,CAAC,CAE5B"}

package/dist/commonjs/compose.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = compose;
+const graphlib_1 = require("@dagrejs/graphlib");
+const cyclic_dependency_error_js_1 = require("./cyclic-dependency-error.js");
+/**
+ * Builds a directed acyclic graph from component dependency declarations.
+ * The graph is described declaratively as nodes and edges, then constructed
+ * via {@link json.read}. Nodes are component keys, edges point from a
+ * dependency to its dependent. Throws if the graph contains a cycle.
+ */
+function buildDependencyGraph(components, dependencies) {
+    const nodes = Object.keys(components).map((v) => ({ v }));
+    const edges = Object.entries(dependencies).flatMap(([key, deps]) => deps.map((dep) => ({ v: dep, w: key })));
+    const graph = graphlib_1.json.read({
+        options: { directed: true },
+        nodes,
+        edges,
+    });
+    if (!graphlib_1.alg.isAcyclic(graph)) {
+        throw new cyclic_dependency_error_js_1.CyclicDependencyError(graphlib_1.alg.findCycles(graph));
+    }
+    return graph;
+}
+/**
+ * A composed system of {@link Lifecycle} components. Holds the dependency graph
+ * built at composition time and traverses it in topological order during build.
+ */
+class ComposedLifecycle {
+    #graph;
+    #components;
+    #dependencies;
+    constructor(components, dependencies) {
+        this.#components = components;
+        this.#dependencies = dependencies;
+        this.#graph = buildDependencyGraph(components, dependencies);
+    }
+    withStacks(stacks) {
+        return new ConfiguredLifecycle((scope, id, parentContext) => this.#buildWith(scope, id, stacks, parentContext));
+    }
+    withStackStrategy(strategy) {
+        return new ConfiguredLifecycle((scope, id, parentContext) => {
+            const stacks = Object.fromEntries(Object.keys(this.#components).map((key) => [key, strategy.resolve(scope, id, key)]));
+            return this.#buildWith(scope, id, stacks, parentContext);
+        });
+    }
+    afterBuild(hook) {
+        return new ConfiguredLifecycle((scope, id, parentContext) => this.#buildWith(scope, id, undefined, parentContext)).afterBuild(hook);
+    }
+    build(scope, id, parentContext) {
+        return this.#buildWith(scope, id, undefined, parentContext).results;
+    }
+    #buildWith(scope, id, stacks, parentContext) {
+        const results = {};
+        const componentScopes = {};
+        for (const key of graphlib_1.alg.topsort(this.#graph)) {
+            const componentScope = stacks?.[key] ?? scope;
+            componentScopes[key] = componentScope;
+            const deps = (this.#dependencies[key] ?? []);
+            // Inner deps shadow parent context on key collision.
+            const innerContext = Object.fromEntries(deps.map((dep) => [dep, results[dep]]));
+            const context = { ...parentContext, ...innerContext };
+            results[key] = this.#components[key].build(componentScope, `${id}/${key}`, context);
+        }
+        return {
+            results: results,
+            componentScopes: componentScopes,
+        };
+    }
+}
+/**
+ * A configured lifecycle that accumulates post-build hooks and applies them
+ * after the underlying build function completes. Returned by
+ * {@link ComposedLifecycle}'s `withStacks`, `withStackStrategy`, and
+ * `afterBuild` methods.
+ */
+class ConfiguredLifecycle {
+    #hooks = [];
+    #buildFn;
+    constructor(buildFn) {
+        this.#buildFn = buildFn;
+    }
+    afterBuild(hook) {
+        this.#hooks.push(hook);
+        return this;
+    }
+    build(scope, id, parentContext) {
+        const { results, componentScopes } = this.#buildFn(scope, id, parentContext);
+        for (const hook of this.#hooks) {
+            hook(scope, id, results, componentScopes);
+        }
+        return results;
+    }
+}
+/**
+ * Composes a set of {@link Lifecycle} components into a single system that
+ * manages their build order and dependency resolution.
+ *
+ * A directed acyclic graph is built eagerly from the declared dependencies.
+ * Cyclic dependencies are detected at composition time and throw immediately.
+ * When `build` is called, components are built in topological order, each
+ * receiving the build outputs of its dependencies as its context.
+ *
+ * The returned {@link ComposedSystem} is a {@link Lifecycle}, so it can be
+ * nested as a component in a larger `compose` call.
+ *
+ * @param components - A record of named {@link Lifecycle} components.
+ * @param dependencies - For each component, the list of other component keys it depends on.
+ * @returns A {@link ComposedSystem} whose build output is the combined {@link BuildResult} of all components.
+ */
+function compose(components, dependencies) {
+    return new ComposedLifecycle(components, dependencies);
+}
+//# sourceMappingURL=compose.js.map

package/dist/commonjs/compose.js.map

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

package/dist/commonjs/construct-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construct-id.d.ts","sourceRoot":"","sources":["../../src/construct-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,GAAG,KAAK,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,KAAK,CAAC,EAAE,GAAG,MAAM,CAK5F"}

package/dist/commonjs/construct-id.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Utilities for producing safe CDK construct IDs from arbitrary strings.
+ *
+ * The `constructs` library uses `/` as the path separator between construct
+ * IDs. When user-supplied strings (DNS names, ARNs, filesystem paths) are
+ * passed through to a construct ID, any embedded `/` silently gets rewritten
+ * to `--`, which produces unreadable CloudFormation logical IDs. Control
+ * characters are likewise unsafe.
+ *
+ * These helpers consolidate that sanitization in one place so every builder
+ * in the monorepo applies the same constraints.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeConstructId = sanitizeConstructId;
+exports.constructId = constructId;
+// eslint-disable-next-line no-control-regex -- the regex must literally match control characters to strip them from construct IDs
+const UNSAFE = /[/\x00-\x1f\x7f]/g;
+/**
+ * Return a construct-ID-safe copy of `raw` by replacing unsafe characters
+ * (`/` and control characters) with a single `-`.
+ *
+ * Does not touch other characters — CDK construct IDs are otherwise
+ * permissive, and collapsing further (e.g., to PascalCase) would destroy
+ * information a reader expects to see in the synthesised tree.
+ *
+ * @example
+ * ```ts
+ * sanitizeConstructId("a/b")       // "a-b"
+ * sanitizeConstructId("_sip._tcp") // "_sip._tcp" (unchanged)
+ * ```
+ */
+function sanitizeConstructId(raw) {
+    return raw.replace(UNSAFE, "-");
+}
+/**
+ * Join the supplied parts into a single construct ID. Falsy parts are
+ * dropped; each remaining part is passed through {@link sanitizeConstructId}
+ * and the results are joined with `-`.
+ *
+ * Intended for composing IDs from a mix of static prefixes and user-supplied
+ * fragments — the sanitization step means callers don't have to reason about
+ * what characters their inputs might contain.
+ *
+ * @example
+ * ```ts
+ * constructId("records", "a", "api")   // "records-a-api"
+ * constructId("zone", undefined, "www") // "zone-www"
+ * constructId("records", "a/b")         // "records-a-b"
+ * ```
+ */
+function constructId(...parts) {
+    return parts
+        .filter((p) => typeof p === "string" && p.length > 0)
+        .map(sanitizeConstructId)
+        .join("-");
+}
+//# sourceMappingURL=construct-id.js.map

package/dist/commonjs/construct-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"construct-id.js","sourceRoot":"","sources":["../../src/construct-id.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;AAmBH,kDAEC;AAkBD,kCAKC;AA1CD,kIAAkI;AAClI,MAAM,MAAM,GAAG,mBAAmB,CAAC;AAEnC;;;;;;;;;;;;;GAaG;AACH,SAAgB,mBAAmB,CAAC,GAAW;IAC7C,OAAO,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAClC,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,WAAW,CAAC,GAAG,KAAqD;IAClF,OAAO,KAAK;SACT,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;SACjE,GAAG,CAAC,mBAAmB,CAAC;SACxB,IAAI,CAAC,GAAG,CAAC,CAAC;AACf,CAAC"}

package/dist/commonjs/cyclic-dependency-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cyclic-dependency-error.d.ts","sourceRoot":"","sources":["../../src/cyclic-dependency-error.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;aAIlB,MAAM,EAAE,MAAM,EAAE,EAAE;IAH9C;;OAEG;gBACyB,MAAM,EAAE,MAAM,EAAE,EAAE;CAI/C"}

package/dist/commonjs/cyclic-dependency-error.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyclicDependencyError = void 0;
+/**
+ * Thrown when {@link compose} detects a cycle in the component dependency graph.
+ * Carries the detected cycles so callers can inspect or report them programmatically.
+ */
+class CyclicDependencyError extends Error {
+    cycles;
+    /**
+     * @param cycles - Each element is an array of component keys forming a cycle.
+     */
+    constructor(cycles) {
+        super(`Cyclic dependencies detected: ${cycles.map((c) => c.join(" -> ")).join("; ")}`);
+        this.cycles = cycles;
+        this.name = "CyclicDependencyError";
+    }
+}
+exports.CyclicDependencyError = CyclicDependencyError;
+//# sourceMappingURL=cyclic-dependency-error.js.map

package/dist/commonjs/cyclic-dependency-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cyclic-dependency-error.js","sourceRoot":"","sources":["../../src/cyclic-dependency-error.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH,MAAa,qBAAsB,SAAQ,KAAK;IAIlB;IAH5B;;OAEG;IACH,YAA4B,MAAkB;QAC5C,KAAK,CAAC,iCAAiC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAD7D,WAAM,GAAN,MAAM,CAAY;QAE5C,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;IACtC,CAAC;CACF;AARD,sDAQC"}

package/dist/commonjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,EACL,OAAO,EACP,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,cAAc,GACpB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AACrE,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,WAAW,EACX,aAAa,GACd,MAAM,qBAAqB,CAAC"}

package/dist/commonjs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupedStacks = exports.singleStack = exports.isRef = exports.resolve = exports.ref = exports.Ref = exports.CyclicDependencyError = exports.compose = exports.sanitizeConstructId = exports.constructId = exports.COPY_STATE = exports.Builder = void 0;
+var builder_js_1 = require("./builder.js");
+Object.defineProperty(exports, "Builder", { enumerable: true, get: function () { return builder_js_1.Builder; } });
+Object.defineProperty(exports, "COPY_STATE", { enumerable: true, get: function () { return builder_js_1.COPY_STATE; } });
+var construct_id_js_1 = require("./construct-id.js");
+Object.defineProperty(exports, "constructId", { enumerable: true, get: function () { return construct_id_js_1.constructId; } });
+Object.defineProperty(exports, "sanitizeConstructId", { enumerable: true, get: function () { return construct_id_js_1.sanitizeConstructId; } });
+var compose_js_1 = require("./compose.js");
+Object.defineProperty(exports, "compose", { enumerable: true, get: function () { return compose_js_1.compose; } });
+var cyclic_dependency_error_js_1 = require("./cyclic-dependency-error.js");
+Object.defineProperty(exports, "CyclicDependencyError", { enumerable: true, get: function () { return cyclic_dependency_error_js_1.CyclicDependencyError; } });
+var ref_js_1 = require("./ref.js");
+Object.defineProperty(exports, "Ref", { enumerable: true, get: function () { return ref_js_1.Ref; } });
+Object.defineProperty(exports, "ref", { enumerable: true, get: function () { return ref_js_1.ref; } });
+Object.defineProperty(exports, "resolve", { enumerable: true, get: function () { return ref_js_1.resolve; } });
+Object.defineProperty(exports, "isRef", { enumerable: true, get: function () { return ref_js_1.isRef; } });
+var stack_strategy_js_1 = require("./stack-strategy.js");
+Object.defineProperty(exports, "singleStack", { enumerable: true, get: function () { return stack_strategy_js_1.singleStack; } });
+Object.defineProperty(exports, "groupedStacks", { enumerable: true, get: function () { return stack_strategy_js_1.groupedStacks; } });
+//# sourceMappingURL=index.js.map

package/dist/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAAA,2CAAkE;AAAzD,qGAAA,OAAO,OAAA;AAAE,wGAAA,UAAU,OAAA;AAC5B,qDAAqE;AAA5D,8GAAA,WAAW,OAAA;AAAE,sHAAA,mBAAmB,OAAA;AACzC,2CAKsB;AAJpB,qGAAA,OAAO,OAAA;AAKT,2EAAqE;AAA5D,mIAAA,qBAAqB,OAAA;AAE9B,mCAAqE;AAA5D,6FAAA,GAAG,OAAA;AAAE,6FAAA,GAAG,OAAA;AAAE,iGAAA,OAAO,OAAA;AAAE,+FAAA,KAAK,OAAA;AACjC,yDAK6B;AAF3B,gHAAA,WAAW,OAAA;AACX,kHAAA,aAAa,OAAA"}

package/dist/commonjs/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../src/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;GAGG;AACH,KAAK,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAErD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,SAAS,CACxB,CAAC,SAAS,MAAM,GAAG,MAAM,EACzB,OAAO,SAAS,sBAAsB,GAAG,sBAAsB;IAE/D,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC;CAC5D"}

package/dist/commonjs/lifecycle.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=lifecycle.js.map

package/dist/{lifecycle.js.map → commonjs/lifecycle.js.map}

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.js","sourceRoot":"","sources":["../src/lifecycle.ts"],"names":[],"mappings":""}
+{"version":3,"file":"lifecycle.js","sourceRoot":"","sources":["../../src/lifecycle.ts"],"names":[],"mappings":""}

package/dist/commonjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/{ref.d.ts → commonjs/ref.d.ts}

@@ -1,3 +1,12 @@
+/**
+ * @internal Brands every {@link Ref} instance so {@link isRef} can recognise
+ * one without `instanceof`. `instanceof` is realm-bound: when `@composurecdk/core`
+ * is loaded as both ESM and CommonJS in the same process (the dual-package
+ * hazard), each copy has its own `Ref` class and `instanceof` fails across the
+ * boundary. A `Symbol.for(...)` brand is registered in the global symbol
+ * registry, so a `Ref` minted by either copy is still recognised by either.
+ */
+export declare const REF_BRAND: unique symbol;
 /**
  * A lazy reference to a value produced by another component at build time.
  *
@@ -27,6 +36,8 @@
  */
 export declare class Ref<T> {
     #private;
+    /** @internal Realm-agnostic brand — see {@link REF_BRAND}. */
+    readonly [REF_BRAND] = true;
     private constructor();
     /**
      * Creates a `Ref` that resolves to a component's full build output.
@@ -100,6 +111,11 @@ export declare function ref<T extends object, U>(component: string, transform: (
 export type Resolvable<T> = T | Ref<T>;
 /**
  * Type guard that checks whether a value is a {@link Ref}.
+ *
+ * Recognises a `Ref` by its {@link REF_BRAND} symbol rather than `instanceof`,
+ * so it works across the dual-package boundary — a `Ref` produced by the ESM
+ * copy of `@composurecdk/core` is still recognised by the CommonJS copy and
+ * vice versa.
  */
 export declare function isRef<T>(value: Resolvable<T>): value is Ref<T>;
 /**

package/dist/commonjs/ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref.d.ts","sourceRoot":"","sources":["../../src/ref.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,eAAiC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,GAAG,CAAC,CAAC;;IAChB,8DAA8D;IAC9D,QAAQ,CAAC,CAAC,SAAS,CAAC,QAAQ;IAI5B,OAAO;IAIP;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC;IAYtD;;;;;OAKG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAIzC;;;;;;;;;OASG;IACH,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;IAInC;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC;CAG5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;AAEjE,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;AAShG;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;AAEvC;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,CAE9D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,CAEpF"}

package/dist/commonjs/ref.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ref = exports.REF_BRAND = void 0;
+exports.ref = ref;
+exports.isRef = isRef;
+exports.resolve = resolve;
+/**
+ * @internal Brands every {@link Ref} instance so {@link isRef} can recognise
+ * one without `instanceof`. `instanceof` is realm-bound: when `@composurecdk/core`
+ * is loaded as both ESM and CommonJS in the same process (the dual-package
+ * hazard), each copy has its own `Ref` class and `instanceof` fails across the
+ * boundary. A `Symbol.for(...)` brand is registered in the global symbol
+ * registry, so a `Ref` minted by either copy is still recognised by either.
+ */
+exports.REF_BRAND = Symbol.for("composurecdk.ref");
+/**
+ * A lazy reference to a value produced by another component at build time.
+ *
+ * `Ref` enables declarative cross-component wiring: a builder can capture a
+ * reference to a dependency's output at configuration time, and the value is
+ * resolved when the system is built. This keeps all configuration in one
+ * place — no split between eager props and deferred hooks.
+ *
+ * Create a `Ref` with the {@link ref} factory, then optionally narrow it
+ * with {@link Ref.get | .get()} or transform it with {@link Ref.map | .map()}.
+ *
+ * @typeParam T - The type of the value this reference resolves to.
+ *
+ * @example
+ * ```ts
+ * // Reference a component's full build output
+ * ref<FunctionBuilderResult>("handler")
+ *
+ * // Narrow to a specific property
+ * ref<FunctionBuilderResult>("handler").get("function")
+ *
+ * // Transform the referenced value
+ * ref<FunctionBuilderResult>("handler")
+ *   .get("function")
+ *   .map(fn => new LambdaIntegration(fn))
+ * ```
+ */
+class Ref {
+    /** @internal Realm-agnostic brand — see {@link REF_BRAND}. */
+    [exports.REF_BRAND] = true;
+    #resolver;
+    constructor(resolver) {
+        this.#resolver = resolver;
+    }
+    /**
+     * Creates a `Ref` that resolves to a component's full build output.
+     *
+     * @param component - The key of the component in the composed system.
+     * @returns A `Ref` to the component's build result.
+     */
+    static to(component) {
+        return new Ref((context) => {
+            if (!(component in context)) {
+                throw new Error(`Ref to "${component}" cannot be resolved: component not found in context. ` +
+                    `Ensure "${component}" is declared as a dependency.`);
+            }
+            return context[component];
+        });
+    }
+    /**
+     * Narrows this reference to a specific property of the resolved value.
+     *
+     * @param key - The property key to select.
+     * @returns A new `Ref` to the selected property.
+     */
+    get(key) {
+        return new Ref((context) => this.#resolver(context)[key]);
+    }
+    /**
+     * Transforms the resolved value using the provided function.
+     *
+     * This is the primary way to adapt a dependency's output into the shape
+     * a consumer needs — for example, wrapping a Lambda function in a
+     * `LambdaIntegration`.
+     *
+     * @param fn - A function that transforms the resolved value.
+     * @returns A new `Ref` whose resolved value is the result of `fn`.
+     */
+    map(fn) {
+        return new Ref((context) => fn(this.#resolver(context)));
+    }
+    /**
+     * Resolves this reference against a build context.
+     *
+     * Called internally during the build phase. Not typically called by users.
+     *
+     * @param context - The resolved dependency outputs, keyed by component name.
+     * @returns The resolved value.
+     */
+    resolve(context) {
+        return this.#resolver(context);
+    }
+}
+exports.Ref = Ref;
+function ref(component, transform) {
+    const base = Ref.to(component);
+    return transform ? base.map(transform) : base;
+}
+/**
+ * Type guard that checks whether a value is a {@link Ref}.
+ *
+ * Recognises a `Ref` by its {@link REF_BRAND} symbol rather than `instanceof`,
+ * so it works across the dual-package boundary — a `Ref` produced by the ESM
+ * copy of `@composurecdk/core` is still recognised by the CommonJS copy and
+ * vice versa.
+ */
+function isRef(value) {
+    return typeof value === "object" && value !== null && exports.REF_BRAND in value;
+}
+/**
+ * Resolves a {@link Resolvable} value. If it is a {@link Ref}, resolves it
+ * against the provided context (or an empty context if none is given).
+ * Otherwise returns the value as-is.
+ *
+ * @param value - A concrete value or a `Ref`.
+ * @param context - The resolved dependency outputs, keyed by component name.
+ *   Omit for standalone builds where no refs are in use — a `Ref` resolved
+ *   against an empty context will throw "component not found".
+ * @returns The concrete value.
+ */
+function resolve(value, context) {
+    return isRef(value) ? value.resolve(context ?? {}) : value;
+}
+//# sourceMappingURL=ref.js.map

package/dist/commonjs/ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref.js","sourceRoot":"","sources":["../../src/ref.ts"],"names":[],"mappings":";;;AAmIA,kBAMC;AAkBD,sBAEC;AAaD,0BAEC;AA5KD;;;;;;;GAOG;AACU,QAAA,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAa,GAAG;IACd,8DAA8D;IACrD,CAAC,iBAAS,CAAC,GAAG,IAAI,CAAC;IAEnB,SAAS,CAAyC;IAE3D,YAAoB,QAAgD;QAClE,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;IAC5B,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CAAmB,SAAiB;QAC3C,OAAO,IAAI,GAAG,CAAI,CAAC,OAAO,EAAE,EAAE;YAC5B,IAAI,CAAC,CAAC,SAAS,IAAI,OAAO,CAAC,EAAE,CAAC;gBAC5B,MAAM,IAAI,KAAK,CACb,WAAW,SAAS,wDAAwD;oBAC1E,WAAW,SAAS,gCAAgC,CACvD,CAAC;YACJ,CAAC;YACD,OAAO,OAAO,CAAC,SAAS,CAAM,CAAC;QACjC,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,GAAG,CAAoB,GAAM;QAC3B,OAAO,IAAI,GAAG,CAAO,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;;;;OASG;IACH,GAAG,CAAI,EAAmB;QACxB,OAAO,IAAI,GAAG,CAAI,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;;;OAOG;IACH,OAAO,CAAC,OAA+B;QACrC,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;CACF;AA/DD,kBA+DC;AA+BD,SAAgB,GAAG,CACjB,SAAiB,EACjB,SAA2B;IAE3B,MAAM,IAAI,GAAG,GAAG,CAAC,EAAE,CAAI,SAAS,CAAC,CAAC;IAClC,OAAO,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAChD,CAAC;AAUD;;;;;;;GAOG;AACH,SAAgB,KAAK,CAAI,KAAoB;IAC3C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,iBAAS,IAAI,KAAK,CAAC;AAC3E,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,OAAO,CAAI,KAAoB,EAAE,OAAgC;IAC/E,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;AAC7D,CAAC"}

package/dist/commonjs/stack-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack-strategy.d.ts","sourceRoot":"","sources":["../../src/stack-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,KAAK,UAAU,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;;OAOG;IACH,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,UAAU,CAAC;CAChF;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,aAAa,CAUhE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,EAC1C,OAAO,EAAE,YAAY,GACpB,aAAa,CAaf"}

package/dist/commonjs/stack-strategy.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.singleStack = singleStack;
+exports.groupedStacks = groupedStacks;
+/**
+ * Creates a strategy that places all components in a single auto-created scope.
+ *
+ * The scope is created lazily on the first call to `resolve` and reused for
+ * all subsequent components.
+ *
+ * @param factory - Factory for creating the scope (e.g. a Stack).
+ * @returns A {@link StackStrategy} that groups all components into one scope.
+ */
+function singleStack(factory) {
+    return {
+        resolve: (() => {
+            let stack;
+            return (scope, systemId) => {
+                stack ??= factory(scope, systemId);
+                return stack;
+            };
+        })(),
+    };
+}
+/**
+ * Creates a strategy that groups components into named scopes determined by
+ * a classifier function.
+ *
+ * Components that return the same group key share a scope. Scopes are created
+ * lazily as new group keys are encountered.
+ *
+ * @param classify - A function that maps a component key to a group name.
+ * @param factory - Factory for creating scopes (e.g. Stacks). The factory
+ *   receives `${systemId}-${group}` as the id.
+ * @returns A {@link StackStrategy} that groups components by classifier output.
+ *
+ * @example
+ * ```ts
+ * groupedStacks(
+ *   key => key === "table" ? "persistence" : "service",
+ *   (app, id) => new Stack(app, id),
+ * )
+ * ```
+ */
+function groupedStacks(classify, factory) {
+    const groups = new Map();
+    return {
+        resolve(scope, systemId, componentKey) {
+            const group = classify(componentKey);
+            let groupScope = groups.get(group);
+            if (!groupScope) {
+                groupScope = factory(scope, `${systemId}-${group}`);
+                groups.set(group, groupScope);
+            }
+            return groupScope;
+        },
+    };
+}
+//# sourceMappingURL=stack-strategy.js.map

package/dist/commonjs/stack-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack-strategy.js","sourceRoot":"","sources":["../../src/stack-strategy.ts"],"names":[],"mappings":";;AAuDA,kCAUC;AAsBD,sCAgBC;AAzDD;;;;;;;;GAQG;AACH,SAAgB,WAAW,CAAC,OAAqB;IAC/C,OAAO;QACL,OAAO,EAAE,CAAC,GAAG,EAAE;YACb,IAAI,KAA6B,CAAC;YAClC,OAAO,CAAC,KAAiB,EAAE,QAAgB,EAAE,EAAE;gBAC7C,KAAK,KAAK,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;gBACnC,OAAO,KAAK,CAAC;YACf,CAAC,CAAC;QACJ,CAAC,CAAC,EAAE;KACL,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,aAAa,CAC3B,QAA0C,EAC1C,OAAqB;IAErB,MAAM,MAAM,GAAG,IAAI,GAAG,EAAsB,CAAC;IAC7C,OAAO;QACL,OAAO,CAAC,KAAiB,EAAE,QAAgB,EAAE,YAAoB;YAC/D,MAAM,KAAK,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;YACrC,IAAI,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACnC,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,UAAU,GAAG,OAAO,CAAC,KAAK,EAAE,GAAG,QAAQ,IAAI,KAAK,EAAE,CAAC,CAAC;gBACpD,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;YAChC,CAAC;YACD,OAAO,UAAU,CAAC;QACpB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/commonjs/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../src/testing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,SAAS;IAAE,IAAI,IAAI,CAAC,CAAA;CAAE,EAAE,CAAC,EAAE,IAAI,EAAE;IACzE,OAAO,EAAE,MAAM,CAAC,CAAC;IACjB,SAAS,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAC;IAChC,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAC;IAC7B,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;IACzB,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC;CACjC,GAAG,IAAI,CAsCP"}