testeranto 0.62.0 → 0.73.0

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

@@ -1,60 +1,50 @@
-import React, { useEffect, useRef, } from "react";
-import { createPortal } from 'react-dom';
+import React, { useEffect, useRef } from "react";
+import { createPortal } from "react-dom";
 
 import Testeranto from "../../../Web.js";
-import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
 
-import type {
-  IInput,
-  ISelection,
-  IStore,
-} from "./index";
+import type { IInput, ISelection, IStore } from "./index";
 
 export type ISubject = HTMLElement;
 
 export default <ITestShape extends IBaseTest>(
-  testImplementations: ITestImplementation<
-    ITestShape,
-    object
-  >,
-  testSpecifications: ITestSpecification<
-    ITestShape
-  >,
+  testImplementations: ITestImplementation<ITestShape>,
+  testSpecifications: ITestSpecification<ITestShape>,
   testInput: IInput
 ) => {
   document.addEventListener("DOMContentLoaded", function () {
     const rootElement = document.getElementById("root");
     if (rootElement) {
-      const TesterantoComponent = function ({ done, innerComp }: { done: (ref: React.MutableRefObject<any>) => any, innerComp: IInput }) {
+      const TesterantoComponent = function ({
+        done,
+        innerComp,
+      }: {
+        done: (ref: React.MutableRefObject<any>) => any;
+        innerComp: IInput;
+      }) {
         const myContainer = useRef<any>(null);
         useEffect(() => {
-          console.log(
-            "useEffect called", myContainer.current
-          );
+          console.log("useEffect called", myContainer.current);
           done(myContainer.current);
         }, []);
 
-        return React.createElement(
-          'div',
-          { ref: myContainer },
-          innerComp()
-        );
+        return React.createElement("div", { ref: myContainer }, innerComp());
       };
 
-      Testeranto<
-        ITestShape
-      >(
+      Testeranto<ITestShape>(
         testInput,
         testSpecifications,
         testImplementations,
         {
-          beforeAll: async (
-            input,
-            artificer
-          ): Promise<HTMLElement> => {
+          beforeAll: async (input, artificer): Promise<HTMLElement> => {
             return await new Promise((resolve, rej) => {
               resolve(rootElement);
-            })
+            });
           },
 
           beforeEach: async (
@@ -69,41 +59,44 @@ export default <ITestShape extends IBaseTest>(
                   innerComp: testInput,
                   done: (reactElement: any) => {
                     process.nextTick(() => {
-                      resolve(reactElement)
-                    })
-                  }
-                },
-                ),
+                      resolve(reactElement);
+                    });
+                  },
+                }),
                 rootElement
               );
             });
           },
           andWhen: function (s: IStore, whenCB): Promise<ISelection> {
             return new Promise((resolve, rej) => {
-              process.nextTick(() => { resolve(whenCB()(s)) })
+              process.nextTick(() => {
+                resolve(whenCB()(s));
+              });
             });
           },
           butThen: async function (s: IStore): Promise<ISelection> {
             return new Promise((resolve, rej) => {
-              process.nextTick(() => { resolve(s) })
+              process.nextTick(() => {
+                resolve(s);
+              });
             });
           },
-          afterEach: async function (
-            store: IStore,
-            ndx,
-            artificer
-          ) {
+          afterEach: async function (store: IStore, ndx, artificer) {
             return new Promise((resolve, rej) => {
-              process.nextTick(() => { resolve({}) })
+              process.nextTick(() => {
+                resolve({});
+              });
             });
           },
           afterAll: (store: IStore, artificer) => {
             return new Promise((resolve, rej) => {
-              process.nextTick(() => { resolve({}) })
+              process.nextTick(() => {
+                resolve({});
+              });
             });
           },
-        },
-      )
+        }
+      );
     }
   });
 };

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

@@ -1,48 +1,38 @@
-import test from "../../../Node";
-
 import React from "react";
 import renderer, { act } from "react-test-renderer";
 
-import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+import {
+  IBaseTest,
+  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, object
-  >,
-  testSpecifications: ITestSpecification<
-    ITestShape
-  >,
+  testImplementations: ITestImplementation<ITestShape>,
+  testSpecifications: ITestSpecification<ITestShape>,
   testInput: IInput
 ) =>
