testeranto 0.134.0 → 0.135.0

package/dist/types/src/PM/__tests__/pureSidecar.testeranto.d.ts

@@ -1,20 +1,2 @@
-import { PM_Pure_Sidecar } from "../pureSidecar";
-import { Ibdd_out, Ibdd_in } from "../../Types";
-type I = Ibdd_in<PM_Pure_Sidecar, PM_Pure_Sidecar, unknown, unknown, unknown, unknown, unknown>;
-type O = Ibdd_out<{
-    SidecarInitialized: [null];
-}, {
-    SidecarReady: [];
-}, {
-    SendTestMessage: [string];
-    VerifyCleanup: [];
-}, {
-    MessageReceived: [string];
-    ListenersCleaned: [];
-}, {
-    SidecarState: unknown;
-}>;
-declare const _default: Promise<import("../../lib/core").default<IT, O, {
-    whens: import("../../Types").TestWhenImplementation<I, O>;
-}>>;
+declare const _default: Promise<import("../../lib/core").default<IT, OT, any>>;
 export default _default;

package/dist/types/src/PM/__tests__/webSidecar.testeranto.d.ts

@@ -1,20 +1,2 @@
-import { PM_Web_Sidecar } from "../webSidecar";
-import { Ibdd_out, Ibdd_in } from "../../Types";
-type I = Ibdd_in<PM_Web_Sidecar, PM_Web_Sidecar, unknown, unknown, unknown, unknown, unknown>;
-type O = Ibdd_out<{
-    SidecarInitialized: [null];
-}, {
-    SidecarReady: [];
-}, {
-    SendTestMessage: [string];
-    VerifyCleanup: [];
-}, {
-    MessageReceived: [string];
-    ListenersCleaned: [];
-}, {
-    SidecarState: unknown;
-}>;
-declare const _default: Promise<import("../../lib/core").default<IT, O, {
-    whens: import("../../Types").TestWhenImplementation<I, O>;
-}>>;
+declare const _default: Promise<import("../../lib/core").default<IT, OT, any>>;
 export default _default;

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

@@ -29,7 +29,7 @@ export declare abstract class PM {
     abstract typeInto(selector: string, value: string): any;
     abstract waitForSelector(p: any, sel: string): any;
     abstract write(uid: number, contents: string): Promise<boolean>;
-    abstract writeFileSync(f: string, c: string, t: string): Promise<boolean>;
+    abstract writeFileSync(f: string, c: string): Promise<boolean>;
     abstract launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]>;
     abstract stopSideCar(n: number): Promise<any>;
 }

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

@@ -1,9 +1,11 @@
 import { Plugin } from "esbuild";
 import { ITTestResourceConfiguration } from "./lib/index.js";
 import { PM } from "./PM/index.js";
