testeranto 0.114.1 → 0.125.0

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

@@ -0,0 +1,88 @@
+import { Plugin } from "esbuild";
+import { ITTestResourceConfiguration } from "./lib/index.js";
+import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen, BaseGiven } from "./lib/abstractBase.js";
+import { IPM, ITestCheckCallback } from "./lib/types.js";
+import { PM } from "./PM/index.js";
+export type ITestInterface<I extends IT = IT> = {
+    assertThis: (x: I["then"]) => any;
+    andWhen: (store: I["istore"], whenCB: I["when"], testResource: ITTestResourceConfiguration, pm: IPM) => Promise<I["istore"]>;
+    butThen: (store: I["istore"], thenCB: I["then"], testResource: ITTestResourceConfiguration, pm: IPM) => Promise<I["iselection"]>;
+    afterAll: (store: I["istore"], pm: IPM) => any;
+    afterEach: (store: I["istore"], key: string, pm: IPM) => Promise<unknown>;
+    beforeAll: (input: I["iinput"], testResource: ITTestResourceConfiguration, pm: IPM) => Promise<I["isubject"]>;
+    beforeEach: (subject: I["isubject"], initializer: (c?: any) => I["given"], testResource: ITTestResourceConfiguration, initialValues: any, pm: IPM) => Promise<I["istore"]>;
+};
+export type IWebTestInterface<I extends IT> = ITestInterface<I>;
+export type INodeTestInterface<I extends IT> = ITestInterface<I>;
+export type IPartialInterface<I extends IT> = Partial<ITestInterface<I>>;
+export type IPartialNodeInterface<I extends IT> = Partial<INodeTestInterface<I>>;
+export type IPartialWebInterface<I extends IT> = Partial<IWebTestInterface<I>>;
+export type IT = Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>;
+export type OT = Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>;
+export type ITestSpecification<I extends IT, O extends OT> = (Suite: {
+    [K in keyof O["suites"]]: (name: string, givens: IGivens<I>, checks: BaseCheck<I>[]) => BaseSuite<I, O>;
+}, Given: {
+    [K in keyof O["givens"]]: (features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], ...xtrasB: O["givens"][K]) => BaseGiven<I>;
+}, When: {
+    [K in keyof O["whens"]]: (...xtrasC: O["whens"][K]) => BaseWhen<I>;
+}, Then: {
+    [K in keyof O["thens"]]: (...xtrasD: O["thens"][K]) => BaseThen<I>;
+}, Check: ITestCheckCallback<I, O>) => any[];
+export type ITestImplementation<I extends IT, O extends OT, modifier = {}> = Modify<{
+    suites: {
+        [K in keyof O["suites"]]: string;
+    };
+    givens: {
+        [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
+    };
+    whens: {
+        [K in keyof O["whens"]]: (...Iw: O["whens"][K]) => (zel: I["iselection"], utils: PM) => Promise<I["when"]>;
+    };
+    thens: {
+        [K in keyof O["thens"]]: (...It: O["thens"][K]) => (ssel: I["iselection"], utils: PM) => I["then"];
+    };
+    checks: {
+        [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
+    };
+}, modifier>;
+export type Modify<T, R> = Omit<T, keyof R> & R;
+export type Ibdd_out<ISuites extends Record<string, any> = Record<string, any>, IGivens extends Record<string, any> = Record<string, any>, IWhens extends Record<string, any> = Record<string, any>, IThens extends Record<string, any> = Record<string, any>, IChecks extends Record<string, any> = Record<string, any>> = {
+    suites: ISuites;
+    givens: IGivens;
+    whens: IWhens;
+    thens: IThens;
+    checks: IChecks;
+};
+export type Ibdd_in<IInput, ISubject, IStore, ISelection, IGiven, IWhen, IThen> = {
+    iinput: IInput;
+    isubject: ISubject;
+    istore: IStore;
+    iselection: ISelection;
+    given: IGiven;
+    when: IWhen;
+    then: IThen;
+};
+export type IPluginFactory = (register: (entrypoint: string, sources: string[]) => any, entrypoints: string[]) => Plugin;
+export type IRunTime = `node` | `web` | "pure";
+export type ITestTypes = [string, IRunTime, {
+    ports: number;
+}, ITestTypes[]];
+export type ITestconfig = {
+    clearScreen: boolean;
+    debugger: boolean;
+    externals: string[];
+    featureIngestor: (s: string) => Promise<string>;
+    importPlugins: IPluginFactory[];
+    minify: boolean;
+    nodePlugins: IPluginFactory[];
+    ports: string[];
+    src: string;
+    tests: ITestTypes[];
+    webPlugins: IPluginFactory[];
+};
+export type IBuiltConfig = {
+    buildDir: string;
+} & ITestconfig;
+export type IProject = {
+    projects: Record<string, ITestconfig>;
+};

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

@@ -0,0 +1,9 @@
+import type { IT, ITestImplementation, ITestInterface, ITestSpecification, IWebTestInterface, OT } 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> {
+    constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest, testInterface: Partial<ITestInterface<I>>);
+    receiveTestResourceConfig(partialTestResource: any): Promise<import("./lib/index.js").IFinalResults>;
+}
+declare const _default: <I extends IT, O extends OT, M>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testInterface: Partial<IWebTestInterface<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<I, O, M>>;
+export default _default;

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

@@ -0,0 +1,3 @@
+import { ITestconfig } from "./lib";
+declare const config: ITestconfig;
+export default config;

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

@@ -0,0 +1,4 @@
+import { BuildOptions } from "esbuild";
+import { ITestconfig } from "../lib";
+declare const _default: (config: ITestconfig) => BuildOptions;
+export default _default;

package/dist/types/{esbuildConfigs → src/esbuildConfigs}/inputFilesPlugin.d.ts

@@ -1,5 +1,6 @@
 import type { Plugin } from "esbuild";
-declare const _default: (platform: "web" | "node", entryPoints: Set<string> | string[]) => {
+import { IRunTime } from "../lib";
+declare const _default: (platform: IRunTime, testName: string) => {
     register: (entrypoint: string, sources: string[]) => void;
     inputFilesPluginFactory: Plugin;
 };

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

@@ -0,0 +1,4 @@
+import { BuildOptions } from "esbuild";
+import { ITestconfig } from "../lib/index.js";
+declare const _default: (config: ITestconfig, entryPoints: string[], testName: string) => BuildOptions;
+export default _default;

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

@@ -0,0 +1,4 @@
+import { BuildOptions } from "esbuild";
+import { ITestconfig } from "../lib/index.js";
+declare const _default: (config: ITestconfig, entryPoints: string[], testName: string) => BuildOptions;
+export default _default;

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

@@ -0,0 +1,4 @@
+import { BuildOptions } from "esbuild";
+import { ITestconfig } from "../lib/index.js";
+declare const _default: (config: ITestconfig, entryPoints: string[], testName: string) => BuildOptions;
+export default _default;

package/dist/types/src/examples/react/component/index.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+export type IProps = {
+    foo: string;
+    children: [];
+};
+export type IState = {
+    count: number;
+};
+export declare class ClassicalComponent extends React.Component<IProps, IState> {
+    constructor(props: any);
+    render(): JSX.Element;
+}
+export default ClassicalComponent;

package/dist/types/src/examples/react/component/test.d.ts

@@ -0,0 +1,17 @@
+import { ITestSpecification, IT } from "../../../Types";
+import { Ibdd_out } from "../../../Types";
+import { IProps, IState } from ".";
+export type O = Ibdd_out<{
+    Default: [string];
+}, {
+    AnEmptyState: [];
+}, {
+    IClickTheButton: [];
+    IClickTheHeader: [];
+}, {
+    ThePropsIs: [IProps];
+    TheStatusIs: [IState];
+}, {
+    AnEmptyState: any;
+}>;
+export declare const specification: ITestSpecification<IT, O>;

package/dist/types/{lib → src/lib}/abstractBase.d.ts

@@ -1,16 +1,17 @@
-import { PM } from "../PM/index.js";
+import { IT, OT } from "../Types.js";
 import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
-import { Ibdd_in, Ibdd_out } from "../Types.js";
-export type IGivens<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = Record<string, BaseGiven<I>>;
-export declare abstract class BaseSuite<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> {
+import { IPM } from "./types.js";
+export type IGivens<I extends IT> = Record<string, BaseGiven<I>>;
+export declare abstract class BaseSuite<I extends IT = IT, O extends OT = OT> {
     name: string;
     givens: IGivens<I>;
-    checks: BaseCheck<I, O>[];
+    checks: BaseCheck<I>[];
     store: I["istore"];
-    fails: BaseGiven<I>[];
     testResourceConfiguration: ITTestResourceConfiguration;
     index: number;
-    constructor(name: string, index: number, givens?: IGivens<I>, checks?: BaseCheck<I, O>[]);
+    failed: boolean;
+    fails: number;
+    constructor(name: string, index: number, givens?: IGivens<I>, checks?: BaseCheck<I>[]);
     features(): string[];
     toObj(): {
         name: string;
@@ -26,17 +27,20 @@ export declare abstract class BaseSuite<I extends Ibdd_in<unknown, unknown, unkn
                 error: boolean;
             }[];
             error: (string | Error | undefined)[] | null;
+            failed: boolean;
             features: string[];
         }[];
-        fails: BaseGiven<I>[];
+        checks: any[];
+        fails: number;
+        failed: boolean;
         features: string[];
     };
-    setup(s: I["iinput"], artifactory: ITestArtifactory, tr: ITTestResourceConfiguration, pm: PM): Promise<I["isubject"]>;
-    assertThat(t: I["then"]): unknown;
-    afterAll(store: I["istore"], artifactory: ITestArtifactory, pm: PM): I["istore"];
-    run(input: I["iinput"], testResourceConfiguration: ITTestResourceConfiguration, artifactory: (fPath: string, value: unknown) => void, tLog: (...string: any[]) => void, pm: PM): Promise<BaseSuite<I, O>>;
+    setup(s: I["iinput"], artifactory: ITestArtifactory, tr: ITTestResourceConfiguration, pm: IPM): Promise<I["isubject"]>;
+    assertThat(t: Awaited<I["then"]> | undefined): boolean;
+    afterAll(store: I["istore"], artifactory: ITestArtifactory, pm: IPM): I["istore"];
+    run(input: I["iinput"], testResourceConfiguration: ITTestResourceConfiguration, artifactory: (fPath: string, value: unknown) => void, tLog: (...string: any[]) => void, pm: IPM): Promise<BaseSuite<I, O>>;
 }
-export declare abstract class BaseGiven<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> {
+export declare abstract class BaseGiven<I extends IT = IT> {
     name: string;
     features: string[];
     whens: BaseWhen<I>[];
@@ -48,8 +52,9 @@ export declare abstract class BaseGiven<I extends Ibdd_in<unknown, unknown, unkn
     givenCB: I["given"];
     initialValues: any;
     key: string;
+    failed: boolean;
     constructor(name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], givenCB: I["given"], initialValues: any);
-    beforeAll(store: I["istore"], initializer: any, artifactory: any, testResource: any, initialValues: any, pm: any): I["istore"];
+    beforeAll(store: I["istore"]): I["istore"];
     toObj(): {
         key: string;
         name: string;
@@ -62,49 +67,57 @@ export declare abstract class BaseGiven<I extends Ibdd_in<unknown, unknown, unkn
             error: boolean;
         }[];
         error: (string | Error | undefined)[] | null;
+        failed: boolean;
         features: string[];
     };
-    abstract givenThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: I["given"], initialValues: any, pm: PM): Promise<I["istore"]>;
-    afterEach(store: I["istore"], key: string, artifactory: ITestArtifactory, pm: PM): Promise<unknown>;
+    abstract givenThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: I["given"], initialValues: any, pm: IPM): Promise<I["istore"]>;
+    afterEach(store: I["istore"], key: string, artifactory: ITestArtifactory, pm: IPM): Promise<unknown>;
     abstract uberCatcher(e: any): any;
