testeranto 0.79.6 → 0.79.7

package/dist/types/Features.d.ts

@@ -0,0 +1,68 @@
+import Graph from "graphology/dist/graphology.umd.js";
+declare const DirectedGraph: any;
+declare abstract class TesterantoGraph {
+    name: string;
+    abstract graph: any;
+    constructor(name: string);
+}
+export declare class BaseFeature {
+    name: string;
+    constructor(name: string);
+}
+export declare class TesterantoGraphUndirected implements TesterantoGraph {
+    name: string;
+    graph: Graph;
+    constructor(name: string);
+    connect(a: any, b: any, relation?: string): void;
+}
+export declare class TesterantoGraphDirected implements TesterantoGraph {
+    name: string;
+    graph: Graph;
+    constructor(name: string);
+    connect(to: any, from: any, relation?: string): void;
+}
+export declare class TesterantoGraphDirectedAcyclic implements TesterantoGraph {
+    name: string;
+    graph: Graph;
+    constructor(name: string);
+    connect(to: any, from: any, relation?: string): void;
+}
+export declare class TesterantoFeatures {
+    features: Record<string, BaseFeature>;
+    graphs: {
+        undirected: TesterantoGraphUndirected[];
+        directed: TesterantoGraphDirected[];
+        dags: TesterantoGraphDirectedAcyclic[];
+    };
+    constructor(features: Record<string, BaseFeature>, graphs: {
+        undirected: TesterantoGraphUndirected[];
+        directed: TesterantoGraphDirected[];
+        dags: TesterantoGraphDirectedAcyclic[];
+    });
+    networks(): (TesterantoGraphUndirected | TesterantoGraphDirected | TesterantoGraphDirectedAcyclic)[];
+    toObj(): {
+        features: {
+            inNetworks: {
+                network: string;
+                neighbors: any;
+            }[];
+            name: string;
+        }[];
+        networks: ({
+            name: string;
+            graph: Graph;
+        } | {
+            name: string;
+            graph: Graph;
+        } | {
+            name: string;
+            graph: Graph;
+        })[];
+    };
+}
+export declare type IT_FeatureNetwork = {
+    name: string;
+};
+export { DirectedGraph };
+declare const _default: {};
+export default _default;

package/dist/types/Node.d.ts

@@ -0,0 +1,6 @@
+import Testeranto from "./lib/core.js";
+import { ITTestResourceRequest } from "./lib/index.js";
+import type { IBaseTest, ITestImplementation, ITestSpecification } from "./Types.js";
+import { INodeTestInterface } from "./lib/types.js";
+declare const _default: <ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape, object>, testInterface: Partial<INodeTestInterface<ITestShape>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
+export default _default;

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

@@ -0,0 +1,20 @@
+import { Browser, Page } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+export declare abstract class PM {
+    server: any;
+    browser: Browser;
+    testResourceConfiguration: ITTestResourceConfiguration;
+    abstract startPuppeteer(options: any, destfolder: string): Promise<Browser>;
+    abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): any;
+    abstract createWriteStream(filepath: string): any;
+    abstract writeFileSync(fp: string, contents: string): any;
+    abstract mkdirSync(): any;
+    abstract existsSync(fp: string): boolean;
+    abstract write(accessObject: {
+        uid: number;
+    }, contents: string): boolean;
+    abstract end(accessObject: {
+        uid: number;
+    }): boolean;
+    abstract customScreenShot(opts: object, page: Page): any;
+}

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

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import fs from "fs";
+import { PassThrough } from "stream";
+import { IBuiltConfig, ITestTypes } from "../lib/types";
+import { PM } from "./index.js";
+import { ITLog } from "../lib/index.js";
+export declare class PM_Main extends PM {
+    customScreenShot(opts: object): void;
+    configs: IBuiltConfig;
+    ports: Record<number, boolean>;
+    queue: any[];
+    constructor(configs: IBuiltConfig);
+    startPuppeteer(options: any, destfolder: string): Promise<any>;
+    launchNode: (src: string, dest: string) => Promise<void>;
+    launchWebSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<unknown>;
+    launchNodeSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<void>;
+    launchWeb: (t: string, dest: string, sidecars: ITestTypes[]) => 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;
+}

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

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { PassThrough } from "stream";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+import { PM } from "./index.js";
+import { Page } from "puppeteer-core/lib/esm/puppeteer";
+declare type PuppetMasterServer = Record<string, Promise<any>>;
+export declare class PM_Node extends PM {
+    server: PuppetMasterServer;
+    testResourceConfiguration: ITTestResourceConfiguration;
+    constructor(t: ITTestResourceConfiguration);
+    customScreenShot(opts: object, page: Page): any;
+    existsSync(destFolder: string): boolean;
+    mkdirSync(): any;
+    write(writeObject: {
+        uid: number;
+    }, contents: string): any;
+    writeFileSync(filepath: string, contents: string): any;
+    createWriteStream(filepath: string): any;
+    end(writeObject: {
+        uid: number;
+    }): any;
+    customclose(): void;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): (fPath: any, value: string | Buffer | PassThrough) => void;
+    startPuppeteer(options?: any): Promise<any>;
+}
+export {};

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

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { PassThrough } from "stream";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+import { PM } from "./index.js";
+declare type PuppetMasterServer = Record<string, Promise<any>>;
+export declare class PM_Web extends PM {
+    server: PuppetMasterServer;
+    constructor(t: ITTestResourceConfiguration);
+    customScreenShot(opts: object): void;
+    existsSync(destFolder: string): boolean;
+    mkdirSync(): any;
+    write(writeObject: {
+        uid: number;
+    }, contents: string): any;
+    writeFileSync(filepath: string, contents: string): any;
+    createWriteStream(filepath: string): any;
+    end(writeObject: {
+        uid: number;
+    }): any;
+    customclose(): void;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): (fPath: any, value: string | Buffer | PassThrough) => void;
+    startPuppeteer(options: any, destFolder: string): Promise<any>;
+}
+export {};

