@step-forge/step-forge 0.0.12 → 0.0.13

package/test/givenCompilationTests.ts

@@ -1,130 +0,0 @@
-import { givenBuilder } from "../src/given";
-import { SampleGivenState } from "./testUtils";
-
-// Simplest possible example
-givenBuilder<SampleGivenState>()
-  .statement("Given a user")
-  .step(() => {
-    return {
-      a: "user",
-    };
-  });
-
-// Simple dependency example
-givenBuilder<SampleGivenState>()
-  .statement("Given a user")
-  .dependencies({
-    given: {
-      a: "required",
-    },
-  })
-  .step(({ given }) => {
-    return {
-      b: `I love ${given.a}`,
-    };
-  });
-
-// Simple variables example
-givenBuilder<SampleGivenState>()
-  .statement((v1: string, v2: number) => `Given a user ${v1} ${v2}`)
-  .step(({ variables: [v1, v2] }) => {
-    return {
-      b: `I love ${v1} ${v2}`,
-    };
-  });
-
-// Complex example
-givenBuilder<SampleGivenState>()
-  .statement((v1: string, v2: number) => `Given a user ${v1} ${v2}`)
-  .dependencies({
-    given: {
-      a: "required",
-      b: "optional",
-      c: "required",
-    },
-  })
-  .step(({ variables: [v1, v2], given: { a, b, c } }) => {
-    return {
-      b: `I love ${v1} ${v2} ${a} ${b} ${c}`,
-    };
-  });
-
-// ----- Should not compile section ----
-
-// @ts-expect-error - Should not compile without a statement
-givenBuilder<SampleGivenState>().step(() => {
-  return {
-    a: "user",
-  };
-});
-
-givenBuilder<SampleGivenState>()
-  .statement(() => "Given a user")
-  // @ts-expect-error - Should not compile since no variables are declared
-  .step(({ variables: [v1, v2] }) => {
-    return {
-      a: `I love ${v1} ${v2}`,
-    };
-  });
-
-// TODO: Currently resolves variables to `any[]` which is incorrect
-givenBuilder<SampleGivenState>()
-  .statement("Given a user")
-  // @ts-expect-error - Should not compile since no variables are declared
-  .step(({ variables: [v1, v2] }) => {
-    return {
-      a: `I love ${v1} ${v2}`,
-    };
-  });
-
-givenBuilder<SampleGivenState>()
-  .statement(
-    (v1: string, v2: number, v3: boolean) => `Given a user ${v1} ${v2} ${v3}`
-  )
-  // @ts-expect-error - Should not compile since the number of variables exceeds the number declared
-  .step(({ variables: [v1, v2, v3, v4] }) => {
-    return {
-      a: `I love ${v1} ${v2} ${v3} ${v4}`,
-    };
-  });
-
-givenBuilder<SampleGivenState>()
-  .statement("Given a user")
-  .dependencies({ given: { a: "required" } })
-  .step(({ given }) => {
-    return {
-      // @ts-expect-error - Should not compile if we attempt to access a part of state that was not declared as a dependency
-      b: `I love ${given.b}`,
-    };
-  });
-
-givenBuilder<SampleGivenState>()
-  .statement("a user")
-  // @ts-expect-error - Should not compile if we attempt to access a part of state that was not declared as a dependency
-  .dependencies({ when: { a: "required" } })
-  .step(({ when }) => {
-    return {
-      // @ts-expect-error - Should not compile if we attempt to access a part of state that was not declared as a dependency
-      b: `I love ${when.c}`,
-    };
-  });
-
-givenBuilder<SampleGivenState>()
-  .statement("Given a user")
-  .dependencies({ given: { a: "optional" } })
-  .step(({ given }) => {
-    // @ts-expect-error - Should not compile since a is optional and can be undefined
-    const strictA: string = given.a;
-    return {
-      b: `I love ${strictA}`,
-    };
-  });
-
-givenBuilder<SampleGivenState>()
-  .statement("Given a user")
-  // @ts-expect-error - Should not compile since the return type is not a partial of given state
-  .step(() => {
-    return {
-      f: "hello",
-    };
-  });

package/test/testUtils.ts

