testeranto 0.114.1 → 0.121.1

package/dist/types/Init.d.ts

@@ -1,2 +1,2 @@
-declare const _default: (partialConfig: any) => Promise<void>;
+declare const _default: () => Promise<void>;
 export default _default;

package/dist/types/PM/base.d.ts

@@ -0,0 +1,38 @@
+import { CdpPage } from "puppeteer-core/lib/esm/puppeteer";
+import fs from "fs";
+import { Browser } from "puppeteer-core";
+import { PassThrough } from "stream";
+import { IBuiltConfig, ITLog } from "../lib/index.js";
+import { PM } from "./index.js";
+export declare abstract class PM_Base extends PM {
+    browser: Browser;
+    configs: IBuiltConfig;
+    constructor(configs: IBuiltConfig);
+    customclose(): void;
+    waitForSelector(p: string, s: string): any;
+    closePage(p: any): any;
+    newPage(): CdpPage;
+    goto(p: any, url: string): any;
+    $(selector: string): boolean;
+    screencast(opts: object): void;
+    customScreenShot(opts: object, cdpPage?: CdpPage): void;
+    end(accessObject: {
+        uid: number;
+    }): boolean;
+    existsSync(destFolder: string): boolean;
+    mkdirSync(fp: string): Promise<string | false | undefined>;
+    writeFileSync(fp: string, contents: string): void;
+    createWriteStream(filepath: string): fs.WriteStream;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): (fPath: any, value: string | Buffer | PassThrough) => void;
+    write(accessObject: {
+        uid: number;
+    }, contents: string): boolean;
+    page(): string | undefined;
+    click(selector: string): string | undefined;
+    focusOn(selector: string): void;
+    typeInto(value: string): void;
+    getValue(value: string): void;
+    getAttribute(selector: string, attribute: string): void;
+    isDisabled(selector: string): Promise<boolean>;
+    screencastStop(s: string): void;
+}

package/dist/types/PM/main.d.ts

@@ -1,51 +1,24 @@
-import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
+import { Page } from "puppeteer-core/lib/esm/puppeteer";
 import fs from "fs";
-import { Browser } from "puppeteer-core";
-import { PassThrough } from "stream";
-import { IBuiltConfig, ITestTypes, ITLog } from "../lib/index.js";
+import { IBuiltConfig, IRunnables, ITestTypes } from "../lib/index.js";
 import { ISummary } from "../utils";