package/dist/types/Project.d.ts

@@ -0,0 +1,7 @@
+import { IBaseConfig, IRunTime } from "./lib/types.js";
+export declare class ITProject {
+    config: IBaseConfig;
+    mode: `up` | `down`;
+    constructor(config: IBaseConfig);
+    getSecondaryEndpointsPoints(runtime?: IRunTime): string[];
+}

package/dist/types/Puppeteer.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/Reporter.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/SubPackages/puppeteer.d.ts

@@ -0,0 +1,6 @@
+import { IBaseTest, IPartialNodeInterface, ITestImplementation, ITestSpecification } from "../Types";
+declare type IInput = string;
+export declare type IImpl<ISpec extends IBaseTest> = ITestImplementation<ISpec>;
+export declare type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+declare const _default: <ITestShape extends any>(testInput: IInput, testSpecifications: ISpec<ITestShape>, testImplementations: ITestImplementation<ITestShape, object>, testInterface?: Partial<import("../lib/types.js").INodeTestInterface<ITestShape>> | undefined) => Promise<import("../lib/core.js").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react/component/node.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+declare type IInput = typeof React.Component;
+export declare type IImpl<ISpec extends IBaseTest, IState> = ITestImplementation<ISpec, object>;
+export declare type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+declare const _default: <ITestShape extends any, IState>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react/component/web.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+declare type IInput = typeof React.Component;
+export declare type IImpl<ISpec extends IBaseTest, IState> = ITestImplementation<ISpec, object>;
+export declare type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+declare const _default: <ITestShape extends any>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react/jsx/index.d.ts

@@ -0,0 +1,12 @@
+import { CElement } from "react";
+import { IBaseTest, IPartialInterface, ITestImplementation, ITestSpecification } from "../../../Types";
+export declare type IWhenShape = any;
+export declare type IThenShape = any;
+export declare type InitialState = unknown;
+export declare type IInput = () => JSX.Element;
+export declare type ISelection = CElement<any, any>;
+export declare type IStore = CElement<any, any>;
+export declare type ISubject = CElement<any, any>;
+export declare type ITestImpl<ITestShape extends IBaseTest> = ITestImplementation<ITestShape>;
+export declare type ITestSpec<ITestShape extends IBaseTest> = ITestSpecification<ITestShape>;
+export declare const testInterface: IPartialInterface<any>;

package/dist/types/SubPackages/react/jsx/node.d.ts

@@ -0,0 +1,4 @@
+import { IPartialInterface } from "../../../Types";
+import { ITestImpl, ITestSpec, IInput } from "./index.js";
+declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface: Partial<import("../../../lib/types.js").ITestInterface<ITestShape>>) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react/jsx/web.d.ts

@@ -0,0 +1,4 @@
+import { IPartialWebInterface } from "../../../Types";
+import { ITestImpl, ITestSpec, IInput } from "./index.js";
+declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface: Partial<import("../../../lib/types").IWebTestInterface<ITestShape>>) => Promise<import("../../../lib/core").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react-dom/component/node.d.ts

