@wpkernel/pipeline 0.12.3-beta.0 → 0.12.5-beta.0

package/dist/internal/runner/program.js

@@ -0,0 +1,294 @@
+import { composeK as G, maybeThen as $ } from "../../async-utils.js";
+import { buildExecutionSnapshot as s, assertAllHelpersExecuted as S } from "../helper-execution.js";
+import { initExtensionCoordinator as j } from "../extension-coordinator.js";
+import { makeAfterFragmentsStage as q, makeFinalizeResultStage as I, makeCommitStage as J, makeFinalizeFragmentsStage as Q, makeHelperStageFactory as W, isHalt as c, runRollbackToHalt as X } from "../pipeline-program-utils.js";
+const Y = "after-fragments";
+function Z(o) {
+  const {
+    fragmentStage: l,
+    finalizeFragments: g,
+    builderStage: u,
+    commitStage: f,
+    finalizeResult: h,
+    makeLifecycleStage: x,
+    extensions: b
+  } = o, p = (b?.lifecycles ?? []).map(
+    x
+  );
+  return [
+    l,
+    g,
+    ...p,
+    u,
+    f,
+    h
+  ];
+}
+const ar = (o, l) => {
+  const g = (r) => ({
+    __halt: !0,
+    error: r
+  }), u = (r, t, n) => {
+    o.diagnosticManager.reviewUnusedHelpers(
+      r.fragmentEntries,
+      t,
+      o.fragmentKind
+    );
+    const e = s(
+      r.fragmentEntries,
+      t,
+      o.fragmentKind
+    );
+    return S(
+      r.fragmentEntries,
+      e,
+      o.fragmentKind,
+      o.diagnosticManager.describeHelper,
+      o.createError
+    ), {
+      ...r,
+      fragmentVisited: t,
+      fragmentExecution: e,
+      fragmentRollbacks: n
+    };
+  }, f = (r, t, n) => {
+    o.diagnosticManager.reviewUnusedHelpers(
+      r.builderEntries,
+      t,
+      o.builderKind
+    );
+    const e = s(
+      r.builderEntries,
+      t,
+      o.builderKind
+    );
+    return S(
+      r.builderEntries,
+      e,
+      o.builderKind,
+      o.diagnosticManager.describeHelper,
+      o.createError
+    ), {
+      ...r,
+      builderVisited: t,
+      builderExecution: e,
+      builderRollbacks: n
+    };
+  }, h = (r, t) => o.options.createFragmentArgs({
+    helper: t.helper,
+    options: r.runOptions,
+    context: r.context,
+    buildOptions: r.buildOptions,
+    draft: r.draft
+  }), x = (r, t) => o.options.createBuilderArgs({
+    helper: t.helper,
+    options: r.runOptions,
+    context: r.context,
+    buildOptions: r.buildOptions,
+    artifact: r.artifact
+  }), b = (r) => (t) => h(r, t), p = (r) => (t) => x(r, t), H = (r) => r.fragmentRollbacks, F = (r) => r.builderRollbacks ?? [], k = (r) => ({
+    context: r.context,
+    extensionCoordinator: r.extensionCoordinator,
+    extensionState: r.extensionState
+  }), y = (r) => r.fragmentExecution ?? s(
+    r.fragmentEntries,
+    r.fragmentVisited,
+    o.fragmentKind
+  ), z = (r) => {
+    const { extensionCoordinator: t, extensionState: n } = r;
+    if (!(!t || !n))
+      return t.commit(n);
+  }, M = (r) => ({
+    context: r.context,
+    rollbackContext: k(r),
+    helperRollbacks: r.builderRollbacks ?? [],
+    onHelperRollbackError: o.options.onHelperRollbackError
+  }), w = (r, t) => X(
+    {
+      rollbackPlan: M(r),
+      halt: g
+    },
+    t
+  ), P = (r) => (t) => {
+    const n = j(
+      ({ error: a, extensionKeys: i, hookSequence: m, errorMetadata: E }) => l.handleRollbackError({
+        error: a,
+        extensionKeys: i,
+        hookSequence: m,
+        errorMetadata: E,
+        context: t.context
+      })
+    ), e = n.runLifecycle(
+      r,
+      {
+        hooks: o.extensionHooks,
+        hookOptions: l.buildHookOptions(
+          t.artifact,
+          r
+        )
+      }
+    );
+    return $(
+      e,
+      (a) => ({
+        ...t,
+        artifact: a.artifact,
+        extensionCoordinator: n,
+        extensionState: a
+      })
+    );
+  }, d = (r) => r.helpers ?? {
+    fragments: r.fragmentExecution ?? s(
+      r.fragmentEntries,
+      r.fragmentVisited,
+      o.fragmentKind
+    ),
+    builders: r.builderExecution ?? s(
+      r.builderEntries,
+      r.builderVisited,
+      o.builderKind
+    )
+  }, B = (r) => ({
+    ...r,
+    helpers: d(r),
+    diagnostics: [
+      ...o.diagnosticManager.readDiagnostics()
+    ]
+  }), C = Q({
+    isHalt: c,
+    snapshotFragments: y,
+    applyArtifact: (r, t) => ({
+      ...r,
+      artifact: o.options.finalizeFragmentState({
+        draft: r.draft,
+        options: r.runOptions,
+        context: r.context,
+        buildOptions: r.buildOptions,
+        helpers: {
+          fragments: t
+        }
+      }),
+      fragmentExecution: t
+    })
+  }), L = (r) => q({
+    isHalt: c,
+    execute: P(r)
+  }), T = J({
+    isHalt: c,
+    commit: z,
+    rollbackToHalt: w
+  }), V = I({
+    isHalt: c,
+    finalize: B
+  }), v = {
+    getOrder: (r) => r.fragmentOrder,
+    makeArgs: b,
+    onVisited: (r, t, n) => u(r, t, n),
+    readRollbacks: H
+  }, U = {
+    getOrder: (r) => r.builderOrder,
+    makeArgs: p,
+    onVisited: (r, t, n) => f(r, t, n),
+    readRollbacks: F
+  }, R = W({
+    pushStep: l.pushStep,
+    toRollbackContext: k,
+    halt: g,
+    isHalt: c,
+    onHelperRollbackError: o.options.onHelperRollbackError
+  }), _ = R(v), N = R(U), O = {
+    runnerEnv: {
+      pushStep: l.pushStep,
+      toRollbackContext: k,
+      halt: g,
+      isHalt: c,
+      onHelperRollbackError: o.options.onHelperRollbackError
+    },
+    fragmentStage: _,
+    builderStage: N,
+    finalizeFragments: C,
+    commitStage: T,
+    finalizeResult: V,
+    makeLifecycleStage: L,
+    extensions: {
+      lifecycles: o.extensionHooks.length > 0 ? o.extensionLifecycles ?? [Y] : []
+    },
+    makeHelperStage: (r, t) => R(
+      {
+        getOrder: (e) => e.helperOrders?.get(r) ?? [],
+        makeArgs: (e) => {
+          if (t?.makeArgs)
+            return t.makeArgs(e);
+          if (r === o.fragmentKind)
+            return b(e);
+          if (r === o.builderKind)
+            return p(e);
+          throw new Error(`No args factory for kind "${r}"`);
+        },
+        onVisited: (e, a, i) => {
+          if (t?.onVisited)
+            return t.onVisited(
+              e,
+              a,
+              i
+            );
+          if (r === o.fragmentKind)
+            return u(
+              e,
+              a,
+              i
+            );
+          if (r === o.builderKind)
+            return f(
+              e,
+              a,
+              i
+            );
+          const m = e.helperOrders?.get(r) ?? [];
+          o.diagnosticManager.reviewUnusedHelpers(
+            m,
+            a,
+            r
+          );
+          const E = s(
+            m,
+            a,
+            r
+          );
+          S(
+            m,
+            E,
+            r,
+            o.diagnosticManager.describeHelper,
+            o.createError
+          );
+          const A = new Map(
+            e.helperExecution ?? []
+          );
+          A.set(r, E);
+          const K = new Map(
+            e.helperRollbacks ?? []
+          );
+          return K.set(
+            r,
+            i
+          ), {
+            ...e,
+            helperExecution: A,
+            helperRollbacks: K
+          };
+        },
+        readRollbacks: (e) => r === o.fragmentKind ? H(
+          e
+        ) : r === o.builderKind ? F(
+          e
+        ) : e.helperRollbacks?.get(r)
+      }
+    )
+  }, D = o.stages ? o.stages(O) : Z(O);
+  return G(...[...D].reverse());
+};
+export {
+  ar as createCoreProgram,
+  Z as defaultStages
+};