@@ -1,30 +0,0 @@
-import { createBasicWorld } from "../src/world";
-
-export const sampleGivenState = {
-  a: "stuff",
-  b: "things",
-  c: 3,
-};
-export type SampleGivenState = typeof sampleGivenState;
-
-export const sampleWhenState = {
-  d: 1,
-  e: "other stuff",
-  f: [3, 4, 5],
-};
-export type SampleWhenState = typeof sampleWhenState;
-
-export const sampleThenState = {
-  g: 1,
-  h: 2,
-  i: { j: "k" },
-};
-export type SampleThenState = typeof sampleThenState;
-
-export const sampleWorld = createBasicWorld<
-  SampleGivenState,
-  SampleWhenState,
-  SampleThenState
->();
-
-export type SampleWorld = typeof sampleWorld;

package/test/thenCompilationTests.ts

@@ -1,207 +0,0 @@
-import { thenBuilder } from "../src/then";
-import {
-  SampleGivenState,
-  SampleThenState,
-  SampleWhenState,
-} from "./testUtils";
-
-// Simplest possible example
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement("Then we should see something")
-  .step(() => {
-    return {
-      i: { j: "result" },
-    };
-  });
-
-// Simple dependency on given state example
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement("Then we should see something")
-  .dependencies({
-    given: {
-      a: "required",
-    },
-  })
-  .step(({ given }) => {
-    return {
-      i: { j: `Result with ${given.a}` },
-    };
-  });
-
-// Simple dependency on when state example
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement("Then we should see something")
-  .dependencies({
-    when: {
-      d: "required",
-    },
-  })
-  .step(({ when }) => {
-    return {
-      i: { j: `Result with ${when.d}` },
-    };
-  });
-
-// Simple dependency on then state example
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement("Then we should see something")
-  .dependencies({
-    then: {
-      g: "required",
-    },
-  })
-  .step(({ then }) => {
-    return {
-      i: { j: `Result with ${then.g}` },
-    };
-  });
-
-// Simple variables example
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement((v1: string, v2: number) => `Then we should see ${v1} ${v2} times`)
-  .step(({ variables: [v1, v2] }) => {
-    return {
-      i: { j: `Result ${v1} ${v2}` },
-    };
-  });
-
-// Complex example with all dependencies
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement((v1: string, v2: number) => `Then we should see ${v1} ${v2} times`)
-  .dependencies({
-    given: {
-      a: "required",
-      b: "optional",
-    },
-    when: {
-      d: "required",
-      e: "optional",
-    },
-    then: {
-      g: "required",
-      h: "optional",
-    },
-  })
-  .step(
-    ({
-      variables: [v1, v2],
-      given: { a, b },
-      when: { d, e },
-      then: { g, h },
-    }) => {
-      return {
-        i: { j: `Result ${v1} ${v2} with ${a} ${b} ${d} ${e} ${g} ${h}` },
-      };
-    }
-  );
-
-// ----- Should not compile section ----
-
-// @ts-expect-error - Should not compile without a statement
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>().step(() => {
-  return {
-    i: { j: "result" },
-  };
-});
-
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement(() => "Then we should see something")
-  // @ts-expect-error - Should not compile since no variables are declared
-  .step(({ variables: [v1, v2] }) => {
-    return {
-      i: { j: `Result ${v1} ${v2}` },
-    };
-  });
-
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement("Then we should see something")
-  // @ts-expect-error - Should not compile since no variables are declared
-  .step(({ variables: [v1, v2] }) => {
-    return {
-      i: { j: `Result ${v1} ${v2}` },
-    };
-  });
-
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement(
-    (v1: string, v2: number, v3: boolean) =>
-      `Then we should see ${v1} ${v2} ${v3}`
-  )
-  // @ts-expect-error - Should not compile since the number of variables exceeds the number declared
-  .step(({ variables: [v1, v2, v3, v4] }) => {
-    return {
-      i: { j: `Result ${v1} ${v2} ${v3} ${v4}` },
-    };
-  });
-
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement("Then we should see something")
-  .dependencies({ given: { a: "required" } })
-  .step(({ given }) => {
-    return {
-      // @ts-expect-error - Should not compile if we attempt to access a part of state that was not declared as a dependency
-      i: { j: `Result ${given.b}` },
-    };
-  });
-
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement("Then we should see something")
-  .dependencies({ when: { d: "required" } })
-  .step(({ when }) => {
-    return {
-      // @ts-expect-error - Should not compile if we attempt to access a part of state that was not declared as a dependency
-      i: { j: `Result ${when.f}` },
-    };
-  });
-
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement("Then we should see something")
-  .dependencies({ then: { g: "required" } })
-  .step(({ then }) => {
-    return {
-      // @ts-expect-error - Should not compile if we attempt to access a part of state that was not declared as a dependency
-      i: { j: `Result ${then.i}` },
-    };
-  });
-
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement("Then we should see something")
-  .dependencies({ given: { a: "optional" } })
-  .step(({ given }) => {
-    // @ts-expect-error - Should not compile since a is optional and can be undefined
-    const strictA: string = given.a;
-    return {
-      i: { j: `Result ${strictA}` },
-    };
-  });
-
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement("Then we should see something")
-  .dependencies({ when: { e: "optional" } })
-  .step(({ when }) => {
-    // @ts-expect-error - Should not compile since e is optional and can be undefined
-    const strictE: string = when.e;
-    return {
-      i: { j: `Result ${strictE}` },
-    };
-  });
-
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement("Then we should see something")
-  .dependencies({ then: { h: "optional" } })
-  .step(({ then }) => {
-    // @ts-expect-error - Should not compile since h is optional and can be undefined
-    const strictH: string = then.h;
-    return {
-      i: { j: `Result ${strictH}` },
-    };
-  });
-
-thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
-  .statement("Then we should see something")
-  // @ts-expect-error - Should not compile since the return type is not a partial of then state
-  .step(() => {
-    return {
-      a: "hello",
-    };
-  });