@@ -0,0 +1,12 @@
+import React, { ReactNode } from "react";
+import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
+import Stream from "stream";
+import { ITestImplementation, ITestSpecification } from "../../../Types";
+declare type IInput = typeof React.Component;
+export declare type IThenShape = any;
+export declare type ISelection = ReactNode;
+export declare type IStore = ReactNode;
+export declare type ISubject = ReactNode;
+export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
+declare const _default: <ITestShape extends any>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ITestSpecification<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react-dom/component/web.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import ReactDom from "react-dom/client";
+import { IPartialWebInterface, ITestImplementation, ITestSpecification } from "../../../Types";
+declare type IInput = typeof React.Component;
+export declare type IStore = {
+    htmlElement: HTMLElement;
+    reactElement: any;
+    domRoot: ReactDom.Root;
+};
+declare const _default: <ITestShape extends any, IWhen, IGiven>(testInput: IInput, testSpecifications: ITestSpecification<ITestShape>, testImplementations: any, testInterface?: IPartialWebInterface<any>) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react-dom/jsx/index.d.ts

@@ -0,0 +1,6 @@
+export declare type IInput = (props?: any) => JSX.Element;
+export declare type IState = unknown;
+export declare type ISelection = HTMLElement;
+export declare type IStore = HTMLElement;
+export declare type IWhenShape = any;
+export declare type IThenShape = any;

package/dist/types/SubPackages/react-dom/jsx/node.d.ts

@@ -0,0 +1,6 @@
+import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
+import Stream from 'stream';
+import { ITestImplementation, ITestSpecification } from "../../../Types";
+export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
+declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ITestSpecification<ITestShape>, testInput: ITestShape["iinput"]) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react-dom/jsx/web.d.ts