-    give(subject: I["isubject"], key: string, testResourceConfiguration: ITTestResourceConfiguration, tester: (t: Awaited<I["then"]> | undefined) => boolean, artifactory: ITestArtifactory, tLog: ITLog, pm: PM, suiteNdx: number): Promise<I["istore"]>;
+    give(subject: I["isubject"], key: string, testResourceConfiguration: ITTestResourceConfiguration, tester: (t: Awaited<I["then"]> | undefined) => boolean, artifactory: ITestArtifactory, tLog: ITLog, pm: IPM, suiteNdx: number): Promise<I["istore"]>;
 }
-export declare abstract class BaseWhen<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> {
+export declare abstract class BaseWhen<I extends IT> {
     name: string;
     whenCB: (x: I["iselection"]) => I["then"];
     error: boolean;
     constructor(name: string, whenCB: (xyz: I["iselection"]) => I["then"]);
-    abstract andWhen(store: I["istore"], whenCB: (x: I["iselection"]) => I["then"], testResource: any, pm: PM): Promise<any>;
+    abstract andWhen(store: I["istore"], whenCB: (x: I["iselection"]) => I["then"], testResource: any, pm: IPM): Promise<any>;
     toObj(): {
         name: string;
         error: boolean;
     };
-    test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: PM, filepath: string): Promise<any>;
+    test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: IPM, filepath: string): Promise<any>;
 }
