@step-forge/step-forge 0.0.12 → 0.0.14

package/src/common.ts

@@ -1,138 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import {
-  Given as CucGiven,
-  Then as CucThen,
-  When as CucWhen,
-} from "@cucumber/cucumber";
-import _ from "lodash";
-
-import { StepType } from "./builderTypeUtils";
-import {
-  requireFromGiven,
-  requireFromThen,
-  requireFromWhen,
-  typeCoercer,
-} from "./utils";
-import { MergeableWorld } from "./world";
-
-const cucFunctionMap = {
-  given: CucGiven,
-  when: CucWhen,
-  then: CucThen,
-};
-
-export 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 = {
-      given: {},
-      when: {},
-      then: {},
-    } as Dependencies
-  ) =>
-  (
-    stepFunction: (input: {
-      variables: Variables;
-      given: RestrictedGivenState;
-      when: RestrictedWhenState;
-      then: RestrictedThenState;
-    }) => ResolvedStepType extends "given"
-      ? Partial<GivenState>
-      : ResolvedStepType extends "when"
-        ? Partial<WhenState>
-        : Partial<ThenState> | void
-  ) => {
-    const statementFunction = statement;
-    const {
-      given: givenDependencies,
-      when: whenDependencies,
-      then: thenDependencies,
-    } = dependencies;
-    return {
-      statement,
-      dependencies,
-      stepType,
-      stepFunction,
-      register: () => {
-        const argCount = statementFunction.length;
-        const argMatchers = Array.from({ length: argCount }, () => "{string}");
-        const statement = statementFunction(...argMatchers);
-        const cucStepFunction = Object.defineProperty(
-          async function (
-            this: MergeableWorld<GivenState, WhenState, ThenState>,
-            ...args: string[]
-          ) {
-            const coercedArgs = args.map(typeCoercer);
-            const requiredGivenKeys = Object.entries(givenDependencies ?? {})
-              .filter(([, value]) => value === "required")
-              .map(([key]) => key);
-            const ensuredGivenValues = requireFromGiven(
-              requiredGivenKeys as (keyof GivenState)[],
-              this
-            );
-            const narrowedGiven = {
-              ..._.pick(this.given, Object.keys(givenDependencies ?? {})),
-              ...ensuredGivenValues,
-            };
-            const requiredWhenKeys = Object.entries(whenDependencies ?? {})
-              .filter(([, value]) => value === "required")
-              .map(([key]) => key);
-            const ensuredWhenValues = requireFromWhen(
-              requiredWhenKeys as (keyof WhenState)[],
-              this
-            );
-            const narrowedWhen = {
-              ..._.pick(this.when, Object.keys(whenDependencies ?? {})),
-              ...ensuredWhenValues,
-            };
-            const requiredThenKeys = Object.entries(thenDependencies ?? {})
-              .filter(([, value]) => value === "required")
-              .map(([key]) => key);
-            const ensuredThenValues = requireFromThen(
-              requiredThenKeys as (keyof ThenState)[],
-              this
-            );
-            const narrowedThen = {
-              ..._.pick(this.then, Object.keys(thenDependencies ?? {})),
-              ...ensuredThenValues,
-            };
-            const result = await stepFunction({
-              variables: coercedArgs as Variables,
-              given: narrowedGiven as RestrictedGivenState,
-              when: narrowedWhen as RestrictedWhenState,
-              then: narrowedThen as RestrictedThenState,
-            });
-            this[stepType].merge({
-              ...(result as any),
-            });
-          },
-          "length",
-          { value: argCount, configurable: true }
-        );
-        const cucStep = cucFunctionMap[stepType];
-        cucStep(statement, cucStepFunction);
-        return {
-          stepType,
-          dependencies,
-          statement: statementFunction,
-          stepFunction,
-        };
-      },
-    };
-  };

package/src/given.ts