-  test<
-    ITestShape
-  >(
-    testInput,
-    testSpecifications,
-    testImplementations,
-    {
-      beforeEach: function (
-        CComponent,
-        props
-      ): Promise<renderer.ReactTestRenderer> {
-        let component;
-        act(() => {
-          component = renderer.create(
-            React.createElement(CComponent, props, [])
-          );
-        });
-        return component;
-      },
-      andWhen: async function (
-        renderer: renderer.ReactTestRenderer,
-        whenCB: () => (a: any) => any
-      ): Promise<renderer.ReactTestRenderer> {
-        await act(() => whenCB()(renderer));
-        return renderer;
-      },
-    }
-  );
+  test<ITestShape>(testInput, testSpecifications, testImplementations, {
+    beforeEach: function (
+      CComponent,
+      props
+    ): Promise<renderer.ReactTestRenderer> {
+      let component;
+      act(() => {
+        component = renderer.create(React.createElement(CComponent, props, []));
+      });
+      return component;
+    },
+    andWhen: async function (
+      renderer: renderer.ReactTestRenderer,
+      whenCB: () => (a: any) => any
+    ): Promise<renderer.ReactTestRenderer> {
+      await act(() => whenCB()(renderer));
+      return renderer;
+    },
+  });

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

@@ -2,7 +2,9 @@ import React from "react";
 import renderer, { act } from "react-test-renderer";
 
 import type {
-  IBaseTest, ITestImplementation, ITestSpecification
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
 } from "../../../Types";
 
 export type ISuper<T> = T extends infer U ? U : object;
@@ -15,17 +17,10 @@ export type ISelection = renderer.ReactTestRenderer;
 export type IStore = renderer.ReactTestRenderer;
 export type ISubject = renderer.ReactTestRenderer;
 
-export type IImpl<
-  ITestShape extends IBaseTest,
-  IProps
-> = ITestImplementation<
-  ITestShape, object
->
-export type ISpec<
-  ITestShape extends IBaseTest
-> = ITestSpecification<
-  ITestShape
->
+export type IImpl<ITestShape extends IBaseTest> =
+  ITestImplementation<ITestShape>;
+export type ISpec<ITestShape extends IBaseTest> =
+  ITestSpecification<ITestShape>;
 
 // export const testInterface = {
 //   beforeEach: function (CComponent, props): Promise<renderer.ReactTestRenderer> {
@@ -48,11 +43,11 @@ export type ISpec<
 //   }
 // }
 