-export declare abstract class BaseThen<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> {
+export declare abstract class BaseThen<I extends IT> {
     name: string;
     thenCB: (storeState: I["iselection"]) => I["then"];
+    go: (storeState: I["iselection"]) => I["then"];
     error: boolean;
     constructor(name: string, thenCB: (val: I["iselection"]) => I["then"]);
     toObj(): {
         name: string;
         error: boolean;
     };
-    abstract butThen(store: I["istore"], thenCB: any, testResourceConfiguration: ITTestResourceConfiguration, pm: PM): Promise<I["iselection"]>;
-    test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: PM, filepath: string): Promise<I["then"] | undefined>;
+    abstract butThen(store: I["istore"], thenCB: (s: I["iselection"]) => I["isubject"], testResourceConfiguration: ITTestResourceConfiguration, pm: IPM, ...args: any[]): Promise<I["iselection"]>;
+    test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: IPM, filepath: string): Promise<I["then"] | undefined>;
+    check(): void;
 }
-export declare abstract class BaseCheck<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> {
+export declare abstract class BaseCheck<I extends IT = IT> {
+    key: string;
     name: string;
     features: string[];
-    checkCB: (whens: any, thens: any) => any;
-    whens: {
-        [K in keyof O["whens"]]: (p: any, tc: any) => BaseWhen<I>;
-    };
-    thens: {
-        [K in keyof O["thens"]]: (p: any, tc: any) => BaseThen<I>;
+    checkCB: (store: I["istore"], pm: IPM) => any;
+    initialValues: any;
+    store: I["istore"];
+    checker: any;
+    constructor(name: string, features: string[], checker: (store: I["istore"], pm: IPM) => any, x: any, checkCB: any);
+    abstract checkThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, initializer: any, initialValues: any, pm: IPM): Promise<I["istore"]>;
+    toObj(): {
+        key: string;
+        name: string;
+        functionAsString: string;
+        features: string[];
     };
-    constructor(name: string, features: string[], checkCB: (whens: any, thens: any) => any, whens: any, thens: any);
-    abstract checkThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, pm: PM): Promise<I["istore"]>;
-    afterEach(store: I["istore"], key: string, cb: any, pm: PM): Promise<unknown>;
-    check(subject: I["isubject"], key: string, testResourceConfiguration: any, tester: any, artifactory: ITestArtifactory, tLog: ITLog, pm: PM): Promise<void>;
+    afterEach(store: I["istore"], key: string, artifactory: ITestArtifactory, pm: IPM): Promise<unknown>;
+    beforeAll(store: I["istore"]): I["istore"];
+    check(subject: I["isubject"], key: string, testResourceConfiguration: any, tester: any, artifactory: ITestArtifactory, tLog: ITLog, pm: IPM): Promise<void>;
 }