@@ -1,102 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import {
-  EmptyDependencies,
-  EmptyObject,
-  GetFunctionArgs,
-  isString,
-  RequiredOrOptional,
-  StepType,
-} from "./builderTypeUtils";
-import { addStep } from "./common";
-
-const givenDependencies =
-  <
-    Statement extends (...args: any[]) => string,
-    ResolvedStepType extends StepType,
-    Variables,
-    GivenState,
-  >(
-    statement: Statement,
-    stepType: ResolvedStepType
-  ) =>
-  <GivenDeps extends RequiredOrOptional<GivenState>>(dependencies: {
-    given: GivenDeps;
-  }) => {
-    type RestrictedGivenState = {
-      [K in keyof GivenState as K extends keyof GivenDeps
-        ? K
-        : never]: GivenDeps[K] extends "optional"
-        ? GivenState[K] | undefined
-        : GivenState[K];
-    };
-    type Dependencies = typeof dependencies & {
-      when: EmptyObject;
-      then: EmptyObject;
-    };
-    const fullDependencies = {
-      ...dependencies,
-      when: {},
-      then: {},
-    };
-    return {
-      step: addStep<
-        ResolvedStepType,
-        Statement,
-        Dependencies,
-        Variables,
-        GivenState,
-        never, // when state
-        never, // then state
-        RestrictedGivenState,
-        never, // restricted when state
-        never // restricted then state
-      >(statement, stepType, fullDependencies),
-    };
-  };
-
-const givenStatement =
-  <ResolvedStepType extends StepType, GivenState>(stepType: ResolvedStepType) =>
-  <Statement extends ((...args: [...any]) => string) | string>(
-    statement: Statement
-  ) => {
-    let normalizedStatement: Statement extends string
-      ? () => string
-      : Statement;
-    if (isString(statement)) {
-      normalizedStatement = (() => statement) as any;
-    } else {
-      normalizedStatement = statement as any;
-    }
-    type NormalizedStatement = typeof normalizedStatement;
-
-    type Variables = Statement extends string ? [] : GetFunctionArgs<Statement>;
-    const dependencyFunc = givenDependencies<
-      NormalizedStatement,
-      ResolvedStepType,
-      Variables,
-      GivenState
-    >(normalizedStatement, stepType);
-    const stepFunc = addStep<
-      ResolvedStepType,
-      NormalizedStatement,
-      EmptyDependencies,
-      Variables,
-      GivenState,
-      never,
-      never,
-      never,
-      never,
-      never
-    >(normalizedStatement, stepType);
-    return {
-      dependencies: dependencyFunc,
-      step: stepFunc,
-    };
-  };
-
-export const givenBuilder = <GivenState>() => {
-  return {
-    statement: givenStatement<"given", GivenState>("given"),
-  };
-};

package/src/index.ts

@@ -1,46 +0,0 @@
-import { givenBuilder } from "./given";
-import { whenBuilder } from "./when";
-import { thenBuilder } from "./then";
-import { BasicWorld } from "./world";
-import {
-  analyze,
-  extractStepDefinitions,
-  parseFeatureFiles,
-  parseFeatureContent,
-  matchScenarioSteps,
-  findMatchingDefinitions,
-  defaultRules,
-} from "./analyzer/index";
-import type {
-  AnalyzerConfig,
-  AnalyzeOptions,
-  AnalysisRule,
-  Diagnostic,
-  StepDefinitionMeta,
-  ParsedScenario,
-  ParsedStep,
-  MatchedStep,
-} from "./analyzer/index";
-
-export { givenBuilder, whenBuilder, thenBuilder, BasicWorld };
-
-export const analyzer = {
-  analyze,
-  extractStepDefinitions,
-  parseFeatureFiles,
-  parseFeatureContent,
-  matchScenarioSteps,
-  findMatchingDefinitions,
-  defaultRules,
-};
-
-export type {
-  AnalyzerConfig,
-  AnalyzeOptions,
-  AnalysisRule,
-  Diagnostic,
-  StepDefinitionMeta,
-  ParsedScenario,
-  ParsedStep,
-  MatchedStep,
-};