-import { IT, OT } from "../dist/types/src/Types.js";
-import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen, BaseGiven } from "./lib/abstractBase.js";
-import { ITestCheckCallback } from "./lib/types.js";
+import { BaseWhen, BaseThen, BaseGiven, BaseCheck, BaseSuite, IGivens } from "./lib/abstractBase.js";
+import { Ibdd_in, Ibdd_out } from "./CoreTypes.js";
+export type SuiteSpecification<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
+    [K in keyof O["suites"]]: (name: string, givens: IGivens<I>, checks: BaseCheck<I>[]) => BaseSuite<I, O>;
+};
 export type TestSummary = {
     testName: string;
     errors?: {
@@ -49,82 +51,36 @@ export type ProjectConfig = {
     minify?: boolean;
     debug?: boolean;
 };
-export type SuiteSpecification<I extends IT, O extends OT> = {
-    [K in keyof O["suites"]]: (name: string, givens: IGivens<I>, checks: BaseCheck<I>[]) => BaseSuite<I, O>;
-};
-export type GivenSpecification<I extends IT, O extends OT> = {
+export type GivenSpecification<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
     [K in keyof O["givens"]]: (features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], ...xtrasB: O["givens"][K]) => BaseGiven<I>;
 };
-export type WhenSpecification<I extends IT, O extends OT> = {
+export type WhenSpecification<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
     [K in keyof O["whens"]]: (...xtrasC: O["whens"][K]) => BaseWhen<I>;
 };
-export type ThenSpecification<I extends IT, O extends OT> = {
+export type ThenSpecification<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
     [K in keyof O["thens"]]: (...xtrasD: O["thens"][K]) => BaseThen<I>;
 };
-export type ITestSpecification<I extends IT, O extends OT> = (Suite: SuiteSpecification<I, O>, Given: GivenSpecification<I, O>, When: WhenSpecification<I, O>, Then: ThenSpecification<I, O>, Check: ITestCheckCallback<I, O>) => any[];
-export type TestSuiteImplementation<O extends OT> = {
+export type TestSuiteImplementation<O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
     [K in keyof O["suites"]]: string;
 };
-export type TestGivenImplementation<I extends IT, O extends OT> = {
+export type TestGivenImplementation<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
     [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
 };
-export type TestWhenImplementation<I extends IT, O extends OT> = {
+export type TestWhenImplementation<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
     [K in keyof O["whens"]]: (...Iw: O["whens"][K]) => (zel: I["iselection"], tr: ITTestResourceConfiguration, utils: PM) => Promise<I["when"]>;
 };
-export type TestThenImplementation<I extends IT, O extends OT> = {
+export type TestThenImplementation<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
     [K in keyof O["thens"]]: (...It: O["thens"][K]) => (ssel: I["iselection"], utils: PM) => I["then"];
 };
-export type TestCheckImplementation<I extends IT, O extends OT> = {
+export type TestCheckImplementation<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
     [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
 };
-export type ITestImplementation<I extends IT, O extends OT, modifier = {
-    whens: TestWhenImplementation<I, O>;
-}> = Modify<{
-    suites: TestSuiteImplementation<O>;
-    givens: TestGivenImplementation<I, O>;
-    whens: TestWhenImplementation<I, O>;
-    thens: TestThenImplementation<I, O>;
-    checks: TestCheckImplementation<I, O>;
-}, modifier>;
 export type Modify<T, R> = Omit<T, keyof R> & R;
 export type TestSuiteShape = Record<string, any>;
 export type TestGivenShape = Record<string, any>;
 export type TestWhenShape = Record<string, any>;
 export type TestThenShape = Record<string, any>;
 export type TestCheckShape = Record<string, any>;
-export type Ibdd_out<ISuites extends TestSuiteShape = TestSuiteShape, IGivens extends TestGivenShape = TestGivenShape, IWhens extends TestWhenShape = TestWhenShape, IThens extends TestThenShape = TestThenShape, IChecks extends TestCheckShape = TestCheckShape> = {
-    suites: ISuites;
-    givens: IGivens;
-    whens: IWhens;
-    thens: IThens;
-    checks: IChecks;
-};
-/**
- * Defines the input shape for BDD test definitions.
- * This is the core type that structures all test operations.
- */
-export type Ibdd_in<IInput, // Type of initial test input
-ISubject, // Type of object being tested
-IStore, // Type for storing test state between steps
-ISelection, // Type for selecting state for assertions
-IGiven, // Type for Given step functions
-IWhen, // Type for When step functions
-IThen> = {
-    /** Initial input required to start tests */
-    iinput: IInput;
-    /** The subject being tested (class, function, etc) */
-    isubject: ISubject;
-    /** Complete test state storage */
-    istore: IStore;
-    /** Selected portion of state for assertions */
-    iselection: ISelection;
-    /** Function type for Given steps */
-    given: IGiven;
-    /** Function type for When steps */
-    when: IWhen;
-    /** Function type for Then steps */
-    then: IThen;
-};
 export type IPluginFactory = (register?: (entrypoint: string, sources: string[]) => any, entrypoints?: string[]) => Plugin;
 export type IRunTime = `node` | `web` | "pure" | `spawn`;
 export type ITestTypes = [string, IRunTime, {

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

@@ -1,4 +1,4 @@
-import type { IT, ITestImplementation, ITestInterface, ITestSpecification, IWebTestInterface, OT } from "./Types";
+import type { ITestImplementation, ITestInterface, ITestSpecification } from "./Types";
 import Testeranto from "./lib/core.js";
 import { ITTestResourceRequest } from "./lib/index.js";
 export declare class WebTesteranto<I extends IT, O extends OT, M> extends Testeranto<I, O, M> {

package/dist/types/src/esbuildConfigs/rebuildPlugin.d.ts

@@ -0,0 +1,6 @@
+import { IRunTime } from "../lib";
+declare const _default: (r: IRunTime) => {
+    name: string;
+    setup: (build: any) => void;
+};
+export default _default;

package/dist/types/src/lib/abstractBase.d.ts

@@ -18,10 +18,7 @@ export declare abstract class BaseSuite<I extends IT = IT, O extends OT = OT> {
         givens: {
             key: string;
             name: string;
-            whens: {
-                name: string;
-                error: string;
-            }[];
+            whens: {}[];
             thens: {
                 name: string;
                 error: boolean;
@@ -58,10 +55,7 @@ export declare abstract class BaseGiven<I extends IT = IT> {
     toObj(): {
         key: string;
         name: string;
-        whens: {
-            name: string;
-            error: string;
-        }[];
+        whens: {}[];
         thens: {
             name: string;
             error: boolean;

package/dist/types/src/lib/core.d.ts

@@ -1,6 +1,6 @@
-import { ITestSpecification, ITestImplementation, ITestInterface, IT, OT } from "../Types.js";
 import { IFinalResults, ITTestResourceRequest } from "./index.js";
 import { ClassBuilder } from "./classBuilder.js";
+import { ITestSpecification, ITestImplementation, ITestInterface } from "../CoreTypes.js";
 export default abstract class Testeranto<I extends IT, O extends OT, M> extends ClassBuilder<I, O, M> {
     constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M> & {
         suites: Record<string, any>;

package/dist/types/src/mothership/test.d.ts

@@ -1,21 +1,2 @@
-import { Ibdd_out, Ibdd_in } from "../Types";
-import type { Express } from "express";
-type I = Ibdd_in<(port: number) => Express, (port: number) => Express, any, any, any, any, any>;
-type O = Ibdd_out<{
-    TheMothership: [null];
-}, {
-    ItIsRunning: [];
-}, {
-    IClaimTheResource: [string];
-    IReleaseTheResource: [string];
-    IResetTheResource: [string];
-}, {
-    TheResourceIsClaimed: [string];
-    TheResourceIsUnClaimed: [string];
-}, {
-    AnEmptyState: any;
-}>;
-declare const _default: Promise<import("../lib/core").default<IT, O, {
-    whens: import("../Types").TestWhenImplementation<I, O>;
-}>>;
+declare const _default: Promise<import("../lib/core").default<IT, OT, any>>;
 export default _default;