package/dist/types/{lib → src/lib}/basebuilder.d.ts

@@ -1,10 +1,8 @@
+import { IT, ITestSpecification, OT } from "../Types.js";
 import { ITTestResourceRequest, ITestJob } from ".";
-import { Ibdd_in, Ibdd_out, ITestSpecification } from "../Types.js";
-import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser } from "./types.js";
+import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser, IPM } from "./types.js";
 import { BaseCheck, BaseWhen, BaseThen, BaseGiven } from "./abstractBase.js";
-import { PM } from "../PM/index.js";
-export declare abstract class BaseBuilder<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions> {
-    readonly input: I["iinput"];
+export declare abstract class BaseBuilder<I extends IT, O extends OT, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions> {
     specs: any;
     assertThis: (t: I["then"]) => {};
     testResourceRequirement: ITTestResourceRequest;
@@ -15,13 +13,13 @@ export declare abstract class BaseBuilder<I extends Ibdd_in<unknown, unknown, un
     givenOverides: Record<keyof GivenExtensions, IGivenKlasser<I>>;
     whenOverides: Record<keyof WhenExtensions, IWhenKlasser<I>>;
     thenOverides: Record<keyof ThenExtensions, IThenKlasser<I>>;
-    checkOverides: Record<keyof CheckExtensions, ICheckKlasser<I, O>>;
-    puppetMaster: PM;
-    constructor(input: I["iinput"], suitesOverrides: Record<keyof SuiteExtensions, ISuiteKlasser<I, O>>, givenOverides: Record<keyof GivenExtensions, IGivenKlasser<I>>, whenOverides: Record<keyof WhenExtensions, IWhenKlasser<I>>, thenOverides: Record<keyof ThenExtensions, IThenKlasser<I>>, checkOverides: Record<keyof CheckExtensions, ICheckKlasser<I, O>>, testResourceRequirement: ITTestResourceRequest, testSpecification: any);
+    checkOverides: Record<keyof CheckExtensions, ICheckKlasser<I>>;
+    puppetMaster: IPM;
+    constructor(input: I["iinput"], suitesOverrides: Record<keyof SuiteExtensions, ISuiteKlasser<I, O>>, givenOverides: Record<keyof GivenExtensions, IGivenKlasser<I>>, whenOverides: Record<keyof WhenExtensions, IWhenKlasser<I>>, thenOverides: Record<keyof ThenExtensions, IThenKlasser<I>>, checkOverides: Record<keyof CheckExtensions, ICheckKlasser<I>>, testResourceRequirement: ITTestResourceRequest, testSpecification: any);
     Specs(): any;
     Suites(): Record<keyof SuiteExtensions, ISuiteKlasser<I, O>>;
     Given(): Record<keyof GivenExtensions, (name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], gcb: any) => BaseGiven<I>>;
     When(): Record<keyof WhenExtensions, (arg0: I["istore"], ...arg1: any) => BaseWhen<I>>;
     Then(): Record<keyof ThenExtensions, (selection: I["iselection"], expectation: any) => BaseThen<I>>;
-    Check(): Record<keyof CheckExtensions, (feature: string, callback: (whens: any, thens: any) => any, whens: any, thens: any, x: any) => BaseCheck<I, O>>;
+    Check(): Record<keyof CheckExtensions, (feature: string, callback: (whens: any, thens: any, pm: IPM) => any, whens: any, thens: any, x: any) => BaseCheck<I>>;
 }

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