package/src/then.ts

@@ -1,128 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import {
-  EmptyDependencies,
-  GetFunctionArgs,
-  isString,
-  RequiredOrOptional,
-  StepType,
-} from "./builderTypeUtils";
-import { addStep } from "./common";
-
-const thenDependencies =
-  <
-    Statement extends (...args: any[]) => string,
-    ResolvedStepType extends StepType,
-    Variables,
-    GivenState,
-    WhenState,
-    ThenState,
-  >(
-    statement: Statement,
-    stepType: ResolvedStepType
-  ) =>
-  <
-    GivenDeps extends RequiredOrOptional<GivenState>,
-    WhenDeps extends RequiredOrOptional<WhenState>,
-    ThenDeps extends RequiredOrOptional<ThenState>,
-  >(dependencies: {
-    given?: GivenDeps;
-    when?: WhenDeps;
-    then?: ThenDeps;
-  }) => {
-    type RestrictedGivenState = {
-      [K in keyof GivenState as K extends keyof GivenDeps
-        ? K
-        : never]: GivenDeps[K] extends "optional"
-        ? GivenState[K] | undefined
-        : GivenState[K];
-    };
-    type RestrictedWhenState = {
-      [K in keyof WhenState as K extends keyof WhenDeps
-        ? K
-        : never]: WhenDeps[K] extends "optional"
-        ? WhenState[K] | undefined
-        : WhenState[K];
-    };
-    type RestrictedThenState = {
-      [K in keyof ThenState as K extends keyof ThenDeps
-        ? K
-        : never]: ThenDeps[K] extends "optional"
-        ? ThenState[K] | undefined
-        : ThenState[K];
-    };
-    type Dependencies = {
-      given: GivenDeps;
-      when: WhenDeps;
-      then: ThenDeps;
-    };
-    const fullDependencies: Dependencies = {
-      given: dependencies.given ?? ({} as GivenDeps),
-      when: dependencies.when ?? ({} as WhenDeps),
-      then: dependencies.then ?? ({} as ThenDeps),
-    };
-    return {
-      step: addStep<
-        ResolvedStepType,
-        Statement,
-        Dependencies,
-        Variables,
-        GivenState,
-        WhenState,
-        ThenState,
-        RestrictedGivenState,
-        RestrictedWhenState,
-        RestrictedThenState
-      >(statement, stepType, fullDependencies),
-    };
-  };
-
-const thenStatement =
-  <ResolvedStepType extends StepType, GivenState, WhenState, ThenState>(
-    stepType: ResolvedStepType
-  ) =>
-  <Statement extends ((...args: [...any]) => string) | string>(
-    statement: Statement
-  ) => {
-    let normalizedStatement: Statement extends string
-      ? () => string
-      : Statement;
-    if (isString(statement)) {
-      normalizedStatement = (() => statement) as any;
-    } else {
-      normalizedStatement = statement as any;
-    }
-    type NormalizedStatement = typeof normalizedStatement;
-
-    type Variables = Statement extends string ? [] : GetFunctionArgs<Statement>;
-    const dependencyFunc = thenDependencies<
-      NormalizedStatement,
-      ResolvedStepType,
-      Variables,
-      GivenState,
-      WhenState,
-      ThenState
-    >(normalizedStatement, stepType);
-    const stepFunc = addStep<
-      ResolvedStepType,
-      NormalizedStatement,
-      EmptyDependencies,
-      Variables,
-      GivenState,
-      WhenState,
-      ThenState,
-      never,
-      never,
-      never
-    >(normalizedStatement, stepType);
-    return {
-      dependencies: dependencyFunc,
-      step: stepFunc,
-    };
-  };
-
-export const thenBuilder = <GivenState, WhenState, ThenState>() => {
-  return {
-    statement: thenStatement<"then", GivenState, WhenState, ThenState>("then"),
-  };
-};

