testeranto 0.62.0 → 0.70.0

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,27 @@ 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> {
+    console.log("ASDASDx");
     let component;
     act(() => {
-      component = renderer.create(
-        React.createElement(CComponent, props, [])
-      );
+      component = renderer.create(React.createElement(CComponent, props, []));
     });
     return component;
   },
@@ -49,6 +44,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
+  );
 };

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

@@ -1,6 +1,10 @@
 import renderer, { act } from "react-test-renderer";
 
-import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
 
 export type IWhenShape = any;
 export type IThenShape = any;
@@ -10,17 +14,11 @@ 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>;
 
-export type ITestSpec<
-  ITestShape extends IBaseTest
-> = ITestSpecification<
-  ITestShape
->
+export type ITestSpec<ITestShape extends IBaseTest> =
+  ITestSpecification<ITestShape>;
 
 export const testInterface = {
   beforeEach: async (CComponent): Promise<renderer.ReactTestRenderer> => {
@@ -30,14 +28,13 @@ export const testInterface = {
         component = renderer.create(CComponent);
       });
       res(component);
-    })
-
+    });
   },
   andWhen: async function (
     renderer: renderer.ReactTestRenderer,
     whenCB: () => (any) => any
   ): Promise<renderer.ReactTestRenderer> {
     await act(() => whenCB()(renderer));
-    return renderer
-  }
-}
+    return renderer;
+  },
+};