package/dist/makePipeline.d.ts

@@ -0,0 +1,20 @@
+import { CreatePipelineOptions, Helper, HelperKind, Pipeline, PipelineDiagnostic, PipelineReporter, PipelineRunState } from './types';
+import { DefaultStageDeps, PipelineStage, PipelineState, Halt } from './internal/pipeline-runner.types';
+export { DefaultStageDeps, PipelineStage, } from "./internal/pipeline-runner.types";
+export { defaultStages } from './internal/runner/program';
+export type MakePipelineArgs<TRunOptions, TReporter extends PipelineReporter = PipelineReporter, TContext extends {
+    reporter: TReporter;
+} = {
+    reporter: TReporter;
+}, TArtifact = unknown, TDiagnostic extends PipelineDiagnostic = PipelineDiagnostic, TRunResult = PipelineRunState<TArtifact, TDiagnostic>, TBuildOptions = unknown, TDraft = unknown, TFragmentInput = unknown, TFragmentOutput = unknown, TBuilderInput = unknown, TBuilderOutput = unknown, TFragmentKind extends HelperKind = 'fragment', TBuilderKind extends HelperKind = 'builder', TFragmentHelper extends Helper<TContext, TFragmentInput, TFragmentOutput, TReporter, TFragmentKind> = Helper<TContext, TFragmentInput, TFragmentOutput, TReporter, TFragmentKind>, TBuilderHelper extends Helper<TContext, TBuilderInput, TBuilderOutput, TReporter, TBuilderKind> = Helper<TContext, TBuilderInput, TBuilderOutput, TReporter, TBuilderKind>> = CreatePipelineOptions<TRunOptions, TBuildOptions, TContext, TReporter, TDraft, TArtifact, TDiagnostic, TRunResult, TFragmentInput, TFragmentOutput, TBuilderInput, TBuilderOutput, TFragmentKind, TBuilderKind, TFragmentHelper, TBuilderHelper> & {
+    extensions?: {
+        lifecycles?: string[];
+    };
+    stages?: (deps: DefaultStageDeps<PipelineState<TRunOptions, TBuildOptions, TContext, TReporter, TDraft, TArtifact, TDiagnostic, TFragmentInput, TFragmentOutput, TBuilderInput, TBuilderOutput, TFragmentKind, TBuilderKind, TFragmentHelper, TBuilderHelper>, TRunResult, TContext, TRunOptions, TArtifact, TReporter>) => PipelineStage<PipelineState<TRunOptions, TBuildOptions, TContext, TReporter, TDraft, TArtifact, TDiagnostic, TFragmentInput, TFragmentOutput, TBuilderInput, TBuilderOutput, TFragmentKind, TBuilderKind, TFragmentHelper, TBuilderHelper>, Halt<TRunResult>>[];
+};
+export declare function makePipeline<TRunOptions, TReporter extends PipelineReporter = PipelineReporter, TContext extends {
+    reporter: TReporter;
+} = {
+    reporter: TReporter;
+}, TArtifact = unknown, TDiagnostic extends PipelineDiagnostic = PipelineDiagnostic, TRunResult = PipelineRunState<TArtifact, TDiagnostic>, TBuildOptions = unknown, TDraft = unknown, TFragmentInput = unknown, TFragmentOutput = unknown, TBuilderInput = unknown, TBuilderOutput = unknown, TFragmentKind extends HelperKind = 'fragment', TBuilderKind extends HelperKind = 'builder', TFragmentHelper extends Helper<TContext, TFragmentInput, TFragmentOutput, TReporter, TFragmentKind> = Helper<TContext, TFragmentInput, TFragmentOutput, TReporter, TFragmentKind>, TBuilderHelper extends Helper<TContext, TBuilderInput, TBuilderOutput, TReporter, TBuilderKind> = Helper<TContext, TBuilderInput, TBuilderOutput, TReporter, TBuilderKind>>(options: MakePipelineArgs<TRunOptions, TReporter, TContext, TArtifact, TDiagnostic, TRunResult, TBuildOptions, TDraft, TFragmentInput, TFragmentOutput, TBuilderInput, TBuilderOutput, TFragmentKind, TBuilderKind, TFragmentHelper, TBuilderHelper>): Pipeline<TRunOptions, TRunResult, TContext, TReporter, TBuildOptions, TArtifact, TFragmentInput, TFragmentOutput, TBuilderInput, TBuilderOutput, TDiagnostic, TFragmentKind, TBuilderKind, TFragmentHelper, TBuilderHelper>;
+//# sourceMappingURL=makePipeline.d.ts.map