package/src/utils.ts

@@ -1,74 +0,0 @@
-import { MergeableWorld } from "./world";
-
-export const requireFromGiven = <G>(
-  keys: (keyof G)[],
-  world: MergeableWorld<G, unknown, unknown>
-) => {
-  keys.forEach(key => {
-    if (!world.given[key]) {
-      throw new Error(`Key ${String(key)} is required in given state`);
-    }
-  });
-  return keys.reduce(
-    (acc, key) => {
-      return {
-        ...acc,
-        [key]: world.given[key],
-      };
-    },
-    {} as { [key in keyof G]: G[key] }
-  );
-};
-export const requireFromWhen = <W>(
-  keys: (keyof W)[],
-  world: MergeableWorld<unknown, W, unknown>
-) => {
-  keys.forEach(key => {
-    if (!world.when[key]) {
-      throw new Error(`Key ${String(key)} is required in when state`);
-    }
-  });
-  return keys.reduce(
-    (acc, key) => {
-      return {
-        ...acc,
-        [key]: world.when[key],
-      };
-    },
-    {} as { [key in keyof W]: W[key] }
-  );
-};
-export const requireFromThen = <T>(
-  keys: (keyof T)[],
-  world: MergeableWorld<unknown, unknown, T>
-) => {
-  keys.forEach(key => {
-    if (!world.then[key]) {
-      throw new Error(`Key ${String(key)} is required in then state`);
-    }
-  });
-  return keys.reduce(
-    (acc, key) => {
-      return {
-        ...acc,
-        [key]: world.then[key],
-      };
-    },
-    {} as { [key in keyof T]: T[key] }
-  );
-};
-
-export const typeCoercer = (value: string) => {
-  // Try to parse as integer first
-  const numberValue = parseInt(value, 10);
-  if (!isNaN(numberValue)) {
-    return numberValue;
-  }
-
-  // Check for boolean values
-  if (value === "true") return true;
-  if (value === "false") return false;
-
-  // Return original string if no other type matches
-  return value;
-};

package/src/when.ts

@@ -1,118 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import {
-  EmptyDependencies,
-  EmptyObject,
-  GetFunctionArgs,
-  isString,
-  RequiredOrOptional,
-  StepType,
-} from "./builderTypeUtils";
-import { addStep } from "./common";
-
-const whenDependencies =
-  <
-    Statement extends (...args: any[]) => string,
-    ResolvedStepType extends StepType,
-    Variables,
-    GivenState,
-    WhenState,
-  >(
-    statement: Statement,
-    stepType: ResolvedStepType
-  ) =>
-  <
-    GivenDeps extends RequiredOrOptional<GivenState>,
-    WhenDeps extends RequiredOrOptional<WhenState>,
-  >(dependencies: {
-    given?: GivenDeps;
-    when?: WhenDeps;
-  }) => {
-    type RestrictedGivenState = {
-      [K in keyof GivenState as K extends keyof GivenDeps
-        ? K
-        : never]: GivenDeps[K] extends "optional"
-        ? GivenState[K] | undefined
-        : GivenState[K];
-    };
-    type RestrictedWhenState = {
-      [K in keyof WhenState as K extends keyof WhenDeps
-        ? K
-        : never]: WhenDeps[K] extends "optional"
-        ? WhenState[K] | undefined
-        : WhenState[K];
-    };
-    type Dependencies = {
-      given: GivenDeps;
-      when: WhenDeps;
-      then: EmptyObject;
-    };
-    const fullDependencies: Dependencies = {
-      given: dependencies.given ?? ({} as GivenDeps),
-      when: dependencies.when ?? ({} as WhenDeps),
-      then: {},
-    };
-    return {
-      step: addStep<
-        ResolvedStepType,
-        Statement,
-        Dependencies,
-        Variables,
-        GivenState,
-        WhenState,
-        never,
-        RestrictedGivenState,
-        RestrictedWhenState,
-        never
-      >(statement, stepType, fullDependencies),
-    };
-  };
-
-const whenStatement =
-  <ResolvedStepType extends StepType, GivenState, WhenState>(
-    stepType: ResolvedStepType
-  ) =>
-  <Statement extends ((...args: [...any]) => string) | string>(
-    statement: Statement
-  ) => {
-    let normalizedStatement: Statement extends string
-      ? () => string
-      : Statement;
-    if (isString(statement)) {
-      normalizedStatement = (() => statement) as any;
-    } else {
-      normalizedStatement = statement as any;
-    }
-    type NormalizedStatement = typeof normalizedStatement;
-
-    type Variables = Statement extends string ? [] : GetFunctionArgs<Statement>;
-    const dependencyFunc = whenDependencies<
-      NormalizedStatement,
-      ResolvedStepType,
-      Variables,
-      GivenState,
-      WhenState
-    >(normalizedStatement, stepType);
-    const stepFunc = addStep<
-      ResolvedStepType,
-      NormalizedStatement,
-      EmptyDependencies,
-      Variables,
-      GivenState,
-      WhenState,
-      never,
-      never,
-      never,
-      never
-    >(normalizedStatement, stepType);
-    return {
-      dependencies: dependencyFunc,
-      step: stepFunc,
-    };
-  };
-
-export const whenBuilder = <GivenState, WhenState>() => {
-  return {
-    statement: whenStatement<"when", GivenState, WhenState>("when"),
-  };
-};

