@step-forge/step-forge 0.0.10 → 0.0.11

package/CLAUDE.md

@@ -9,7 +9,7 @@ npm test                # Run all tests (Cucumber.js, suppresses stderr)
 npm run test:debug      # Run all tests with full output (use when debugging failures)
 npm run test:cucumber   # Run with default Cucumber profile
 npm run test:ci         # Run with CI profile
-npm run build           # Full build: clean → tsc → rolldown → dts-bundle-generator → copy
+npm run build           # Full build: clean → tsc typecheck → tsdown (bundle + dts) → copy package.json
 npm run lint            # ESLint
 npm run format          # Prettier
 ```
@@ -108,7 +108,7 @@ Step definitions in `features/steps/analyzerSteps.ts` provide these steps:
 
 ### Build Output
 
-Vite produces ESM (`dist/step-forge.js`) and `dts-bundle-generator` creates a single `dist/index.d.ts`. The `build/` directory contains the publishable package.
+`tsdown` (configured in `tsdown.config.ts`, powered by rolldown) produces both the JS bundles and the bundled type declarations in one pass: ESM + CJS for the main entry (`dist/step-forge.js` / `.cjs` with `dist/step-forge.d.ts` / `.d.cts`), and ESM for the analyzer library and CLI (`dist/analyzer.js`, `dist/analyzer-cli.js`). Dependencies and `node:` builtins are externalized automatically. The `build/` directory contains the publishable package.
 
 ## Exports
 

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@step-forge/step-forge",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "module": "./dist/step-forge.js",
   "type": "module",
   "exports": {
     ".": {
       "require": {
-        "types": "./dist/index.d.cts",
+        "types": "./dist/step-forge.d.cts",
         "default": "./dist/step-forge.cjs"
       },
       "import": {
-        "types": "./dist/index.d.ts",
+        "types": "./dist/step-forge.d.ts",
         "default": "./dist/step-forge.js"
       }
     },
@@ -25,9 +25,9 @@
   "bin": {
     "step-forge-analyze": "./dist/analyzer-cli.js"
   },
-  "types": "./dist/index.d.ts",
+  "types": "./dist/step-forge.d.ts",
   "scripts": {
-    "build": "rm -rf build && tsc && rolldown -c && dts-bundle-generator --config ./dts-bundle-generator.config.cjs && cp build/dist/index.d.ts build/dist/index.d.cts && cp package.json build/",
+    "build": "rm -rf build && tsc --noEmit && tsdown && cp package.json build/",
     "test:cucumber": "NODE_ENV=test NODE_OPTIONS='--import tsx' cucumber-js -p default",
     "test:ci": "NODE_ENV=test NODE_OPTIONS='--import tsx' cucumber-js -p ci",
     "test": "NODE_ENV=test PORT=7888 LOG_LEVEL=none NODE_OPTIONS='--import tsx' cucumber-js -p all 2> /dev/null",
@@ -42,14 +42,13 @@
     "@types/node": "^22.10.2",
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
-    "dts-bundle-generator": "^9.5.1",
     "earl": "^1.3.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.2.1",
     "prettier": "^3.3.3",
+    "tsdown": "^0.22.0",
     "tsx": "^4.19.0",
-    "rolldown": "^1.0.0-rc.3",
     "typescript": "^5.7.2"
   },
   "peerDependencies": {

package/tsdown.config.ts

@@ -0,0 +1,35 @@
+import { defineConfig } from "tsdown";
+
+// `dependencies` and `peerDependencies` (the @cucumber/* packages, lodash, and
+// typescript) plus `node:` builtins are externalized automatically by tsdown,
+// so no explicit external list is needed.
+const shared = {
+  outDir: "./build/dist",
+  platform: "node" as const,
+  sourcemap: true,
+  dts: true,
+  // Follow the package's "type": "module" for extensions: ESM -> .js/.d.ts,
+  // CJS -> .cjs/.d.cts. Without this, tsdown emits .mjs for the ESM build.
+  fixedExtension: false,
+  // `rm -rf build` in the npm script does the cleaning; disabling clean here
+  // prevents the second config below from wiping the first config's output.
+  clean: false,
+};
+
+export default defineConfig([
+  // Main entry: ESM + CJS, with bundled type declarations (.d.ts / .d.cts).
+  {
+    ...shared,
+    entry: { "step-forge": "./src/index.ts" },
+    format: ["esm", "cjs"],
+  },
+  // Analyzer library + CLI: ESM only. Shared code is split into a chunk.
+  {
+    ...shared,
+    entry: {
+      analyzer: "./src/analyzer/index.ts",
+      "analyzer-cli": "./src/analyzer/cli.ts",
+    },
+    format: ["esm"],
+  },
+]);

package/dist/step-forge.cjs

@@ -1 +0,0 @@
-"use strict";var C=Object.defineProperty;var I=(e,n,t)=>n in e?C(e,n,{enumerable:!0,configurable:!0,writable:!0,value:t}):e[n]=t;var u=(e,n,t)=>I(e,typeof n!="symbol"?n+"":n,t);Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const g=require("@cucumber/cucumber"),x=require("lodash"),H=e=>e&&e.__esModule?e:{default:e},o=H(x),f=e=>typeof e=="string",J=(e,n)=>(e.forEach(t=>{if(!n.given[t])throw new Error(`Key ${String(t)} is required in given state`)}),e.reduce((t,r)=>({...t,[r]:n.given[r]}),{})),L=(e,n)=>(e.forEach(t=>{if(!n.when[t])throw new Error(`Key ${String(t)} is required in when state`)}),e.reduce((t,r)=>({...t,[r]:n.when[r]}),{})),N=(e,n)=>(e.forEach(t=>{if(!n.then[t])throw new Error(`Key ${String(t)} is required in then state`)}),e.reduce((t,r)=>({...t,[r]:n.then[r]}),{})),q={parse:e=>e,gherkin:"{string}"},Q={parse:e=>parseInt(e,10),gherkin:"{int}"},R={parse:e=>parseFloat(e),gherkin:"{double}"},U={parse:e=>e==="true",gherkin:"{string}"},X={given:g.Given,when:g.When,then:g.Then},c=(e,n,t={given:{},when:{},then:{}},r)=>i=>{const h=e,{given:v,when:w,then:m}=t;return{statement:e,dependencies:t,stepType:n,stepFunction:i,register:()=>{const a=h.length,S=r??Array.from({length:a},()=>q),D=Array.from({length:a},(p,d)=>S[d].gherkin),O=h(...D),B=Object.defineProperty(async function(...p){const d=p.filter(s=>typeof s!="function").map((s,y)=>S[y].parse(s)),E=Object.entries(v??{}).filter(([,s])=>s==="required").map(([s])=>s),W=J(E,this),K={...o.default.pick(this.given,Object.keys(v??{})),...W},G=Object.entries(w??{}).filter(([,s])=>s==="required").map(([s])=>s),M=L(G,this),$={...o.default.pick(this.when,Object.keys(w??{})),...M},z=Object.entries(m??{}).filter(([,s])=>s==="required").map(([s])=>s),A=N(z,this),j={...o.default.pick(this.then,Object.keys(m??{})),...A},k=await i({variables:d,given:K,when:$,then:j});this[n].merge({...k})},"length",{value:a,configurable:!0}),_=X[n];return _(O,B),{stepType:n,dependencies:t,statement:h,stepFunction:i}}}},P=(e,n,t)=>r=>{const i={...r,when:{},then:{}};return{step:c(e,n,i,t)}},Y=(e,n)=>t=>({dependencies:P(e,n,t),step:c(e,n,void 0,t)}),Z=e=>n=>{let t;return f(n)?t=()=>n:t=n,{dependencies:P(t,e),parsers:Y(t,e),step:c(t,e)}},V=()=>({statement:Z("given")}),F=(e,n,t)=>r=>{const i={given:r.given??{},when:r.when??{},then:{}};return{step:c(e,n,i,t)}},T=(e,n)=>t=>({dependencies:F(e,n,t),step:c(e,n,void 0,t)}),ee=e=>n=>{let t;f(n)?t=()=>n:t=n;const r=F(t,e),i=T(t,e),h=c(t,e);return{dependencies:r,parsers:i,step:h}},ne=()=>({statement:ee("when")}),b=(e,n,t)=>r=>{const i={given:r.given??{},when:r.when??{},then:r.then??{}};return{step:c(e,n,i,t)}},te=(e,n)=>t=>({dependencies:b(e,n,t),step:c(e,n,void 0,t)}),re=e=>n=>{let t;f(n)?t=()=>n:t=n;const r=b(t,e),i=c(t,e),h=te(t,e);return{dependencies:r,parsers:h,step:i}},se=()=>({statement:re("then")});function l(e,n){if(o.default.isArray(e))return e.concat(n);if(e&&!o.default.isPlainObject(e)&&e!==n)throw new Error(`Merge would have destroyed previous value ${e} with ${n}`);return e}class ie{constructor(){u(this,"givenState",{});u(this,"whenState",{});u(this,"thenState",{})}get given(){return{...this.givenState,merge:n=>{this.givenState=o.default.merge({...this.givenState},n,l)}}}get when(){return{...this.whenState,merge:n=>{this.whenState=o.default.merge({...this.whenState},n,l)}}}get then(){return{...this.thenState,merge:n=>{this.thenState=o.default.merge({...this.thenState},n,l)}}}}exports.BasicWorld=ie;exports.booleanParser=U;exports.givenBuilder=V;exports.intParser=Q;exports.numberParser=R;exports.stringParser=q;exports.thenBuilder=se;exports.whenBuilder=ne;

package/dist/step-forge.js

@@ -1,235 +0,0 @@
-var C = Object.defineProperty;
-var _ = (e, n, t) => n in e ? C(e, n, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[n] = t;
-var u = (e, n, t) => _(e, typeof n != "symbol" ? n + "" : n, t);
-import { Then as x, When as I, Given as y } from "@cucumber/cucumber";
-import h from "lodash";
-const v = (e) => typeof e == "string", H = (e, n) => (e.forEach((t) => {
-  if (!n.given[t])
-    throw new Error(`Key ${String(t)} is required in given state`);
-}), e.reduce(
-  (t, r) => ({
-    ...t,
-    [r]: n.given[r]
-  }),
-  {}
-)), J = (e, n) => (e.forEach((t) => {
-  if (!n.when[t])
-    throw new Error(`Key ${String(t)} is required in when state`);
-}), e.reduce(
-  (t, r) => ({
-    ...t,
-    [r]: n.when[r]
-  }),
-  {}
-)), L = (e, n) => (e.forEach((t) => {
-  if (!n.then[t])
-    throw new Error(`Key ${String(t)} is required in then state`);
-}), e.reduce(
-  (t, r) => ({
-    ...t,
-    [r]: n.then[r]
-  }),
-  {}
-)), N = {
-  parse: (e) => e,
-  gherkin: "{string}"
-}, te = {
-  parse: (e) => parseInt(e, 10),
-  gherkin: "{int}"
-}, re = {
-  parse: (e) => parseFloat(e),
-  gherkin: "{double}"
-}, ie = {
-  parse: (e) => e === "true",
-  gherkin: "{string}"
-}, Q = {
-  given: y,
-  when: I,
-  then: x
-}, c = (e, n, t = {
-  given: {},
-  when: {},
-  then: {}
-}, r) => (s) => {
-  const o = e, {
-    given: w,
-    when: l,
-    then: f
-  } = t;
-  return {
-    statement: e,
-    dependencies: t,
-    stepType: n,
-    stepFunction: s,
-    register: () => {
-      const a = o.length, m = r ?? Array.from({ length: a }, () => N), D = Array.from({ length: a }, (p, g) => m[g].gherkin), P = o(...D), O = Object.defineProperty(
-        async function(...p) {
-          const g = p.filter((i) => typeof i != "function").map((i, k) => m[k].parse(i)), E = Object.entries(w ?? {}).filter(([, i]) => i === "required").map(([i]) => i), K = H(
-            E,
-            this
-          ), W = {
-            ...h.pick(this.given, Object.keys(w ?? {})),
-            ...K
-          }, G = Object.entries(l ?? {}).filter(([, i]) => i === "required").map(([i]) => i), $ = J(
-            G,
-            this
-          ), z = {
-            ...h.pick(this.when, Object.keys(l ?? {})),
-            ...$
-          }, A = Object.entries(f ?? {}).filter(([, i]) => i === "required").map(([i]) => i), B = L(
-            A,
-            this
-          ), M = {
-            ...h.pick(this.then, Object.keys(f ?? {})),
-            ...B
-          }, j = await s({
-            variables: g,
-            given: W,
-            when: z,
-            then: M
-          });
-          this[n].merge({
-            ...j
-          });
-        },
-        "length",
-        { value: a, configurable: !0 }
-      ), b = Q[n];
-      return b(P, O), {
-        stepType: n,
-        dependencies: t,
-        statement: o,
-        stepFunction: s
-      };
-    }
-  };
-}, S = (e, n, t) => (r) => {
-  const s = {
-    ...r,
-    when: {},
-    then: {}
-  };
-  return {
-    step: c(e, n, s, t)
-  };
-}, R = (e, n) => (t) => ({
-  dependencies: S(e, n, t),
-  step: c(e, n, void 0, t)
-}), U = (e) => (n) => {
-  let t;
-  return v(n) ? t = () => n : t = n, {
-    dependencies: S(t, e),
-    parsers: R(t, e),
-    step: c(t, e)
-  };
-}, se = () => ({
-  statement: U("given")
-}), F = (e, n, t) => (r) => {
-  const s = {
-    given: r.given ?? {},
-    when: r.when ?? {},
-    then: {}
-  };
-  return {
-    step: c(e, n, s, t)
-  };
-}, X = (e, n) => (t) => ({
-  dependencies: F(e, n, t),
-  step: c(e, n, void 0, t)
-}), Y = (e) => (n) => {
-  let t;
-  v(n) ? t = () => n : t = n;
-  const r = F(t, e), s = X(t, e), o = c(t, e);
-  return {
-    dependencies: r,
-    parsers: s,
-    step: o
-  };
-}, ce = () => ({
-  statement: Y("when")
-}), q = (e, n, t) => (r) => {
-  const s = {
-    given: r.given ?? {},
-    when: r.when ?? {},
-    then: r.then ?? {}
-  };
-  return {
-    step: c(e, n, s, t)
-  };
-}, Z = (e, n) => (t) => ({
-  dependencies: q(e, n, t),
-  step: c(e, n, void 0, t)
-}), V = (e) => (n) => {
-  let t;
-  v(n) ? t = () => n : t = n;
-  const r = q(t, e), s = c(t, e), o = Z(t, e);
-  return {
-    dependencies: r,
-    parsers: o,
-    step: s
-  };
-}, he = () => ({
-  statement: V("then")
-});
-function d(e, n) {
-  if (h.isArray(e))
-    return e.concat(n);
-  if (e && !h.isPlainObject(e) && e !== n)
-    throw new Error(
-      `Merge would have destroyed previous value ${e} with ${n}`
-    );
-  return e;
-}
-class oe {
-  constructor() {
-    u(this, "givenState", {});
-    u(this, "whenState", {});
-    u(this, "thenState", {});
-  }
-  get given() {
-    return {
-      ...this.givenState,
-      merge: (n) => {
-        this.givenState = h.merge(
-          { ...this.givenState },
-          n,
-          d
-        );
-      }
-    };
-  }
-  get when() {
-    return {
-      ...this.whenState,
-      merge: (n) => {
-        this.whenState = h.merge(
-          { ...this.whenState },
-          n,
-          d
-        );
-      }
-    };
-  }
-  get then() {
-    return {
-      ...this.thenState,
-      merge: (n) => {
-        this.thenState = h.merge(
-          { ...this.thenState },
-          n,
-          d
-        );
-      }
-    };
-  }
-}
-export {
-  oe as BasicWorld,
-  ie as booleanParser,
-  se as givenBuilder,
-  te as intParser,
-  re as numberParser,
-  N as stringParser,
-  he as thenBuilder,
-  ce as whenBuilder
-};

package/dist/types/src/builderTypeUtils.d.ts

@@ -1,14 +0,0 @@
-export type StepType = "given" | "when" | "then";
-export type InferAndReplace<T, U> = never extends T ? U : T;
-export type HasKeys<T> = T extends Record<any, any> ? (keyof T extends never ? never : T) : T;
-export type EmptyObject = Record<string, never>;
-export type RequiredOrOptional<T> = {
-    [K in keyof T]?: "required" | "optional";
-};
-export type GetFunctionArgs<T> = T extends (...args: infer A) => any ? A : never;
-export declare const isString: (statement: string | ((...args: [...any]) => string)) => statement is string;
-export type EmptyDependencies = {
-    given: EmptyObject;
-    when: EmptyObject;
-    then: EmptyObject;
-};

package/dist/types/src/common.d.ts

@@ -1,32 +0,0 @@
-import { StepType } from "./builderTypeUtils";
-export declare const addStep: <ResolvedStepType extends StepType, Statement extends (...args: any[]) => string, Dependencies extends {
-    given: any;
-    when: any;
-    then: any;
-}, Variables, GivenState, WhenState, ThenState, RestrictedGivenState, RestrictedWhenState, RestrictedThenState>(statement: Statement, stepType: ResolvedStepType, dependencies?: Dependencies) => (stepFunction: (input: {
-    variables: Variables;
-    given: RestrictedGivenState;
-    when: RestrictedWhenState;
-    then: RestrictedThenState;
-}) => ResolvedStepType extends "given" ? Partial<GivenState> : ResolvedStepType extends "when" ? Partial<WhenState> : Partial<ThenState> | void) => {
-    statement: Statement;
-    dependencies: Dependencies;
-    stepType: ResolvedStepType;
-    stepFunction: (input: {
-        variables: Variables;
-        given: RestrictedGivenState;
-        when: RestrictedWhenState;
-        then: RestrictedThenState;
-    }) => ResolvedStepType extends "given" ? Partial<GivenState> : ResolvedStepType extends "when" ? Partial<WhenState> : Partial<ThenState> | void;
-    register: () => {
-        stepType: ResolvedStepType;
-        dependencies: Dependencies;
-        statement: Statement;
-        stepFunction: (input: {
-            variables: Variables;
-            given: RestrictedGivenState;
-            when: RestrictedWhenState;
-            then: RestrictedThenState;
-        }) => ResolvedStepType extends "given" ? Partial<GivenState> : ResolvedStepType extends "when" ? Partial<WhenState> : Partial<ThenState> | void;
-    };
-};

package/dist/types/src/given.d.ts

@@ -1,73 +0,0 @@
-import { EmptyDependencies, EmptyObject, GetFunctionArgs, RequiredOrOptional } from "./builderTypeUtils";
-export declare const givenBuilder: <GivenState>() => {
-    statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
-        dependencies: <GivenDeps extends RequiredOrOptional<GivenState>>(dependencies: {
-            given: GivenDeps;
-        }) => {
-            step: (stepFunction: (input: {
-                variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
-                when: never;
-                then: never;
-            }) => Partial<GivenState>) => {
-                statement: Statement extends string ? () => string : Statement;
-                dependencies: {
-                    given: GivenDeps;
-                } & {
-                    when: EmptyObject;
-                    then: EmptyObject;
-                };
-                stepType: "given";
-                stepFunction: (input: {
-                    variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                    given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
-                    when: never;
-                    then: never;
-                }) => Partial<GivenState>;
-                register: () => {
-                    stepType: "given";
-                    dependencies: {
-                        given: GivenDeps;
-                    } & {
-                        when: EmptyObject;
-                        then: EmptyObject;
-                    };
-                    statement: Statement extends string ? () => string : Statement;
-                    stepFunction: (input: {
-                        variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                        given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
-                        when: never;
-                        then: never;
-                    }) => Partial<GivenState>;
-                };
-            };
-        };
-        step: (stepFunction: (input: {
-            variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-            given: never;
-            when: never;
-            then: never;
-        }) => Partial<GivenState>) => {
-            statement: Statement extends string ? () => string : Statement;
-            dependencies: EmptyDependencies;
-            stepType: "given";
-            stepFunction: (input: {
-                variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                given: never;
-                when: never;
-                then: never;
-            }) => Partial<GivenState>;
-            register: () => {
-                stepType: "given";
-                dependencies: EmptyDependencies;
-                statement: Statement extends string ? () => string : Statement;
-                stepFunction: (input: {
-                    variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                    given: never;
-                    when: never;
-                    then: never;
-                }) => Partial<GivenState>;
-            };
-        };
-    };
-};

package/dist/types/src/index.d.ts

@@ -1,5 +0,0 @@
-import { givenBuilder } from "./given";
-import { whenBuilder } from "./when";
-import { thenBuilder } from "./then";
-import { BasicWorld } from "./world";
-export { givenBuilder, whenBuilder, thenBuilder, BasicWorld };

package/dist/types/src/then.d.ts

@@ -1,73 +0,0 @@
-import { EmptyDependencies, GetFunctionArgs, RequiredOrOptional } from "./builderTypeUtils";
-export declare const thenBuilder: <GivenState, WhenState, ThenState>() => {
-    statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
-        dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>, ThenDeps extends RequiredOrOptional<ThenState>>(dependencies: {
-            given?: GivenDeps | undefined;
-            when?: WhenDeps | undefined;
-            then?: ThenDeps | undefined;
-        }) => {
-            step: (stepFunction: (input: {
-                variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
-                when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1]; };
-                then: { [K_2 in keyof ThenState as K_2 extends keyof ThenDeps ? K_2 : never]: ThenDeps[K_2] extends "optional" ? ThenState[K_2] | undefined : ThenState[K_2]; };
-            }) => void | Partial<ThenState>) => {
-                statement: Statement extends string ? () => string : Statement;
-                dependencies: {
-                    given: GivenDeps;
-                    when: WhenDeps;
-                    then: ThenDeps;
-                };
-                stepType: "then";
-                stepFunction: (input: {
-                    variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                    given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
-                    when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1]; };
-                    then: { [K_2 in keyof ThenState as K_2 extends keyof ThenDeps ? K_2 : never]: ThenDeps[K_2] extends "optional" ? ThenState[K_2] | undefined : ThenState[K_2]; };
-                }) => void | Partial<ThenState>;
-                register: () => {
-                    stepType: "then";
-                    dependencies: {
-                        given: GivenDeps;
-                        when: WhenDeps;
-                        then: ThenDeps;
-                    };
-                    statement: Statement extends string ? () => string : Statement;
-                    stepFunction: (input: {
-                        variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                        given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
-                        when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1]; };
-                        then: { [K_2 in keyof ThenState as K_2 extends keyof ThenDeps ? K_2 : never]: ThenDeps[K_2] extends "optional" ? ThenState[K_2] | undefined : ThenState[K_2]; };
-                    }) => void | Partial<ThenState>;
-                };
-            };
-        };
-        step: (stepFunction: (input: {
-            variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-            given: never;
-            when: never;
-            then: never;
-        }) => void | Partial<ThenState>) => {
-            statement: Statement extends string ? () => string : Statement;
-            dependencies: EmptyDependencies;
-            stepType: "then";
-            stepFunction: (input: {
-                variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                given: never;
-                when: never;
-                then: never;
-            }) => void | Partial<ThenState>;
-            register: () => {
-                stepType: "then";
-                dependencies: EmptyDependencies;
-                statement: Statement extends string ? () => string : Statement;
-                stepFunction: (input: {
-                    variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                    given: never;
-                    when: never;
-                    then: never;
-                }) => void | Partial<ThenState>;
-            };
-        };
-    };
-};

package/dist/types/src/utils.d.ts

@@ -1,5 +0,0 @@
-import { MergeableWorld } from "./world";
-export declare const requireFromGiven: <G>(keys: (keyof G)[], world: MergeableWorld<G, unknown, unknown>) => { [key in keyof G]: G[key]; };
-export declare const requireFromWhen: <W>(keys: (keyof W)[], world: MergeableWorld<unknown, W, unknown>) => { [key in keyof W]: W[key]; };
-export declare const requireFromThen: <T>(keys: (keyof T)[], world: MergeableWorld<unknown, unknown, T>) => { [key in keyof T]: T[key]; };
-export declare const typeCoercer: (value: string) => string | number | boolean;

package/dist/types/src/when.d.ts

@@ -1,72 +0,0 @@
-import { EmptyDependencies, EmptyObject, GetFunctionArgs, RequiredOrOptional } from "./builderTypeUtils";
-export declare const whenBuilder: <GivenState, WhenState>() => {
-    statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
-        dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>>(dependencies: {
-            given?: GivenDeps | undefined;
-            when?: WhenDeps | undefined;
-        }) => {
-            step: (stepFunction: (input: {
-                variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
-                when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1]; };
-                then: never;
-            }) => Partial<WhenState>) => {
-                statement: Statement extends string ? () => string : Statement;
-                dependencies: {
-                    given: GivenDeps;
-                    when: WhenDeps;
-                    then: EmptyObject;
-                };
-                stepType: "when";
-                stepFunction: (input: {
-                    variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                    given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
-                    when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1]; };
-                    then: never;
-                }) => Partial<WhenState>;
-                register: () => {
-                    stepType: "when";
-                    dependencies: {
-                        given: GivenDeps;
-                        when: WhenDeps;
-                        then: EmptyObject;
-                    };
-                    statement: Statement extends string ? () => string : Statement;
-                    stepFunction: (input: {
-                        variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                        given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K]; };
-                        when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1]; };
-                        then: never;
-                    }) => Partial<WhenState>;
-                };
-            };
-        };
-        step: (stepFunction: (input: {
-            variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-            given: never;
-            when: never;
-            then: never;
-        }) => Partial<WhenState>) => {
-            statement: Statement extends string ? () => string : Statement;
-            dependencies: EmptyDependencies;
-            stepType: "when";
-            stepFunction: (input: {
-                variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                given: never;
-                when: never;
-                then: never;
-            }) => Partial<WhenState>;
-            register: () => {
-                stepType: "when";
-                dependencies: EmptyDependencies;
-                statement: Statement extends string ? () => string : Statement;
-                stepFunction: (input: {
-                    variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-                    given: never;
-                    when: never;
-                    then: never;
-                }) => Partial<WhenState>;
-            };
-        };
-    };
-};

package/dist/types/src/world.d.ts

@@ -1,21 +0,0 @@
-export type WorldState<State> = {
-    readonly [K in keyof State]?: State[K];
-};
-export type MergeableWorldState<T> = WorldState<T> & {
-    merge: (newState: Partial<T>) => void;
-};
-export declare const createMergeableState: <T>(state: WorldState<T>) => MergeableWorldState<T>;
-export type MergeableWorld<Given, When, Then> = {
-    given: MergeableWorldState<Given>;
-    when: MergeableWorldState<When>;
-    then: MergeableWorldState<Then>;
-};
-export declare class BasicWorld<Given, When, Then> {
-    private givenState;
-    private whenState;
-    private thenState;
-    get given(): MergeableWorldState<Given>;
-    get when(): MergeableWorldState<When>;
-    get then(): MergeableWorldState<Then>;
-}
-export declare const createBasicWorld: <Given, When, Then>() => MergeableWorld<Given, When, Then>;

package/dts-bundle-generator.config.cjs

@@ -1,19 +0,0 @@
-const config = {
-  compilationOptions: {
-    preferredConfigPath: "./tsconfig.json",
-  },
-  entries: [
-    {
-      filePath: "./src/index.ts",
-      outFile: "./build/dist/index.d.ts",
-      noCheck: false,
-    },
-    {
-      filePath: "./src/analyzer/index.ts",
-      outFile: "./build/dist/analyzer.d.ts",
-      noCheck: false,
-    },
-  ],
-};
-
-module.exports = config;

package/rolldown.config.mjs

@@ -1,45 +0,0 @@
-import { defineConfig } from "rolldown";
-
-const allExternal = [
-  "@cucumber/cucumber",
-  "@cucumber/gherkin",
-  "@cucumber/messages",
-  "@cucumber/cucumber-expressions",
-  "lodash",
-  "typescript",
-  /^node:/,
-];
-
-export default defineConfig([
-  {
-    input: "./src/index.ts",
-    output: {
-      file: "./build/dist/step-forge.js",
-      format: "esm",
-      sourcemap: true,
-    },
-    external: allExternal,
-  },
-  {
-    input: "./src/index.ts",
-    output: {
-      file: "./build/dist/step-forge.cjs",
-      format: "cjs",
-      sourcemap: true,
-    },
-    external: allExternal,
-  },
-  {
-    input: {
-      analyzer: "./src/analyzer/index.ts",
-      "analyzer-cli": "./src/analyzer/cli.ts",
-    },
-    output: {
-      dir: "./build/dist",
-      format: "esm",
-      sourcemap: true,
-      entryFileNames: "[name].js",
-    },
-    external: allExternal,
-  },
-]);