package/dist/makePipeline.d.ts.map

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

package/dist/makePipeline.js

@@ -0,0 +1,139 @@
+import { maybeThen as K, isPromiseLike as C } from "./async-utils.js";
+import { registerHelper as g, handleExtensionRegisterResult as F } from "./registration.js";
+import { initDiagnosticManager as L } from "./internal/diagnostic-manager.js";
+import { initPipelineRunner as V } from "./internal/runner/index.js";
+function j(r) {
+  const i = r.fragmentKind ?? "fragment", s = r.builderKind ?? "builder", a = r.createError ?? ((e, n) => new Error(`[${e}] ${n}`)), u = /* @__PURE__ */ new Map(), d = (e) => (u.has(e) || u.set(e, []), u.get(e)), f = d(
+    i
+  ), m = d(
+    s
+  ), R = [], c = [], l = L({
+    options: r,
+    fragmentKind: i,
+    builderKind: s
+  }), P = r.createRunResult ?? ((e) => ({
+    artifact: e.artifact,
+    diagnostics: e.diagnostics,
+    steps: e.steps
+  })), H = {
+    options: r,
+    fragmentEntries: f,
+    builderEntries: m,
+    helperRegistries: u,
+    fragmentKind: i,
+    builderKind: s,
+    diagnosticManager: l,
+    createError: a,
+    resolveRunResult: P,
+    extensionHooks: R,
+    extensionLifecycles: r.extensions?.lifecycles,
+    stages: r.stages
+  }, x = V(H), p = i, E = s, h = (e) => g(
+    e,
+    i,
+    f,
+    p,
+    (n, t, o) => l.flagConflict(
+      n,
+      t,
+      p,
+      o
+    ),
+    a
+  ), v = (e) => g(
+    e,
+    s,
+    m,
+    E,
+    (n, t, o) => l.flagConflict(
+      n,
+      t,
+      E,
+      o
+    ),
+    a
+  ), b = (e, n) => F(e, n, R), w = (e) => {
+    if (e && C(e)) {
+      Promise.resolve(e).catch(() => {
+      });
+      const n = Promise.resolve(e).then(() => {
+      });
+      n.catch(() => {
+      }), c.push(n), n.finally(() => {
+        const t = c.indexOf(n);
+        t !== -1 && c.splice(t, 1);
+      }).catch(() => {
+      });
+    }
+    return e;
+  }, M = () => {
+    if (c.length !== 0)
+      return Promise.all([...c]).then(
+        () => {
+        }
+      );
+  }, k = {
+    fragmentKind: i,
+    builderKind: s,
+    ir: {
+      use(e) {
+        h(e);
+      }
+    },
+    builders: {
+      use(e) {
+        v(e);
+      }
+    },
+    extensions: {
+      use(e) {
+        const n = e.register(k);
+        n && C(n) && Promise.resolve(n).catch(() => {
+        });
+        const t = K(
+          n,
+          (o) => b(e.key, o)
+        );
+        return w(t);
+      }
+    },
+    use(e) {
+      if (e.kind === i) {
+        h(e);
+        return;
+      }
+      if (e.kind === s) {
+        v(e);
+        return;
+      }
+      const n = e.kind, t = d(n);
+      g(
+        e,
+        n,
+        t,
+        n,
+        (o, y, D) => l.flagConflict(
+          o,
+          y,
+          n,
+          D
+        ),
+        a
+      );
+    },
+    run(e) {
+      const n = () => {
+        const t = x.prepareContext(e);
+        return x.executeRun(t);
+      };
+      return K(
+        M(),
+        () => n()
+      );
+    }
+  };
+  return k;
+}
+export {
+  j as makePipeline
+};