package/src/world.ts

@@ -1,90 +0,0 @@
-import _ from "lodash";
-
-export type WorldState<State> = {
-  readonly [K in keyof State]?: State[K];
-};
-
-export type MergeableWorldState<T> = WorldState<T> & {
-  merge: (newState: Partial<T>) => void;
-};
-
-function mergeCustomizer(objValue: unknown, srcValue: unknown) {
-  if (_.isArray(objValue)) {
-    return objValue.concat(srcValue);
-  } else if (objValue && !_.isPlainObject(objValue) && objValue !== srcValue) {
-    throw new Error(
-      `Merge would have destroyed previous value ${objValue} with ${srcValue}`
-    );
-  }
-  return objValue;
-}
-
-export const createMergeableState = <T>(
-  state: WorldState<T>
-): MergeableWorldState<T> => {
-  return {
-    ...state,
-    merge: (newState: Partial<T>) => {
-      state = _.merge({ ...state }, newState, mergeCustomizer);
-    },
-  };
-};
-
-export type MergeableWorld<Given, When, Then> = {
-  given: MergeableWorldState<Given>;
-  when: MergeableWorldState<When>;
-  then: MergeableWorldState<Then>;
-};
-
-export class BasicWorld<Given, When, Then> {
-  private givenState: WorldState<Given> = {};
-  private whenState: WorldState<When> = {};
-  private thenState: WorldState<Then> = {};
-
-  public get given(): MergeableWorldState<Given> {
-    return {
-      ...this.givenState,
-      merge: (newState: Partial<Given>) => {
-        this.givenState = _.merge(
-          { ...this.givenState },
-          newState,
-          mergeCustomizer
-        );
-      },
-    };
-  }
-
-  public get when(): MergeableWorldState<When> {
-    return {
-      ...this.whenState,
-      merge: (newState: Partial<When>) => {
-        this.whenState = _.merge(
-          { ...this.whenState },
-          newState,
-          mergeCustomizer
-        );
-      },
-    };
-  }
-
-  public get then(): MergeableWorldState<Then> {
-    return {
-      ...this.thenState,
-      merge: (newState: Partial<Then>) => {
-        this.thenState = _.merge(
-          { ...this.thenState },
-          newState,
-          mergeCustomizer
-        );
-      },
-    };
-  }
-}
-
-export const createBasicWorld = <Given, When, Then>(): MergeableWorld<
-  Given,
-  When,
-  Then
-> => {
-  return new BasicWorld<Given, When, Then>();
-};