@@ -0,0 +1,9 @@
+import { IT, ITestImplementation, ITestSpecification, OT } from "../Types.js";
+import { BaseBuilder } from "./basebuilder.js";
+import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser } from "./types.js";
+import { ITTestResourceRequest } from "./index.js";
+type IExtenstions = Record<string, unknown>;
+export declare abstract class ClassBuilder<I extends IT = IT, O extends OT = OT, M = unknown> extends BaseBuilder<I, O, IExtenstions, IExtenstions, IExtenstions, IExtenstions, IExtenstions> {
+    constructor(testImplementation: ITestImplementation<I, O, M>, testSpecification: ITestSpecification<I, O>, input: I["iinput"], suiteKlasser: ISuiteKlasser<I, O>, givenKlasser: IGivenKlasser<I>, whenKlasser: IWhenKlasser<I>, thenKlasser: IThenKlasser<I>, checkKlasser: ICheckKlasser<I>, testResourceRequirement: ITTestResourceRequest);
+}
+export {};

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

@@ -0,0 +1,7 @@
+import { ITestSpecification, ITestImplementation, ITestInterface, IT, OT } from "../Types.js";
+import { IFinalResults, ITTestResourceRequest } from "./index.js";
+import { ClassBuilder } from "./classBuilder.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>, testResourceRequirement: ITTestResourceRequest | undefined, testInterface: Partial<ITestInterface<I>>, uberCatcher: (cb: () => void) => void);
+    abstract receiveTestResourceConfig(partialTestResource: string): Promise<IFinalResults>;
+}

