@step-forge/step-forge 0.0.6 → 0.0.7-beta

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/vite-env.d.ts.old

@@ -1 +0,0 @@
-/// <reference types="vite/client" />

package/src/when.js

@@ -1,34 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { isString, } from "./builderTypeUtils";
-import { addStep } from "./common";
-const whenDependencies = (statement, stepType) => (dependencies) => {
-    const fullDependencies = {
-        given: dependencies.given ?? {},
-        when: dependencies.when ?? {},
-        then: {},
-    };
-    return {
-        step: addStep(statement, stepType, fullDependencies),
-    };
-};
-const whenStatement = (stepType) => (statement) => {
-    let normalizedStatement;
-    if (isString(statement)) {
-        normalizedStatement = (() => statement);
-    }
-    else {
-        normalizedStatement = statement;
-    }
-    const dependencyFunc = whenDependencies(normalizedStatement, stepType);
-    const stepFunc = addStep(normalizedStatement, stepType);
-    return {
-        dependencies: dependencyFunc,
-        step: stepFunc,
-    };
-};
-export const whenBuilder = () => {
-    return {
-        statement: whenStatement("when"),
-    };
-};
-//# sourceMappingURL=when.js.map

package/src/when.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"when.js","sourceRoot":"","sources":["when.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAIL,QAAQ,GAGT,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAEnC,MAAM,gBAAgB,GACpB,CAOE,SAAoB,EACpB,QAA0B,EAC1B,EAAE,CACJ,CAGE,YAGD,EAAE,EAAE;IAoBH,MAAM,gBAAgB,GAAiB;QACrC,KAAK,EAAE,YAAY,CAAC,KAAK,IAAK,EAAgB;QAC9C,IAAI,EAAE,YAAY,CAAC,IAAI,IAAK,EAAe;QAC3C,IAAI,EAAE,EAAE;KACT,CAAC;IACF,OAAO;QACL,IAAI,EAAE,OAAO,CAWX,SAAS,EAAE,QAAQ,EAAE,gBAAgB,CAAC;KACzC,CAAC;AACJ,CAAC,CAAC;AAEJ,MAAM,aAAa,GACjB,CACE,QAA0B,EAC1B,EAAE,CACJ,CACE,SAAoB,EACpB,EAAE;IACF,IAAI,mBAES,CAAC;IACd,IAAI,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QACxB,mBAAmB,GAAG,CAAC,GAAG,EAAE,CAAC,SAAS,CAAQ,CAAC;IACjD,CAAC;SAAM,CAAC;QACN,mBAAmB,GAAG,SAAgB,CAAC;IACzC,CAAC;IAID,MAAM,cAAc,GAAG,gBAAgB,CAMrC,mBAAmB,EAAE,QAAQ,CAAC,CAAC;IACjC,MAAM,QAAQ,GAAG,OAAO,CAWtB,mBAAmB,EAAE,QAAQ,CAAC,CAAC;IACjC,OAAO;QACL,YAAY,EAAE,cAAc;QAC5B,IAAI,EAAE,QAAQ;KACf,CAAC;AACJ,CAAC,CAAC;AAEJ,MAAM,CAAC,MAAM,WAAW,GAAG,GAA0B,EAAE;IACrD,OAAO;QACL,SAAS,EAAE,aAAa,CAAgC,MAAM,CAAC;KAChE,CAAC;AACJ,CAAC,CAAC"}

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.js

@@ -1,51 +0,0 @@
-import _ from "lodash";
-function mergeCustomizer(objValue, srcValue) {
-    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 = (state) => {
-    return {
-        ...state,
-        merge: (newState) => {
-            state = _.merge({ ...state }, newState, mergeCustomizer);
-        },
-    };
-};
-export class BasicWorld {
-    givenState = {};
-    whenState = {};
-    thenState = {};
-    get given() {
-        return {
-            ...this.givenState,
-            merge: (newState) => {
-                this.givenState = _.merge({ ...this.givenState }, newState, mergeCustomizer);
-            },
-        };
-    }
-    get when() {
-        return {
-            ...this.whenState,
-            merge: (newState) => {
-                this.whenState = _.merge({ ...this.whenState }, newState, mergeCustomizer);
-            },
-        };
-    }
-    get then() {
-        return {
-            ...this.thenState,
-            merge: (newState) => {
-                this.thenState = _.merge({ ...this.thenState }, newState, mergeCustomizer);
-            },
-        };
-    }
-}
-export const createBasicWorld = () => {
-    return new BasicWorld();
-};
-//# sourceMappingURL=world.js.map

package/src/world.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"world.js","sourceRoot":"","sources":["world.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAUvB,SAAS,eAAe,CAAC,QAAiB,EAAE,QAAiB;IAC3D,IAAI,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QACxB,OAAO,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACnC,CAAC;SAAM,IAAI,QAAQ,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAC3E,MAAM,IAAI,KAAK,CACb,6CAA6C,QAAQ,SAAS,QAAQ,EAAE,CACzE,CAAC;IACJ,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,KAAoB,EACI,EAAE;IAC1B,OAAO;QACL,GAAG,KAAK;QACR,KAAK,EAAE,CAAC,QAAoB,EAAE,EAAE;YAC9B,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,EAAE,EAAE,QAAQ,EAAE,eAAe,CAAC,CAAC;QAC3D,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAQF,MAAM,OAAO,UAAU;IACb,UAAU,GAAsB,EAAE,CAAC;IACnC,SAAS,GAAqB,EAAE,CAAC;IACjC,SAAS,GAAqB,EAAE,CAAC;IAEzC,IAAW,KAAK;QACd,OAAO;YACL,GAAG,IAAI,CAAC,UAAU;YAClB,KAAK,EAAE,CAAC,QAAwB,EAAE,EAAE;gBAClC,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,KAAK,CACvB,EAAE,GAAG,IAAI,CAAC,UAAU,EAAE,EACtB,QAAQ,EACR,eAAe,CAChB,CAAC;YACJ,CAAC;SACF,CAAC;IACJ,CAAC;IAED,IAAW,IAAI;QACb,OAAO;YACL,GAAG,IAAI,CAAC,SAAS;YACjB,KAAK,EAAE,CAAC,QAAuB,EAAE,EAAE;gBACjC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,KAAK,CACtB,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE,EACrB,QAAQ,EACR,eAAe,CAChB,CAAC;YACJ,CAAC;SACF,CAAC;IACJ,CAAC;IAED,IAAW,IAAI;QACb,OAAO;YACL,GAAG,IAAI,CAAC,SAAS;YACjB,KAAK,EAAE,CAAC,QAAuB,EAAE,EAAE;gBACjC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,KAAK,CACtB,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE,EACrB,QAAQ,EACR,eAAe,CAChB,CAAC;YACJ,CAAC;SACF,CAAC;IACJ,CAAC;CACF;AAED,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAI9B,EAAE;IACF,OAAO,IAAI,UAAU,EAAqB,CAAC;AAC7C,CAAC,CAAC"}

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>();
-};

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;