@step-forge/step-forge 0.0.12 → 0.0.14

package/dist/step-forge.d.ts

@@ -0,0 +1,326 @@
+//#region src/builderTypeUtils.d.ts
+type EmptyObject = Record<string, never>;
+type RequiredOrOptional<T> = { [K in keyof T]?: "required" | "optional" };
+type GetFunctionArgs<T> = T extends ((...args: infer A) => any) ? A : never;
+type EmptyDependencies = {
+  given: EmptyObject;
+  when: EmptyObject;
+  then: EmptyObject;
+};
+//#endregion
+//#region src/given.d.ts
+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> | Promise<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> | Promise<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> | Promise<Partial<GivenState>>;
+        };
+      };
+    };
+    step: (stepFunction: (input: {
+      variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+      given: never;
+      when: never;
+      then: never;
+    }) => Partial<GivenState> | Promise<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> | Promise<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> | Promise<Partial<GivenState>>;
+      };
+    };
+  };
+};
+//#endregion
+//#region src/when.d.ts
+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> | Promise<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> | Promise<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> | Promise<Partial<WhenState>>;
+        };
+      };
+    };
+    step: (stepFunction: (input: {
+      variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+      given: never;
+      when: never;
+      then: never;
+    }) => Partial<WhenState> | Promise<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> | Promise<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> | Promise<Partial<WhenState>>;
+      };
+    };
+  };
+};
+//#endregion
+//#region src/then.d.ts
+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> | Promise<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> | Promise<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> | Promise<Partial<ThenState>>;
+        };
+      };
+    };
+    step: (stepFunction: (input: {
+      variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
+      given: never;
+      when: never;
+      then: never;
+    }) => void | Partial<ThenState> | Promise<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> | Promise<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> | Promise<Partial<ThenState>>;
+      };
+    };
+  };
+};
+//#endregion
+//#region src/world.d.ts
+type WorldState<State> = { readonly [K in keyof State]?: State[K] };
+type MergeableWorldState<T> = WorldState<T> & {
+  merge: (newState: Partial<T>) => void;
+};
+declare class BasicWorld<Given, When, Then> {
+  private givenState;
+  private whenState;
+  private thenState;
+  get given(): MergeableWorldState<Given>;
+  get when(): MergeableWorldState<When>;
+  get then(): MergeableWorldState<Then>;
+}
+//#endregion
+//#region src/analyzer/types.d.ts
+interface StepDefinitionMeta {
+  stepType: "given" | "when" | "then";
+  expression: string;
+  dependencies: {
+    given: Record<string, "required" | "optional">;
+    when: Record<string, "required" | "optional">;
+    then: Record<string, "required" | "optional">;
+  };
+  produces: string[];
+  sourceFile: string;
+  line: number;
+}
+interface ParsedScenario {
+  name: string;
+  file: string;
+  steps: ParsedStep[];
+}
+interface ParsedStep {
+  keyword: "Given" | "When" | "Then" | "And" | "But";
+  effectiveKeyword: "Given" | "When" | "Then";
+  text: string;
+  line: number;
+  column: number;
+}
+interface MatchedStep extends ParsedStep {
+  definitions: StepDefinitionMeta[];
+}
+interface Diagnostic {
+  file: string;
+  range: {
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+  };
+  severity: "error" | "warning" | "info";
+  message: string;
+  rule: string;
+  source: "step-forge";
+}
+interface AnalysisRule {
+  name: string;
+  check(scenario: ParsedScenario, matchedSteps: MatchedStep[]): Diagnostic[];
+}
+interface AnalyzerConfig {
+  stepFiles: string[];
+  featureFiles: string[];
+  tsConfigPath?: string;
+}
+//#endregion
+//#region src/analyzer/stepExtractor.d.ts
+declare function extractStepDefinitions(filePaths: string[], tsConfigPath?: string): StepDefinitionMeta[];
+//#endregion
+//#region src/analyzer/gherkinParser.d.ts
+declare function parseFeatureFiles(filePaths: string[]): ParsedScenario[];
+declare function parseFeatureContent(content: string, filePath: string): ParsedScenario[];
+//#endregion
+//#region src/analyzer/stepMatcher.d.ts
+declare function matchScenarioSteps(scenario: ParsedScenario, definitions: StepDefinitionMeta[]): MatchedStep[];
+declare function findMatchingDefinitions(text: string, effectiveKeyword: "Given" | "When" | "Then", definitions: StepDefinitionMeta[]): StepDefinitionMeta[];
+//#endregion
+//#region src/analyzer/index.d.ts
+interface AnalyzeOptions {
+  rules?: AnalysisRule[];
+}
+declare function analyze(config: AnalyzerConfig, options?: AnalyzeOptions): Promise<Diagnostic[]>;
+//#endregion
+//#region src/index.d.ts
+declare const analyzer: {
+  analyze: typeof analyze;
+  extractStepDefinitions: typeof extractStepDefinitions;
+  parseFeatureFiles: typeof parseFeatureFiles;
+  parseFeatureContent: typeof parseFeatureContent;
+  matchScenarioSteps: typeof matchScenarioSteps;
+  findMatchingDefinitions: typeof findMatchingDefinitions;
+  defaultRules: AnalysisRule[];
+};
+//#endregion
+export { type AnalysisRule, type AnalyzeOptions, type AnalyzerConfig, BasicWorld, type Diagnostic, type MatchedStep, type ParsedScenario, type ParsedStep, type StepDefinitionMeta, analyzer, givenBuilder, thenBuilder, whenBuilder };
+//# sourceMappingURL=step-forge.d.ts.map