package/dist/types/{lib → src/lib}/index.d.ts

@@ -1,5 +1,7 @@
-import { PM } from "../PM/index.js";
-import { Ibdd_in, Ibdd_out, ITestInterface } from "../Types.js";
+import { PM_Pure } from "../PM/pure.js";
+import { PM_Node } from "../PM/node.js";
+import { PM_Web } from "../PM/web.js";
+import { Ibdd_in, ITestInterface, ITestconfig, IBuiltConfig, IRunTime, ITestTypes, IT, OT } from "../Types.js";
 import { IGivens, BaseCheck, BaseSuite } from "./abstractBase.js";
 export declare const BaseTestInterface: ITestInterface<Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>>;
 export declare const DefaultTestInterface: (p: Partial<ITestInterface<any>>) => ITestInterface<any>;
@@ -29,55 +31,31 @@ type ITest = {
     toObj(): object;
     name: string;
     givens: IGivens<Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>>;
-    checks: BaseCheck<Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>[];
+    checks: BaseCheck<IT>[];
     testResourceConfiguration: ITTestResourceConfiguration;
 };
-export type ITestJob<T = PM> = {
+export type ITestJob = {
     toObj(): object;
     test: ITest;
-    runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<BaseSuite<Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>>;
+    runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<BaseSuite<IT, OT>>;
     testResourceRequirement: ITTestResourceRequirement;
-    receiveTestResourceConfig: (pm: PM) => Promise<{
-        failed: number;
-        artifacts: Promise<unknown>[];
-        logPromise: Promise<unknown>;
-        features: string[];
-    }>;
+    receiveTestResourceConfig: (pm: PM_Node | PM_Web | PM_Pure) => IFinalResults;
 };
 export type ITestResults = Promise<{
     test: ITest;
 }>[];
 export declare const defaultTestResourceRequirement: ITTestResourceRequest;
 export type ITestArtifactory = (key: string, value: unknown) => unknown;
+export type { ITestconfig, IBuiltConfig, IRunTime, ITestTypes };
 export type IRunnables = {
     nodeEntryPoints: Record<string, string>;
     webEntryPoints: Record<string, string>;
+    importEntryPoints: Record<string, string>;
 };
 export type IFinalResults = {
     features: string[];
-    failed: number;
+    failed: boolean;
+    fails: number;
+    artifacts: Promise<unknown>[];
+    logPromise: Promise<unknown>;
 };
-export type IRunTime = `node` | `web`;
-export type ITestTypes = [string, IRunTime, {
-    ports: number;
-}, ITestTypes[]];
-export type IPluginFactory = (register: (entrypoint: any, sources: any) => any, entrypoints: any) => Plugin;
-export type IBaseConfig = {
-    src: string;
-    clearScreen: boolean;
-    debugger: boolean;
-    devMode: boolean;
-    externals: string[];
-    minify: boolean;
-    outbase: string;
-    outdir: string;
-    ports: string[];
-    tests: ITestTypes[];
-    nodePlugins: IPluginFactory[];
-    webPlugins: IPluginFactory[];
-    featureIngestor: (s: string) => Promise<string>;
-};
-export type IBuiltConfig = {
-    buildDir: string;
-} & IBaseConfig;
-export {};

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

@@ -0,0 +1,15 @@
+import { PM } from "../PM";
+import { PM_Node } from "../PM/node";
+import { PM_Pure } from "../PM/pure";
+import { PM_Web } from "../PM/web";
+import { IT, OT } from "../Types";
+import { IGivens, BaseCheck, BaseSuite, BaseGiven, BaseWhen, BaseThen } from "./abstractBase";
+export type IPM = PM_Node | PM_Web | PM_Pure;
+export type ITestCheckCallback<I extends IT, O extends OT> = {
+    [K in keyof O["checks"]]: (name: string, features: string[], checkCallback: (store: I["istore"], pm: PM) => Promise<any>, ...xtrasA: O["checks"][K]) => BaseCheck<I>;
+};
+export type ISuiteKlasser<I extends IT, O extends OT> = (name: string, index: number, givens: IGivens<I>, checks: BaseCheck<I>[]) => BaseSuite<I, O>;
+export type IGivenKlasser<I extends IT> = (name: any, features: any, whens: any, thens: any, givenCB: any) => BaseGiven<I>;
+export type IWhenKlasser<I extends IT> = (s: any, o: any) => BaseWhen<I>;
+export type IThenKlasser<I extends IT> = (s: any, o: any) => BaseThen<I>;
+export type ICheckKlasser<I extends IT> = (n: any, f: any, cb: any, w: any, t: any) => BaseCheck<I>;

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

@@ -0,0 +1,18 @@
+import { IBuiltConfig, IRunTime, ITestTypes } from "./Types";
+import { IRunnables } from "./lib";
+export type ISummary = Record<string, {
+    runTimeError?: number | "?";
+    typeErrors?: number | "?";
+    staticErrors?: number | "?";
+    prompt?: string | "?";
+}>;
+export declare const destinationOfRuntime: (f: string, r: IRunTime, configs: IBuiltConfig) => string;
+export declare const tscPather: (entryPoint: string, platform: IRunTime, projectName: string) => string;
+export declare const lintPather: (entryPoint: string, platform: IRunTime, projectName: string) => string;
+export declare const bddPather: (entryPoint: string, platform: IRunTime, projectName: string) => string;
+export declare const promptPather: (entryPoint: string, platform: IRunTime, projectName: string) => string;
+export declare const getRunnables: (tests: ITestTypes[], projectName: string, payload?: {
+    nodeEntryPoints: {};
+    webEntryPoints: {};
+    importEntryPoints: {};
+}) => IRunnables;

package/dist/types/testeranto.config.d.ts

@@ -0,0 +1,3 @@
+import { IProject } from "./src/Types";
+declare const config: IProject;
+export default config;