-import { PM } from "./index.js";
-export declare class PM_Main extends PM {
-    browser: Browser;
-    shutdownMode: boolean;
-    configs: IBuiltConfig;
+import { PM_Base } from "./base.js";
+export declare class PM_Main extends PM_Base {
+    name: string;
     ports: Record<number, boolean>;
     queue: any[];
-    mode: "DEV" | "PROD";
+    mode: "once" | "dev";
     bigBoard: ISummary;
     webMetafileWatcher: fs.FSWatcher;
     nodeMetafileWatcher: fs.FSWatcher;
-    constructor(configs: IBuiltConfig);
+    constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev");
+    start(): Promise<any>;
     stop: () => void;
-    customclose(): void;
-    waitForSelector(p: string, s: string): any;
-    closePage(p: any): any;
-    newPage(): CdpPage;
-    goto(p: any, url: string): any;
-    $(selector: string): boolean;
-    screencast(opts: object): void;
-    customScreenShot(opts: object, cdpPage?: CdpPage): void;
-    end(accessObject: {
-        uid: number;
-    }): boolean;
-    existsSync(destFolder: string): boolean;
-    mkdirSync(fp: string): Promise<string | false | undefined>;
-    writeFileSync(fp: string, contents: string): void;
-    createWriteStream(filepath: string): fs.WriteStream;
-    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): (fPath: any, value: string | Buffer | PassThrough) => void;
-    write(accessObject: {
-        uid: number;
-    }, contents: string): boolean;
-    page(): string | undefined;
-    click(selector: string): string | undefined;
-    focusOn(selector: string): void;
-    typeInto(value: string): void;
-    getValue(value: string): void;
-    getAttribute(selector: string, attribute: string): void;
-    isDisabled(selector: string): Promise<boolean>;
-    screencastStop(s: string): void;
+    getRunnables: (tests: ITestTypes[], payload?: {
+        nodeEntryPoints: {};
+        webEntryPoints: {};
+    }) => IRunnables;
     metafileOutputs(platform: "web" | "node"): Promise<void>;
-    start(): Promise<any>;
     tscCheck: ({ entrypoint, addableFiles, platform, }: {
         platform: "web" | "node";
         entrypoint: string;
@@ -54,13 +27,16 @@ export declare class PM_Main extends PM {
     eslintCheck: (entrypoint: string, platform: "web" | "node", addableFiles: string[]) => Promise<void>;
     makePrompt: (entryPoint: string, addableFiles: string[], platform: "web" | "node") => Promise<void>;
     checkForShutdown: () => void;
-    testIsNowRunning: (src: string) => void;
-    testIsNowDone: (src: string) => void;
+    typeCheckIsRunning: (src: string) => void;
+    typeCheckIsNowDone: (src: string, failures: number) => void;
+    lintIsRunning: (src: string) => void;
+    lintIsNowDone: (src: string, failures: number) => void;
+    bddTestIsRunning: (src: string) => void;
+    bddTestIsNowDone: (src: string, failures: number) => void;
     launchNode: (src: string, dest: string) => Promise<void>;
     launchWebSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<Page>;
     launchNodeSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<void>;
-    launchWeb: (t: string, dest: string) => void;
-    receiveFeatures: (features: string[], destFolder: string, srcTest: string) => void;
-    receiveExitCode: (srcTest: string, failures: number) => void;
+    launchWeb: (src: string, dest: string) => void;
+    receiveFeatures: (features: string[], destFolder: string, srcTest: string, platform: "node" | "web") => void;
     writeBigBoard: () => void;
 }

package/dist/types/esbuildConfigs/inputFilesPlugin.d.ts

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 import { PM } from "../PM/index.js";
-import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
 import { Ibdd_in, Ibdd_out } from "../Types.js";
+import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
 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>>> {
     name: string;
@@ -28,6 +28,7 @@ export declare abstract class BaseSuite<I extends Ibdd_in<unknown, unknown, unkn
             error: (string | Error | undefined)[] | null;
             features: string[];
         }[];
+        checks: any[];
         fails: BaseGiven<I>[];
         features: string[];
     };
@@ -84,27 +85,34 @@ export declare abstract class BaseWhen<I extends Ibdd_in<unknown, unknown, unkno
 export declare abstract class BaseThen<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> {
     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"]>;
+    abstract butThen(store: I["istore"], thenCB: (s: I["iselection"]) => I["isubject"], testResourceConfiguration: ITTestResourceConfiguration, pm: PM): Promise<I["iselection"]>;
     test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: PM, 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>>> {
+    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: PM) => any;
+    initialValues: any;
+    store: I["istore"];
+    checker: any;
+    constructor(name: string, features: string[], checker: (store: I["istore"], pm: PM) => any, x: any, checkCB: any);
+    abstract checkThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, initializer: any, initialValues: any, pm: PM): 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>;
+    afterEach(store: I["istore"], key: string, artifactory: ITestArtifactory, pm: PM): Promise<unknown>;
+    beforeAll(store: I["istore"], initializer: any, artifactory: any, testResource: any, initialValues: any, pm: any): I["istore"];
     check(subject: I["isubject"], key: string, testResourceConfiguration: any, tester: any, artifactory: ITestArtifactory, tLog: ITLog, pm: PM): Promise<void>;
 }

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

@@ -4,7 +4,6 @@ import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser
 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"];
     specs: any;
     assertThis: (t: I["then"]) => {};
     testResourceRequirement: ITTestResourceRequest;
@@ -23,5 +22,5 @@ export declare abstract class BaseBuilder<I extends Ibdd_in<unknown, unknown, un
     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: PM) => any, whens: any, thens: any, x: any) => BaseCheck<I, O>>;
 }

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

@@ -66,11 +66,8 @@ 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[];
@@ -80,4 +77,7 @@ export type IBaseConfig = {
 export type IBuiltConfig = {
     buildDir: string;
 } & IBaseConfig;
+export type IConfigV2 = {
+    projects: Record<string, IBaseConfig>;
+};
 export {};

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

@@ -1,11 +1,8 @@
+import { PM } from "../PM";
 import { Ibdd_in, Ibdd_out } from "../Types";
 import { IGivens, BaseCheck, BaseSuite, BaseGiven, BaseWhen, BaseThen } from "./abstractBase";
 export type ITestCheckCallback<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>>> = {
-    [K in keyof O["checks"]]: (name: string, features: string[], callbackA: (whens: {
-        [K in keyof O["whens"]]: (...unknown: any[]) => BaseWhen<I>;
-    }, thens: {
-        [K in keyof O["thens"]]: (...unknown: any[]) => BaseThen<I>;
-    }) => Promise<any>, ...xtrasA: O["checks"][K]) => BaseCheck<I, O>;
+    [K in keyof O["checks"]]: (name: string, features: string[], checkCallback: (store: I["istore"], pm: PM) => Promise<any>, ...xtrasA: O["checks"][K]) => BaseCheck<I, O>;
 };
 export type ISuiteKlasser<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>>> = (name: string, index: number, givens: IGivens<I>, checks: BaseCheck<I, O>[]) => BaseSuite<I, O>;
 export type IGivenKlasser<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = (name: any, features: any, whens: any, thens: any, givenCB: any) => BaseGiven<I>;