-
-
 export const testInterface = {
-  beforeEach: function (CComponent, propsAndChildren): Promise<renderer.ReactTestRenderer> {
-
+  beforeEach: function (
+    CComponent,
+    propsAndChildren
+  ): Promise<renderer.ReactTestRenderer> {
     function Link(props) {
       const p = props.props;
       const c = props.children;
@@ -73,31 +68,22 @@ export const testInterface = {
   ): Promise<renderer.ReactTestRenderer> {
     // console.log("andWhen", whenCB)
     await act(() => whenCB(renderer));
-    return renderer
+    return renderer;
   },
 
   // andWhen: function (s: Store, whenCB): Promise<Selection> {
   //   return whenCB()(s);
   // },
   butThen: async function (s: IStore, thenCB, tr): Promise<ISelection> {
-
-    console.log("butThen", thenCB.toString())
-    // debugger
+    console.log("butThen", thenCB.toString());
     return thenCB(s);
   },
-  afterEach: async function (
-    store: IStore,
-    ndx,
-    artificer
-  ) {
+  afterEach: async function (store: IStore, ndx, artificer) {
     // console.log("afterEach", store);
-    return {
-
-    };
+    return {};
   },
   afterAll: (store: IStore, artificer) => {
     // console.log("afterAll", store);
     return;
   },
-
-}
+};

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

@@ -3,20 +3,14 @@ import type { IBaseTest } from "../../../Types";
 
 import { IImpl, ISpec, IInput, testInterface } from "./index.js";
 
-export default <
-  ITestShape extends IBaseTest,
-  IProps,
-  IState
->(
-  testImplementations: IImpl<ITestShape, object>,
+export default <ITestShape extends IBaseTest, IProps, IState>(
+  testImplementations: IImpl<ITestShape>,
   testSpecifications: ISpec<ITestShape>,
-  testInput: IInput<IProps, IState>,
+  testInput: IInput<IProps, IState>
 ) =>
-  Testeranto<
-    ITestShape
-  >(
+  Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
     testInterface
-  )
+  );

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

@@ -3,20 +3,14 @@ import Testeranto from "../../../Web.js";
 
 import { IImpl, ISpec, IInput, testInterface } from "./index.js";
 
-export default <
-  ITestShape extends IBaseTest,
-  IProps,
-  IState
->(
-  testImplementations: IImpl<ITestShape, object>,
+export default <ITestShape extends IBaseTest, IProps, IState>(
+  testImplementations: IImpl<ITestShape>,
   testSpecifications: ISpec<ITestShape>,
-  testInput: IInput<any, any>,
+  testInput: IInput<any, any>
 ) =>
-  Testeranto<
-    ITestShape
-  >(
+  Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
     testInterface
-  )
+  );

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

@@ -3,61 +3,47 @@ import renderer, { act } from "react-test-renderer";
 
 import test from "../../../Node.js";
 
-import { ITestSpecification, ITestImplementation, IBaseTest } from "../../../Types";
+import {
+  ITestSpecification,
+  ITestImplementation,
+  IBaseTest,
+} from "../../../Types";
 
 export type IInput = React.FC;
 export type IWhenShape = unknown;
 export type IThenShape = unknown;
 
-export type ISpec<ITestShape extends IBaseTest> = ITestSpecification<
-  ITestShape
->
-export default <
-  ITestShape extends IBaseTest
->(
-  testImplementations: ITestImplementation<
-    ITestShape, object
-  >,
+export type ISpec<ITestShape extends IBaseTest> =
+  ITestSpecification<ITestShape>;
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImplementation<ITestShape>,
   testSpecifications: ISpec<ITestShape>,
   testInput: IInput
 ) =>
-  test<
-    ITestShape
-  >(
-    testInput,
-    testSpecifications,
-    testImplementations,
-    {
-      beforeEach: function (
-        CComponent,
-        props
-      ): Promise<renderer.ReactTestRenderer> {
-
-        return new Promise((res, rej) => {
-          let component: renderer.ReactTestRenderer;
-          act(() => {
-            component = renderer.create(
-              React.createElement(
-                CComponent,
-                props,
-                [])
-            );
-            res(component);
-          });
-
-        })
-
-      },
-      andWhen: async function (
-        renderer: renderer.ReactTestRenderer,
-        whenCB: () => (a: any) => any
-      ): Promise<renderer.ReactTestRenderer> {
-        await act(() => whenCB()(renderer));
-        return renderer;
-      },
-      afterEach: async (store, key, artificer) => {
-        console.log("afterall")
-        store.unmount();
-      },
-    }
-  );
+  test<ITestShape>(testInput, testSpecifications, testImplementations, {
+    beforeEach: function (
+      CComponent,
+      props
+    ): Promise<renderer.ReactTestRenderer> {
+      return new Promise((res, rej) => {
+        let component: renderer.ReactTestRenderer;
+        act(() => {
+          component = renderer.create(
+            React.createElement(CComponent, props, [])
+          );
+          res(component);
+        });
+      });
+    },
+    andWhen: async function (
+      renderer: renderer.ReactTestRenderer,
+      whenCB: () => (a: any) => any
+    ): Promise<renderer.ReactTestRenderer> {
+      await act(() => whenCB()(renderer));
+      return renderer;
+    },
+    afterEach: async (store, key, artificer) => {
+      console.log("afterall");
+      store.unmount();
+    },
+  });

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

@@ -1,61 +1,48 @@
-import test from "../../../Web.js";
-
 import React from "react";
 import renderer, { act } from "react-test-renderer";
 
-import { ITestSpecification, ITestImplementation, IBaseTest } from "../../../Types";
+import {
+  ITestSpecification,
+  ITestImplementation,
+  IBaseTest,
+} from "../../../Types";
+import test from "../../../Web.js";
 
 export type IInput = React.FC;
 export type IWhenShape = unknown;
 export type IThenShape = unknown;
 
-export type ISpec<ITestShape extends IBaseTest> = ITestSpecification<
-  ITestShape
->
-export default <
-  ITestShape extends IBaseTest,
-  IPropShape
->(
-  testImplementations: ITestImplementation<
-    ITestShape, object
-  >,
+export type ISpec<ITestShape extends IBaseTest> =
+  ITestSpecification<ITestShape>;
+export default <ITestShape extends IBaseTest, IPropShape>(
+  testImplementations: ITestImplementation<ITestShape>,
   testSpecifications: ISpec<ITestShape>,
   testInput: IInput
 ) =>
-  test<
-    ITestShape
-  >(
-    testInput,
-    testSpecifications,
-    testImplementations,
-    {
-      beforeEach: function (
-        CComponent,
-        props
-      ): Promise<renderer.ReactTestRenderer> {
-
-        return new Promise((res, rej) => {
-          let component: renderer.ReactTestRenderer;
-          act(() => {
-            component = renderer.create(
-              React.createElement(CComponent, props, [])
-            );
-            res(component);
-          });
-
-        })
-
-      },
-      andWhen: async function (
-        renderer: renderer.ReactTestRenderer,
-        whenCB: () => (a: any) => any
-      ): Promise<renderer.ReactTestRenderer> {
-        await act(() => whenCB()(renderer));
-        return renderer;
-      },
-      afterEach: async (store, key, artificer) => {
-        console.log("afterall")
-        store.unmount();
-      },
-    }
-  );
+  test<ITestShape>(testInput, testSpecifications, testImplementations, {
+    beforeEach: function (
+      CComponent,
+      props
+    ): Promise<renderer.ReactTestRenderer> {
+      return new Promise((res, rej) => {
+        let component: renderer.ReactTestRenderer;
+        act(() => {
+          component = renderer.create(
+            React.createElement(CComponent, props, [])
+          );
+          res(component);
+        });
+      });
+    },
+    andWhen: async function (
+      renderer: renderer.ReactTestRenderer,
+      whenCB: () => (a: any) => any
+    ): Promise<renderer.ReactTestRenderer> {
+      await act(() => whenCB()(renderer));
+      return renderer;
+    },
+    afterEach: async (store, key, artificer) => {
+      console.log("afterall");
+      store.unmount();
+    },
+  });

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

@@ -4,7 +4,7 @@ import renderer, { act } from "react-test-renderer";
 import {
   IBaseTest,
   ITestImplementation,
-  ITestSpecification
+  ITestSpecification,
 } from "../../../Types";
 
 export type IWhenShape = any;
@@ -15,32 +15,26 @@ export type ISelection = renderer.ReactTestRenderer;
 export type IStore = renderer.ReactTestRenderer;
 export type ISubject = renderer.ReactTestRenderer;
 
-export type ITestImpl<
-  ITestShape extends IBaseTest
-> = ITestImplementation<
-  ITestShape, object
->
+export type ITestImpl<ITestShape extends IBaseTest> = ITestImplementation<
+  ITestShape,
+  object
+>;
 
-export type ITestSpec<
-  ITestShape extends IBaseTest
-> = ITestSpecification<
-  ITestShape
->
+export type ITestSpec<ITestShape extends IBaseTest> =
+  ITestSpecification<ITestShape>;
 
 export const testInterface = {
   butThen: async function (s: IStore, thenCB, tr): Promise<ISelection> {
-
-    console.log("butThen", thenCB.toString())
-    // debugger
+    console.log("butThen", thenCB.toString());
     return thenCB(s);
   },
-  beforeEach: function (CComponent, props): Promise<renderer.ReactTestRenderer> {
-    console.log("ASDASDx")
+  beforeEach: function (
+    CComponent,
+    props
+  ): Promise<renderer.ReactTestRenderer> {
     let component;
     act(() => {
-      component = renderer.create(
-        React.createElement(CComponent, props, [])
-      );
+      component = renderer.create(React.createElement(CComponent, props, []));
     });
     return component;
   },
@@ -49,6 +43,6 @@ export const testInterface = {
     whenCB: (any) => any
   ): Promise<renderer.ReactTestRenderer> {
     await act(() => whenCB(renderer));
-    return renderer
-  }
+    return renderer;
+  },
 };

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

@@ -1,24 +1,20 @@
 import test from "../../../Node.js";
 import { IBaseTest } from "../../../Types";
+
 import type { ITestImpl, ITestSpec } from "../jsx-promised";
 
-import {
-  IInput,
-  testInterface
-} from "./index.js";
+import { IInput, testInterface } from "./index.js";
 
 export default <ITestShape extends IBaseTest>(
   testImplementations: ITestImpl<ITestShape>,
   testSpecifications: ITestSpec<ITestShape>,
   testInput: IInput,
-  testInterface2 = testInterface,
+  testInterface2 = testInterface
 ) => {
-  return test<
-    ITestShape
-  >(
+  return test<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
-    testInterface2,
-  )
+    testInterface2
+  );
 };

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

@@ -1,20 +1,20 @@
-import { IInput, testInterface } from "./index.js";
 import { IBaseTest } from "../../../Types";
 import test from "../../../Web.js";
+
 import { ITestImpl, ITestSpec } from "../jsx-promised";
 
+import { IInput, testInterface } from "./index.js";
+
 export default <ITestShape extends IBaseTest>(
   testImplementations: ITestImpl<ITestShape>,
   testSpecifications: ITestSpec<ITestShape>,
   testInput: IInput,
-  testInterface2 = testInterface,
+  testInterface2 = testInterface
 ) => {
-  return test<
-    ITestShape
-  >(
+  return test<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
-    testInterface2,
-  )
+    testInterface2
+  );
 };