@@ -0,0 +1,5 @@
+import { ITestImplementation, ITestSpecification } from "../../../Types";
+import type { IInput } from "./index";
+export declare type ISubject = HTMLElement;
+declare const _default: <ITestShape extends any>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ITestSpecification<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/MemoExoticComponent/node.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { ITestImplementation, ITestSpecification } from "../../../Types";
+declare type IInput = React.MemoExoticComponent<() => JSX.Element>;
+declare const _default: <ITestShape extends any, PropShape>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ITestSpecification<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/component/index.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import renderer from "react-test-renderer";
+import type { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+export declare type ISuper<T> = T extends infer U ? U : object;
+export declare type IInput<P, S> = typeof React.Component<P, S>;
+export declare type InitialState = unknown;
+export declare type IWhenShape = any;
+export declare type IThenShape = any;
+export declare type ISelection = renderer.ReactTestRenderer;
+export declare type IStore = renderer.ReactTestRenderer;
+export declare type ISubject = renderer.ReactTestRenderer;
+export declare type IImpl<ITestShape extends IBaseTest> = ITestImplementation<ITestShape>;
+export declare type ISpec<ITestShape extends IBaseTest> = ITestSpecification<ITestShape>;

package/dist/types/SubPackages/react-test-renderer/component/interface.d.ts

@@ -0,0 +1,9 @@
+import renderer from "react-test-renderer";
+import { ISelection, IStore } from ".";
+export declare const testInterface: {
+    beforeEach: (CComponent: any, propsAndChildren: any) => Promise<renderer.ReactTestRenderer>;
+    andWhen: (renderer: renderer.ReactTestRenderer, whenCB: any) => Promise<renderer.ReactTestRenderer>;
+    butThen: (s: IStore, thenCB: any, tr: any) => Promise<ISelection>;
+    afterEach: (store: IStore, ndx: any, artificer: any) => Promise<{}>;
+    afterAll: (store: IStore, artificer: any) => void;
+};

package/dist/types/SubPackages/react-test-renderer/component/node.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { IImpl, ISpec, IInput } from "./index.js";
+declare const _default: <ITestShape extends any, IProps, IState>(testImplementations: IImpl<ITestShape>, testSpecifications: ISpec<ITestShape>, testInput: {
+    new (props: IProps | Readonly<IProps>): import("react").Component<IProps, IState, any>;
+    new (props: IProps, context: any): import("react").Component<IProps, IState, any>;
+    contextType?: import("react").Context<any> | undefined;
+}) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/component/web.d.ts

@@ -0,0 +1,3 @@
+import { IImpl, ISpec, IInput } from "./index.js";
+declare const _default: <ITestShape extends any, IProps, IState>(testImplementations: IImpl<ITestShape>, testSpecifications: ISpec<ITestShape>, testInput: IInput<any, any>) => Promise<import("../../../lib/core").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/fc/node.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import { ITestSpecification, ITestImplementation, IBaseTest } from "../../../Types";
+export declare type IInput = React.FC;
+export declare type IWhenShape = unknown;
+export declare type IThenShape = unknown;
+export declare type ISpec<ITestShape extends IBaseTest> = ITestSpecification<ITestShape>;
+declare const _default: <ITestShape extends any>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/fc/web.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import { ITestSpecification, ITestImplementation, IBaseTest } from "../../../Types";
+export declare type IInput = React.FC;
+export declare type IWhenShape = unknown;
+export declare type IThenShape = unknown;
+export declare type ISpec<ITestShape extends IBaseTest> = ITestSpecification<ITestShape>;
+declare const _default: <ITestShape extends any, IPropShape>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/jsx/index.d.ts

@@ -0,0 +1,16 @@
+import renderer from "react-test-renderer";
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+export declare type IWhenShape = any;
+export declare type IThenShape = any;
+export declare type InitialState = unknown;
+export declare type IInput = (props?: any) => JSX.Element;
+export declare type ISelection = renderer.ReactTestRenderer;
+export declare type IStore = renderer.ReactTestRenderer;
+export declare type ISubject = renderer.ReactTestRenderer;
+export declare type ITestImpl<ITestShape extends IBaseTest> = ITestImplementation<ITestShape, object>;
+export declare type ITestSpec<ITestShape extends IBaseTest> = ITestSpecification<ITestShape>;
+export declare const testInterface: {
+    butThen: (s: IStore, thenCB: any, tr: any) => Promise<ISelection>;
+    beforeEach: (CComponent: any, props: any) => Promise<renderer.ReactTestRenderer>;
+    andWhen: (renderer: renderer.ReactTestRenderer, whenCB: (any: any) => any) => Promise<renderer.ReactTestRenderer>;
+};

package/dist/types/SubPackages/react-test-renderer/jsx/node.d.ts

@@ -0,0 +1,8 @@
+import type { ITestImpl, ITestSpec } from "../jsx-promised";
+import { IInput } from "./index.js";
+declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface2?: {
+    butThen: (s: import("react-test-renderer").ReactTestRenderer, thenCB: any, tr: any) => Promise<import("react-test-renderer").ReactTestRenderer>;
+    beforeEach: (CComponent: any, props: any) => Promise<import("react-test-renderer").ReactTestRenderer>;
+    andWhen: (renderer: import("react-test-renderer").ReactTestRenderer, whenCB: (any: any) => any) => Promise<import("react-test-renderer").ReactTestRenderer>;
+}) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/jsx/web.d.ts

@@ -0,0 +1,8 @@
+import { ITestImpl, ITestSpec } from "../jsx-promised";
+import { IInput } from "./index.js";
+declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface2?: {
+    butThen: (s: import("react-test-renderer").ReactTestRenderer, thenCB: any, tr: any) => Promise<import("react-test-renderer").ReactTestRenderer>;
+    beforeEach: (CComponent: any, props: any) => Promise<import("react-test-renderer").ReactTestRenderer>;
+    andWhen: (renderer: import("react-test-renderer").ReactTestRenderer, whenCB: (any: any) => any) => Promise<import("react-test-renderer").ReactTestRenderer>;
+}) => Promise<import("../../../lib/core").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/jsx-promised/index.d.ts

@@ -0,0 +1,15 @@
+import renderer from "react-test-renderer";
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+export declare type IWhenShape = any;
+export declare type IThenShape = any;
+export declare type InitialState = unknown;
+export declare type IInput = Promise<JSX.Element>;
+export declare type ISelection = renderer.ReactTestRenderer;
+export declare type IStore = renderer.ReactTestRenderer;
+export declare type ISubject = renderer.ReactTestRenderer;
+export declare type ITestImpl<ITestShape extends IBaseTest> = ITestImplementation<ITestShape>;
+export declare type ITestSpec<ITestShape extends IBaseTest> = ITestSpecification<ITestShape>;
+export declare const testInterface: {
+    beforeEach: (CComponent: any) => Promise<renderer.ReactTestRenderer>;
+    andWhen: (renderer: renderer.ReactTestRenderer, whenCB: () => (any: any) => any) => Promise<renderer.ReactTestRenderer>;
+};