package/dist/registration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registration.d.ts","sourceRoot":"","sources":["../src/registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,MAAM,EACN,UAAU,EACV,qBAAqB,EAErB,0BAA0B,EAC1B,gBAAgB,EAChB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC7B,QAAQ,EACR,MAAM,EACN,OAAO,EACP,SAAS,SAAS,gBAAgB,EAClC,KAAK,SAAS,UAAU,EACxB,OAAO,SAAS,MAAM,CACrB,QAAQ,EACR,MAAM,EACN,OAAO,EACP,SAAS,EACT,KAAK,CACL,GAAG,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,EAEvD,MAAM,EAAE,OAAO,EACf,YAAY,EAAE,UAAU,EACxB,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAAE,EACpC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,EACzE,WAAW,EAAE,YAAY,GACvB,IAAI,CA6BN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAClE,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,IAAI,EAAE,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAC1D,cAAc,EAAE,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,EACnE,SAAS,GAAE,0BAA8C,GACvD,MAAM,CASR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAC1E,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,MAAM,EAAE,OAAO,EACf,cAAc,EAAE,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,GACjE,OAAO,CAqCT"}
+{"version":3,"file":"registration.d.ts","sourceRoot":"","sources":["../src/registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,MAAM,EACN,UAAU,EACV,qBAAqB,EAErB,0BAA0B,EAC1B,gBAAgB,EAChB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC7B,QAAQ,EACR,MAAM,EACN,OAAO,EACP,SAAS,SAAS,gBAAgB,EAClC,KAAK,SAAS,UAAU,EACxB,OAAO,SAAS,MAAM,CACrB,QAAQ,EACR,MAAM,EACN,OAAO,EACP,SAAS,EACT,KAAK,CACL,GAAG,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,EAEvD,MAAM,EAAE,OAAO,EACf,YAAY,EAAE,UAAU,EACxB,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAAE,EACpC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,EACzE,WAAW,EAAE,YAAY,GACvB,IAAI,CAqCN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAClE,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,IAAI,EAAE,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAC1D,cAAc,EAAE,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,EACnE,SAAS,GAAE,0BAA8C,GACvD,MAAM,CASR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAC1E,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,MAAM,EAAE,OAAO,EACf,cAAc,EAAE,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,GACjE,OAAO,CAqCT"}

package/dist/registration.js

@@ -1,35 +1,37 @@
-import { createHelperId as a } from "./dependency-graph.js";
-function p(e, i, o, t, r, d) {
+import { createHelperId as k } from "./dependency-graph.js";
+function a(e, i, o, n, r, d) {
   if (e.kind !== i)
     throw d(
       "ValidationError",
-      `Attempted to register helper "${e.key}" as ${t} but received kind "${e.kind}".`
+      `Attempted to register helper "${e.key}" as ${n} but received kind "${e.kind}".`
     );
   if (e.mode === "override") {
     const c = o.find(
-      (n) => n.helper.key === e.key && n.helper.mode === "override"
+      (t) => t.helper.key === e.key && t.helper.mode === "override"
     );
     if (c) {
-      const n = `Multiple overrides registered for helper "${e.key}".`;
-      throw r(e, c.helper, n), d("ValidationError", n);
+      const t = `Multiple overrides registered for helper "${e.key}".`;
+      throw r(e, c.helper, t), d("ValidationError", t);
     }
+    for (let t = o.length - 1; t >= 0; t--)
+      o[t].helper.key === e.key && o.splice(t, 1);
   }
   const f = o.length;
   o.push({
     helper: e,
-    id: a(e, f),
+    id: k(e, f),
     index: f
   });
 }
-function g(e, i, o, t = "after-fragments") {
+function g(e, i, o, n = "after-fragments") {
   const r = e ?? `pipeline.extension#${o.length + 1}`;
   return o.push({
     key: r,
-    lifecycle: t,
+    lifecycle: n,
     hook: i
   }), r;
 }
-function s(e, i, o) {
+function y(e, i, o) {
   if (typeof i == "function") {
     g(
       e,
@@ -39,19 +41,19 @@ function s(e, i, o) {
     return;
   }
   if (i && typeof i == "object" && "hook" in i && typeof i.hook == "function") {
-    const t = i;
+    const n = i;
     g(
       e,
-      t.hook,
+      n.hook,
       o,
-      t.lifecycle
+      n.lifecycle
     );
     return;
   }
   return i;
 }
 export {
-  s as handleExtensionRegisterResult,
+  y as handleExtensionRegisterResult,
   g as registerExtensionHook,
-  p as registerHelper
+  a as registerHelper
 };

package/dist/rollback.d.ts

@@ -0,0 +1,94 @@
+import { MaybePromise } from './types.js';
+/**
+ * Metadata about an error during rollback execution.
+ * @public
+ */
+export interface PipelineRollbackErrorMetadata {
+    readonly name?: string;
+    readonly message?: string;
+    readonly stack?: string;
+    readonly cause?: unknown;
+}
+/**
+ * A rollback operation that can be executed to undo changes.
+ *
+ * Rollbacks are collected during helper/extension execution and invoked in reverse order
+ * if the pipeline encounters a failure, enabling cleanup and state restoration.
+ *
+ * @public
+ */
+export interface PipelineRollback {
+    readonly key?: string;
+    readonly label?: string;
+    readonly run: () => unknown | Promise<unknown>;
+}
+/**
+ * Options for executing a rollback stack.
+ * @public
+ */
+export interface RunRollbackStackOptions {
+    readonly source: 'extension' | 'helper';
+    readonly onError?: (args: {
+        readonly error: unknown;
+        readonly entry: PipelineRollback;
+        readonly metadata: PipelineRollbackErrorMetadata;
+    }) => void;
+}
+/**
+ * Creates a pipeline rollback object with metadata.
+ *
+ * This is a lightweight wrapper that helps distinguish rollback operations in diagnostics
+ * and error handling. It's used by both helpers and extensions to declare cleanup functions.
+ *
+ * @param run           - The rollback function to execute
+ * @param options       - Optional metadata (key, label) for diagnostics
+ * @param options.key
+ * @param options.label
+ * @returns A rollback descriptor with the run function and metadata
+ *
+ * @example
+ * ```typescript
+ * const rollback = createPipelineRollback(
+ *   () => {
+ *     cleanup();
+ *   },
+ *   {
+ *     key: 'my-helper',
+ *     label: 'Restore previous state',
+ *   }
+ * );
+ * ```
+ *
+ * @public
+ */
+export declare function createPipelineRollback(run: () => unknown | Promise<unknown>, options?: {
+    readonly key?: string;
+    readonly label?: string;
+}): PipelineRollback;
+/**
+ * Converts an error into a serializable metadata object.
+ *
+ * Extracts `name`, `message`, `stack`, and `cause` from Error instances.
+ * Falls back to a plain message string for non-Error values.
+ *
+ * @param error - The error to convert
+ * @returns Serializable error metadata
+ *
+ * @internal
+ */
+export declare function createRollbackErrorMetadata(error: unknown): PipelineRollbackErrorMetadata;
+/**
+ * Executes a stack of rollback operations in reverse order.
+ *
+ * Each rollback is executed sequentially in reverse (LIFO) order. If any rollback fails,
+ * the error is reported via the onError callback but execution continues with remaining
+ * rollbacks. This ensures all cleanup functions are attempted even if some fail.
+ *
+ * @param entries - The rollback entries to execute in reverse order
+ * @param options - Configuration including error handler and rollback source
+ * @returns A promise if any rollback is async, otherwise `void`
+ *
+ * @internal
+ */
+export declare function runRollbackStack(entries: readonly PipelineRollback[], options: RunRollbackStackOptions): MaybePromise<void>;
+//# sourceMappingURL=rollback.d.ts.map

package/dist/rollback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollback.d.ts","sourceRoot":"","sources":["../src/rollback.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;GAGG;AACH,MAAM,WAAW,6BAA6B;IAC7C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC/C;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACvC,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC;IACxC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE;QACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;QACxB,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;QACjC,QAAQ,CAAC,QAAQ,EAAE,6BAA6B,CAAC;KACjD,KAAK,IAAI,CAAC;CACX;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,sBAAsB,CACrC,GAAG,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EACrC,OAAO,GAAE;IACR,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACnB,GACJ,gBAAgB,CAElB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,OAAO,GACZ,6BAA6B,CAoB/B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC/B,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,OAAO,EAAE,uBAAuB,GAC9B,YAAY,CAAC,IAAI,CAAC,CAyCpB"}

package/dist/rollback.js

@@ -0,0 +1,46 @@
+import { isPromiseLike as u, maybeTry as f } from "./async-utils.js";
+function v(e, t = {}) {
+  return { run: e, ...t };
+}
+function m(e) {
+  if (e instanceof Error) {
+    const { name: t, message: r, stack: n } = e, o = e.cause;
+    return {
+      name: t,
+      message: r,
+      stack: n,
+      cause: o
+    };
+  }
+  return typeof e == "string" ? {
+    message: e
+  } : {};
+}
+function b(e, t) {
+  const r = [...e].reverse(), n = (s) => {
+    if (s >= r.length)
+      return;
+    const a = r[s], i = f(
+      () => a.run(),
+      (c) => {
+        const l = m(c);
+        t.onError?.({
+          error: c,
+          entry: a,
+          metadata: l
+        });
+      }
+    );
+    return u(i) ? Promise.resolve(i).then(
+      () => n(s + 1)
+    ) : n(s + 1);
+  }, o = n(0);
+  if (u(o))
+    return Promise.resolve(o).then(() => {
+    });
+}
+export {
+  v as createPipelineRollback,
+  m as createRollbackErrorMetadata,
+  b as runRollbackStack
+};