package/test/whenCompilationTests.ts

@@ -1,157 +0,0 @@
-import { whenBuilder } from "../src/when";
-import { SampleGivenState, SampleWhenState } from "./testUtils";
-
-// Simplest possible example
-whenBuilder<SampleGivenState, SampleWhenState>()
-  .statement("When a user does something")
-  .step(() => {
-    return {
-      e: "action",
-    };
-  });
-
-// Simple dependency on given state example
-whenBuilder<SampleGivenState, SampleWhenState>()
-  .statement("When a user does something")
-  .dependencies({
-    given: {
-      a: "required",
-    },
-  })
-  .step(({ given }) => {
-    return {
-      e: `Action with ${given.a}`,
-    };
-  });
-
-// Simple dependency on when state example
-whenBuilder<SampleGivenState, SampleWhenState>()
-  .statement("When a user does something")
-  .dependencies({
-    when: {
-      d: "required",
-    },
-  })
-  .step(({ when }) => {
-    return {
-      e: `Action with ${when.d}`,
-    };
-  });
-
-// Simple variables example
-whenBuilder<SampleGivenState, SampleWhenState>()
-  .statement((v1: string, v2: number) => `When a user does ${v1} ${v2} times`)
-  .step(({ variables: [v1, v2] }) => {
-    return {
-      e: `Action ${v1} ${v2}`,
-    };
-  });
-
-// Complex example with both dependencies
-whenBuilder<SampleGivenState, SampleWhenState>()
-  .statement((v1: string, v2: number) => `When a user does ${v1} ${v2} times`)
-  .dependencies({
-    given: {
-      a: "required",
-      b: "optional",
-    },
-    when: {
-      d: "required",
-      e: "optional",
-    },
-  })
-  .step(({ variables: [v1, v2], given: { a, b }, when: { d, e } }) => {
-    return {
-      e: `Action ${v1} ${v2} with ${a} ${b} ${d} ${e}`,
-    };
-  });
-
-// ----- Should not compile section ----
-
-// @ts-expect-error - Should not compile without a statement
-whenBuilder<SampleGivenState, SampleWhenState>().step(() => {
-  return {
-    a: "action",
-  };
-});
-
-whenBuilder<SampleGivenState, SampleWhenState>()
-  .statement(() => "When a user does something")
-  // @ts-expect-error - Should not compile since no variables are declared
-  .step(({ variables: [v1, v2] }) => {
-    return {
-      a: `Action ${v1} ${v2}`,
-    };
-  });
-
-whenBuilder<SampleGivenState, SampleWhenState>()
-  .statement("When a user does something")
-  // @ts-expect-error - Should not compile since no variables are declared
-  .step(({ variables: [v1, v2] }) => {
-    return {
-      a: `Action ${v1} ${v2}`,
-    };
-  });
-
-whenBuilder<SampleGivenState, SampleWhenState>()
-  .statement(
-    (v1: string, v2: number, v3: boolean) =>
-      `When a user does ${v1} ${v2} ${v3}`
-  )
-  // @ts-expect-error - Should not compile since the number of variables exceeds the number declared
-  .step(({ variables: [v1, v2, v3, v4] }) => {
-    return {
-      a: `Action ${v1} ${v2} ${v3} ${v4}`,
-    };
-  });
-
-whenBuilder<SampleGivenState, SampleWhenState>()
-  .statement("When a user does something")
-  .dependencies({ given: { a: "required" } })
-  .step(({ given }) => {
-    return {
-      // @ts-expect-error - Should not compile if we attempt to access a part of state that was not declared as a dependency
-      e: `Action ${given.b}`,
-    };
-  });
-
-whenBuilder<SampleGivenState, SampleWhenState>()
-  .statement("When a user does something")
-  .dependencies({ when: { d: "required" } })
-  .step(({ when }) => {
-    return {
-      // @ts-expect-error - Should not compile if we attempt to access a part of state that was not declared as a dependency
-      e: `Action ${when.f}`,
-    };
-  });
-
-whenBuilder<SampleGivenState, SampleWhenState>()
-  .statement("When a user does something")
-  .dependencies({ given: { a: "optional" } })
-  .step(({ given }) => {
-    // @ts-expect-error - Should not compile since a is optional and can be undefined
-    const strictA: string = given.a;
-    return {
-      e: `Action ${strictA}`,
-    };
-  });
-
-whenBuilder<SampleGivenState, SampleWhenState>()
-  .statement("When a user does something")
-  .dependencies({ when: { e: "optional" } })
-  .step(({ when }) => {
-    // @ts-expect-error - Should not compile since a is optional and can be undefined
-    const strictE: string = when.e;
-    return {
-      f: [strictE.length],
-    };
-  });
-
-whenBuilder<SampleGivenState, SampleWhenState>()
-  .statement("When a user does something")
-  // @ts-expect-error - Should not compile since the return type is not a partial of when state
-  .step(() => {
-    return {
-      a: "hello",
-    };
-  });

