testeranto 0.100.0 → 0.111.0

package/src/SubPackages/react-dom/component/node.ts

@@ -8,69 +8,61 @@ import Stream from "stream";
 import Testeranto from "../../../Node.js";
 
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   ITestImplementation,
   ITestSpecification,
 } from "../../../Types";
 
 type IInput = typeof React.Component;
-type InitialState = unknown;
-type IWhenShape = any;
-export type IThenShape = any;
+
 export type ISelection = ReactNode;
 export type IStore = ReactNode;
 export type ISubject = ReactNode;
 
 export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
 
-export default <ITestShape extends IBaseTest>(
-  testImplementations: ITestImplementation<ITestShape>,
-  testSpecifications: ITestSpecification<ITestShape>,
+export default <
+  I extends Ibdd_in<
+    IInput,
+    ISubject,
+    IStore,
+    ISelection,
+    unknown,
+    (s: IStore) => IStore,
+    unknown
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+>(
+  testImplementations: ITestImplementation<I, O>,
+  testSpecifications: ITestSpecification<I, O>,
   testInput: IInput
 ) => {
-  return Testeranto<ITestShape>(
-    testInput,
-    testSpecifications,
-    testImplementations,
-    {
-      // beforeAll: async (
-      //   prototype,
-      //   artificer
-      // ): Promise<ISubject> => {
-      //   return await new Promise((resolve, rej) => {
-      //     const elem = document.getElementById("root");
-      //     if (elem) {
-      //       resolve({ htmlElement: elem });
-      //     }
-
-      //   })
-      // },
-      beforeEach: async (
-        reactComponent,
-        ndx,
-        testRsource,
-        artificer
-      ): Promise<IStore> => {
-        return new Promise((resolve, rej) => {
-          // Ignore these type errors
-          resolve(createElement(testInput));
-        });
-      },
-      andWhen: async function (s: IStore, whenCB): Promise<ISelection> {
-        return whenCB(s);
-        // return s
-      },
-      butThen: async function (s: IStore): Promise<ISelection> {
-        return s;
-      },
-      afterEach: async function (store: IStore, ndx, artificer) {
-        return {};
-      },
-      afterAll: (store: IStore, artificer) => {
-        return;
-      },
-    }
-  );
+  return Testeranto<I, O>(testInput, testSpecifications, testImplementations, {
+    beforeEach: async (): Promise<IStore> => {
+      return new Promise((resolve, rej) => {
+        resolve(createElement(testInput));
+      });
+    },
+    andWhen: async function (s, whenCB) {
+      return whenCB(s);
+    },
+    butThen: async function (s) {
+      return s;
+    },
+    afterEach: async function () {
+      return {};
+    },
+    afterAll: () => {
+      return;
+    },
+  });
 };
 
 // type IInput = typeof React.Component;

package/src/SubPackages/react-dom/component/web.ts

@@ -3,7 +3,8 @@ import ReactDom from "react-dom/client";
 
 import Testeranto from "../../../Web.js";
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   IPartialInterface,
   IPartialWebInterface,
   ITestImplementation,
@@ -11,10 +12,10 @@ import {
 } from "../../../Types";
 
 type IInput = typeof React.Component;
-type InitialState = unknown;
 type ISelection = {
   htmlElement: HTMLElement;
   reactElement: any; //CElement<any, any>;
+  domRoot: ReactDom.Root;
 };
 
 export type IStore = {
@@ -29,10 +30,27 @@ type ISubject = {
   domRoot: ReactDom.Root;
 };
 
-export default <ITestShape extends IBaseTest, IWhen, IGiven>(
+export default <
+  I extends Ibdd_in<
+    IInput,
+    ISubject,
+    ISelection,
+    IStore,
+    (s: IStore) => IStore,
+    (s: IStore) => IStore,
+    (s: IStore) => IStore
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+>(
   testInput: IInput,
-  testSpecifications: ITestSpecification<ITestShape>,
-  testImplementations: ITestImplementation<ITestShape, any>,
+  testSpecifications: ITestSpecification<I, O>,
+  testImplementations: ITestImplementation<I, O>,
   testInterface?: IPartialWebInterface<any>
 ) => {
   class TesterantoComponent extends testInput {
@@ -47,7 +65,7 @@ export default <ITestShape extends IBaseTest, IWhen, IGiven>(
     }
   }
 
-  const t = Testeranto<ITestShape>(
+  const t = Testeranto<I, O>(
     testInput,
     testSpecifications,
     testImplementations,
@@ -86,19 +104,19 @@ export default <ITestShape extends IBaseTest, IWhen, IGiven>(
           );
         });
       },
-      andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+      andWhen: async function (s, whenCB) {
         return whenCB(s);
       },
-      butThen: async function (s: IStore, thenCB): Promise<ISelection> {
+      butThen: async function (s, thenCB) {
         return thenCB(s);
       },
       afterEach:
         testInterface?.afterEach ||
-        async function (store: IStore, ndx, artificer, utils) {
+        async function (store: IStore, ndx, utils) {
           return store;
         },
 
-      afterAll: async (store: IStore, artificer, utils) => {
+      afterAll: async (store: IStore, utils) => {
         // setTimeout(() => {
         //   console.log("This will run after 1 second");
         // }, 1000); // 1000 milliseconds = 1 second

package/src/SubPackages/react-dom/jsx/node.ts

@@ -1,68 +1,66 @@
 import { createElement } from "react";
-import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
-import Stream from 'stream'
+import {
+  renderToStaticMarkup,
+  renderToStaticNodeStream,
+} from "react-dom/server";
+import Stream from "stream";
 
 import Testeranto from "../../../Node.js";
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   ITestImplementation,
-  ITestSpecification
+  ITestSpecification,
 } from "../../../Types";
 
-export {
-  renderToStaticMarkup, renderToStaticNodeStream, Stream
-}
-
-export default <ITestShape extends IBaseTest>(
+import { IInput, ISelection, IStore } from "./index.js";
 
-  testImplementations: ITestImplementation<ITestShape, any>,
-  testSpecifications: ITestSpecification<ITestShape>,
-  testInput: ITestShape['iinput']
+export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
 
+export default <
+  I extends Ibdd_in<
+    IInput,
+    unknown,
+    ISelection,
+    IStore,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+>(
+  testImplementations: ITestImplementation<I, O>,
+  testSpecifications: ITestSpecification<I, O>,
+  testInput: I["iinput"]
 ) => {
-  return Testeranto<
-    ITestShape
-  >(
-    testInput,
-    testSpecifications,
-    testImplementations,
-    {
-      beforeAll: async (
-        prototype,
-        artificer
-      ) => {
-        return await new Promise((resolve, rej) => {
-          resolve(null);
-        })
-      },
-      beforeEach: async (
-        reactComponent,
-        ndx,
-        testRsource,
-        artificer
-      ): Promise<ITestShape['istore']> => {
-        return new Promise((resolve, rej) => {
-          resolve(createElement(testInput));
-        });
-      },
-      andWhen: async function (s, whenCB) {
-        return s
-      },
-      butThen: async function (s: ITestShape['istore']): Promise<ITestShape['iselection']> {
-        return s;
-      },
-      afterEach: async function (
-        store: ITestShape['istore'],
-        ndx,
-        artificer
-      ) {
-        return {};
-      },
-      afterAll: (
-        store: ITestShape['istore'],
-        artificer) => {
-        return;
-      },
+  return Testeranto<I, O>(testInput, testSpecifications, testImplementations, {
+    beforeAll: async (prototype, artificer) => {
+      return await new Promise((resolve, rej) => {
+        resolve(null);
+      });
+    },
+    beforeEach: async () => {
+      return new Promise((resolve, rej) => {
+        resolve(createElement(testInput));
+      });
+    },
+    andWhen: async function (s, whenCB) {
+      return s;
+    },
+    butThen: async function (s: I["istore"]): Promise<I["iselection"]> {
+      return s;
+    },
+    afterEach: async function (store: I["istore"], ndx, artificer) {
+      return {};
+    },
+    afterAll: (store: I["istore"], artificer) => {
+      return;
     },
-  )
+  });
 };

package/src/SubPackages/react-dom/jsx/web.ts

@@ -1,16 +1,22 @@
 import React, { useEffect, useRef } from "react";
 import { CElement, createElement } from "react";
 import ReactDom from "react-dom";
-import { createPortal } from "react-dom";
 
 import Testeranto from "../../../Web.js";
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   ITestImplementation,
   ITestSpecification,
 } from "../../../Types";
 
-import type { IInput, ISelection, IStore } from "./index";
+import type {
+  IInput,
+  ISelection,
+  IStore,
+  IThenShape,
+  IWhenShape,
+} from "./index";
 
 export type ISubject = HTMLElement;
 
@@ -30,12 +36,29 @@ const TesterantoComponent = ({
   return React.createElement("div", { ref: myContainer }, innerComp());
 };
 
-export default <ITestShape extends IBaseTest>(
-  testImplementations: ITestImplementation<ITestShape>,
-  testSpecifications: ITestSpecification<ITestShape>,
+export default <
+  I extends Ibdd_in<
+    IInput,
+    ISubject,
+    ISelection,
+    IStore,
+    unknown,
+    IWhenShape,
+    IThenShape
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+>(
+  testImplementations: ITestImplementation<I, O>,
+  testSpecifications: ITestSpecification<I, O>,
   testInput: IInput
 ) => {
-  const t = Testeranto<ITestShape>(
+  const t = Testeranto<I, O>(
     testInput,
     testSpecifications,
     testImplementations,
@@ -70,36 +93,31 @@ export default <ITestShape extends IBaseTest>(
         });
       },
 
-      beforeEach: async (
-        subject,
-        initializer,
-        artificer,
-        testResource,
-        pm
-      ): Promise<IStore> => {
-        return new Promise((resolve, rej) => {
-          resolve(subject);
-          // const tc = TesterantoComponent({
-          //   innerComp: () =>
-          //     testInput({
-          //       port: 3003,
-          //       address: "some-address",
-          //       secretKey: "someSecretKey",
-          //       abi: "foo",
-          //     }),
-          //   done: (reactElement: any) => {
-          //     console.log("mark9");
-          //     resolve(reactElement);
-          //     // process.nextTick(() => {
-          //     //   resolve(reactElement);
-          //     // });
-          //   },
-          // });
-          // console.log("mark9", tc);
-          // createPortal(tc, subject.domRoot);
-        });
+      beforeEach: async (subject) => {
+        return subject;
+        // return new Promise((resolve, rej) => {
+        //   resolve(subject);
+        //   // const tc = TesterantoComponent({
+        //   //   innerComp: () =>
+        //   //     testInput({
+        //   //       port: 3003,
+        //   //       address: "some-address",
+        //   //       secretKey: "someSecretKey",
+        //   //       abi: "foo",
+        //   //     }),
+        //   //   done: (reactElement: any) => {
+        //   //     console.log("mark9");
+        //   //     resolve(reactElement);
+        //   //     // process.nextTick(() => {
+        //   //     //   resolve(reactElement);
+        //   //     // });
+        //   //   },
+        //   // });
+        //   // console.log("mark9", tc);
+        //   // createPortal(tc, subject.domRoot);
+        // });
       },
-      andWhen: function (s: IStore, whenCB, tr, utils): Promise<ISelection> {
+      andWhen: async function (s, whenCB, tr, utils) {
         return whenCB(s, utils);
         // return new Promise(async (resolve, rej) => {
         //   // resolve(await whenCB(s, utils));
@@ -108,12 +126,7 @@ export default <ITestShape extends IBaseTest>(
         //   // });
         // });
       },
-      butThen: async function (
-        s: IStore,
-        thenCB,
-        tr,
-        utils
-      ): Promise<ISelection> {
+      butThen: async function (s, thenCB, tr, utils) {
         return new Promise((resolve, rej) => {
           resolve(thenCB(s, utils));
         });

package/src/SubPackages/react-test-renderer/MemoExoticComponent/node.ts

@@ -2,22 +2,38 @@ import React from "react";
 import renderer, { act } from "react-test-renderer";
 
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   ITestImplementation,
   ITestSpecification,
 } from "../../../Types";
 import test from "../../../Node";
 
 type IInput = React.MemoExoticComponent<() => JSX.Element>;
-type WhenShape = unknown;
-type ThenShape = unknown;
 
-export default <ITestShape extends IBaseTest, PropShape>(
-  testImplementations: ITestImplementation<ITestShape>,
-  testSpecifications: ITestSpecification<ITestShape>,
+export default <
+  I extends Ibdd_in<
+    IInput,
+    renderer.ReactTestRenderer,
+    renderer.ReactTestRenderer,
+    renderer.ReactTestRenderer,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+>(
+  testImplementations: ITestImplementation<I, O>,
+  testSpecifications: ITestSpecification<I, O>,
   testInput: IInput
 ) =>
-  test<ITestShape>(testInput, testSpecifications, testImplementations, {
+  test<I, O>(testInput, testSpecifications, testImplementations, {
     beforeEach: function (
       CComponent,
       props

package/src/SubPackages/react-test-renderer/component/index.ts

@@ -2,7 +2,8 @@ import React from "react";
 import renderer, { act } from "react-test-renderer";
 
 import type {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   ITestImplementation,
   ITestSpecification,
 } from "../../../Types";
@@ -17,7 +18,39 @@ export type ISelection = renderer.ReactTestRenderer;
 export type IStore = renderer.ReactTestRenderer;
 export type ISubject = renderer.ReactTestRenderer;
 
-export type IImpl<ITestShape extends IBaseTest> =
-  ITestImplementation<ITestShape>;
-export type ISpec<ITestShape extends IBaseTest> =
-  ITestSpecification<ITestShape>;
+export type IImpl<
+  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>
+  >
+> = ITestImplementation<I, O>;
+export type ISpec<
+  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>
+  >
+> = ITestSpecification<I, O>;

package/src/SubPackages/react-test-renderer/component/node.ts

@@ -1,15 +1,34 @@
 import Testeranto from "../../../Node.js";
-import type { IBaseTest } from "../../../Types";
+import { Ibdd_in, Ibdd_out } from "../../../Types.js";
 
 import { IImpl, ISpec, IInput } from "./index.js";
 import { testInterface } from "./interface.js";
 
-export default <ITestShape extends IBaseTest, IProps, IState>(
-  testImplementations: IImpl<ITestShape>,
-  testSpecifications: ISpec<ITestShape>,
+export default <
+  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>
+  >,
+  IProps,
+  IState
+>(
+  testImplementations: IImpl<I, O>,
+  testSpecifications: ISpec<I, O>,
   testInput: IInput<IProps, IState>
 ) =>
-  Testeranto<ITestShape>(
+  Testeranto<I, O>(
     testInput,
     testSpecifications,
     testImplementations,

package/src/SubPackages/react-test-renderer/component/web.ts

@@ -1,15 +1,32 @@
-import { IBaseTest } from "../../../Types";
+import { Ibdd_in, Ibdd_out } from "../../../Types.js";
 import Testeranto from "../../../Web.js";
 
 import { IImpl, ISpec, IInput } from "./index.js";
 import { testInterface } from "./interface";
 
-export default <ITestShape extends IBaseTest, IProps, IState>(
-  testImplementations: IImpl<ITestShape>,
-  testSpecifications: ISpec<ITestShape>,
+export default <
+  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>
+  >
+>(
+  testImplementations: IImpl<I, O>,
+  testSpecifications: ISpec<I, O>,
   testInput: IInput<any, any>
 ) =>
-  Testeranto<ITestShape>(
+  Testeranto<I, O>(
     testInput,
     testSpecifications,
     testImplementations,