package/dist/types/SubPackages/react-test-renderer/jsx-promised/node.d.ts

@@ -0,0 +1,4 @@
+import { IInput } from ".";
+import { ITestImpl, ITestSpec } from "../../react/jsx";
+declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react-test-renderer/jsx-promised/web.d.ts

@@ -0,0 +1,4 @@
+import { ITestImpl, ITestSpec } from "../../react/jsx";
+import { IInput } from "./index";
+declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
+export default _default;

package/dist/types/TaskManBackEnd.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/Types.d.ts

@@ -0,0 +1,50 @@
+import { ITTestResourceRequest, ITestCheckCallback } from "./lib/index.js";
+import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen, BaseGiven } from "./lib/abstractBase.js";
+import Testeranto from "./lib/core.js";
+import { INodeTestInterface, ITestInterface, IWebTestInterface } from "./lib/types.js";
+export declare type IPartialInterface<I extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = Partial<ITestInterface<I>>;
+export declare type IPartialNodeInterface<I extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = Partial<INodeTestInterface<I>>;
+export declare type IPartialWebInterface<I extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = Partial<IWebTestInterface<I>>;
+export declare type IEntry<ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = (input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape, object>, testInterface: IPartialInterface<ITestShape>, testResourceRequirement: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
+export declare type ITestSpecification<ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = (Suite: {
+    [K in keyof ITestShape["suites"]]: (name: string, givens: IGivens<ITestShape>, checks: BaseCheck<ITestShape>[]) => BaseSuite<ITestShape>;
+}, Given: {
+    [K in keyof ITestShape["givens"]]: (features: string[], whens: BaseWhen<ITestShape>[], thens: BaseThen<ITestShape>[], ...xtrasB: ITestShape["givens"][K]) => BaseGiven<ITestShape>;
+}, When: {
+    [K in keyof ITestShape["whens"]]: (...xtrasC: ITestShape["whens"][K]) => BaseWhen<ITestShape>;
+}, Then: {
+    [K in keyof ITestShape["thens"]]: (...xtrasD: ITestShape["thens"][K]) => BaseThen<ITestShape>;
+}, Check: ITestCheckCallback<ITestShape>) => any[];
+export declare type ITestImplementation<ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>, IMod = object> = Modify<{
+    suites: {
+        [K in keyof ITestShape["suites"]]: string;
+    };
+    givens: {
+        [K in keyof ITestShape["givens"]]: (...Ig: ITestShape["givens"][K]) => ITestShape["given"];
+    };
+    whens: {
+        [K in keyof ITestShape["whens"]]: (...Iw: ITestShape["whens"][K]) => (zel: ITestShape["iselection"]) => ITestShape["when"];
+    };
+    thens: {
+        [K in keyof ITestShape["thens"]]: (...It: ITestShape["thens"][K]) => (ssel: ITestShape["iselection"]) => ITestShape["then"];
+    };
+    checks: {
+        [K in keyof ITestShape["checks"]]: (...Ic: ITestShape["checks"][K]) => ITestShape["given"];
+    };
+}, IMod>;
+declare type Modify<T, R> = Omit<T, keyof R> & R;
+export declare type IBaseTest<IInput, ISubject, IStore, ISelection, IGiven, IWhen, IThen, ISuites extends Record<string, any>, IGivens extends Record<string, any>, IWhens extends Record<string, any>, IThens extends Record<string, any>, IChecks extends Record<string, any>> = {
+    iinput: IInput;
+    isubject: ISubject;
+    istore: IStore;
+    iselection: ISelection;
+    given: IGiven;
+    when: IWhen;
+    then: IThen;
+    suites: ISuites;
+    givens: IGivens;
+    whens: IWhens;
+    thens: IThens;
+    checks: IChecks;
+};
+export {};

package/dist/types/Web.d.ts

@@ -0,0 +1,6 @@
+import type { IBaseTest, ITestImplementation, ITestSpecification } from "./Types";
+import Testeranto from "./lib/core.js";
+import { ITTestResourceRequest } from "./lib/index.js";
+import { IWebTestInterface } from "./lib/types";
+declare const _default: <ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape, object>, testInterface: Partial<IWebTestInterface<ITestShape>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
+export default _default;

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

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

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

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

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

@@ -0,0 +1,5 @@
+declare const _default: (platform: "web" | "node", entryPoints: Set<string> | string[]) => {
+    name: string;
+    setup(build: any): void;
+};
+export default _default;

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

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

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

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

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

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

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

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