package/ts-node-esm-register.js

@@ -1,8 +0,0 @@
-import { register } from "ts-node";
-
-register({
-  project: "./tsconfig.cucumber.json",
-  esm: true,
-  experimentalSpecifierResolution: "node",
-  transpileOnly: true,
-});

package/tsconfig.cucumber.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "allowJs": true,
-    "esModuleInterop": true,
-    "allowImportingTsExtensions": true,
-    "noEmit": true,
-    "moduleDetection": "force"
-  },
-  "include": ["features/**/*.ts", "src/**/*.ts"],
-  "exclude": ["node_modules", "src/vite-env.d.ts"]
-}

package/tsconfig.json

@@ -1,29 +0,0 @@
-{
-  "compilerOptions": {
-    "rootDir": ".",
-    "paths": {
-      "@/*": ["./src/*"],
-      "@@/*": ["./*"]
-    },
-    "target": "ESNext",
-    "useDefineForClassFields": true,
-    "module": "ESNext",
-    "lib": ["ESNext", "DOM"],
-    "moduleResolution": "Node",
-    "strict": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "noEmit": false,
-    "emitDeclarationOnly": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "forceConsistentCasingInFileNames": true,
-    "types": ["node"],
-    "declaration": true,
-    "declarationDir": "./build/dist/types"
-  },
-  "include": ["src"],
-  "exclude": ["**/*.test.ts", "node_modules", "test/**", ".history/**"]
-}

package/tsdown.config.ts

@@ -1,35 +0,0 @@
-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"],
-  },
-]);