testeranto 0.62.0 → 0.70.0

package/src/Report.tsx

@@ -10,8 +10,8 @@ import { Sigma, RandomizeNodePositions, RelativeSize } from 'react-sigma';
 
 import 'bootstrap/dist/css/bootstrap.min.css';
 
-import type { ITestTypes } from "./Types";
 import { TesterantoFeatures } from "./Features.js";
+import { ITestTypes } from "./lib/types.js";
 
 type IGraphData = {
   nodes: { id: string, label: string }[],

package/src/SubPackages/puppeteer.ts

@@ -2,22 +2,27 @@ import React from "react";
 
 import Testeranto from "../Node.js";
 
-import { IBaseTest, IPartialInterface, ITestImplementation, ITestSpecification } from "../Types";
+import {
+  IBaseTest,
+  IPartialNodeInterface,
+  ITestImplementation,
+  ITestSpecification,
+} from "../Types";
 
 type IInput = string;
 type ISelection = any;
-type IStore = any
-type ISubject = any
+type IStore = any;
+type ISubject = any;
 
-export type IImpl<ISpec extends IBaseTest> = ITestImplementation<ISpec, object>
+export type IImpl<ISpec extends IBaseTest> = ITestImplementation<ISpec>;
 
 export type ISpec<T extends IBaseTest> = ITestSpecification<T>;
 
 export default <ITestShape extends IBaseTest>(
   testInput: IInput,
   testSpecifications: ISpec<ITestShape>,
-  testImplementations: ITestImplementation<ITestShape, object>,
-  testInterface?: IPartialInterface<ITestShape>
+  testImplementations: ITestImplementation<ITestShape>,
+  testInterface?: IPartialNodeInterface<ITestShape>
 ) => {
   return Testeranto<ITestShape>(
     testInput,
@@ -25,22 +30,22 @@ export default <ITestShape extends IBaseTest>(
     testImplementations,
     {
       beforeAll(x) {
-        process.parentPort.postMessage(`/dist/web/src/ClassicalComponent/test.html`)
+        process.parentPort.postMessage(
+          `/docs/web/src/ClassicalComponent/test.html`
+        );
 
         return x;
       },
-      beforeEach: async (
-      ): Promise<IStore> => {
+      beforeEach: async (): Promise<IStore> => {
         return new Promise((resolve, rej) => {
-          resolve(React.createElement(testInput, {
-          }, []));
+          resolve(React.createElement(testInput, {}, []));
         });
       },
       andWhen: function (s: IStore, whenCB): Promise<ISelection> {
         return whenCB()(s);
       },
 
-      ...testInterface
-    },
-  )
+      ...testInterface,
+    }
+  );
 };

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

@@ -2,54 +2,42 @@ import React from "react";
 
 import Testeranto from "../../../Node.js";
 
-import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
 
 type IInput = typeof React.Component;
-type ISelection = React.CElement<any, any>
-type IStore = React.CElement<any, any>
-type ISubject = React.CElement<any, any>
+type ISelection = React.CElement<any, any>;
+type IStore = React.CElement<any, any>;
+type ISubject = React.CElement<any, any>;
 
-export type IImpl<
-  ISpec extends IBaseTest,
-  IState
-> = ITestImplementation<
-  ISpec, object
->
-
-export type ISpec<
-  T extends IBaseTest
-> = ITestSpecification<
-  T
+export type IImpl<ISpec extends IBaseTest, IState> = ITestImplementation<
+  ISpec,
+  object
 >;
 
-export default <
-  ITestShape extends IBaseTest,
-  IState
->(
-  testImplementations: ITestImplementation<
-    ITestShape,
-    object
-  >,
+export type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+
+export default <ITestShape extends IBaseTest, IState>(
+  testImplementations: ITestImplementation<ITestShape>,
   testSpecifications: ISpec<ITestShape>,
   testInput: IInput
 ) => {
-  return Testeranto<
-    ITestShape
-  >(
+  return Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
     {
-      beforeEach: async (
-      ): Promise<IStore> => {
+      beforeEach: async (): Promise<IStore> => {
         return new Promise((resolve, rej) => {
-          resolve(React.createElement(testInput, {
-          }, []));
+          resolve(React.createElement(testInput, {}, []));
         });
       },
       andWhen: function (s: IStore, whenCB): Promise<ISelection> {
         return whenCB()(s);
       },
-    },
-  )
+    }
+  );
 };

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

@@ -2,52 +2,42 @@ import React from "react";
 
 import Testeranto from "../../../Web.js";
 
-import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
 
 type IInput = typeof React.Component;
-type ISelection = React.CElement<any, any>
-type Store = React.CElement<any, any>
-type Subject = React.CElement<any, any>
+type ISelection = React.CElement<any, any>;
+type Store = React.CElement<any, any>;
+// type Subject = React.CElement<any, any>;
 
-export type IImpl<
-  ISpec extends IBaseTest,
-  IState
-> = ITestImplementation<
-  ISpec, object
->
-
-export type ISpec<
-  T extends IBaseTest
-> = ITestSpecification<
-  T
+export type IImpl<ISpec extends IBaseTest, IState> = ITestImplementation<
+  ISpec,
+  object
 >;
 
-export default <
-  ITestShape extends IBaseTest,
->(
-  testImplementations: ITestImplementation<
-    ITestShape, object
-  >,
+export type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImplementation<ITestShape>,
   testSpecifications: ISpec<ITestShape>,
   testInput: IInput
 ) => {
-  return Testeranto<
-    ITestShape
-  >(
+  return Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
     {
-      beforeEach: async (
-      ): Promise<Store> => {
+      beforeEach: async (): Promise<Store> => {
         return new Promise((resolve, rej) => {
-          resolve(React.createElement(testInput, {
-          }, []));
+          resolve(React.createElement(testInput, {}, []));
         });
       },
       andWhen: function (s: Store, whenCB): Promise<ISelection> {
         return whenCB()(s);
       },
-    },
-  )
+    }
+  );
 };

package/src/SubPackages/react/jsx/index.ts

@@ -1,43 +1,32 @@
 import { CElement } from "react";
 
 import {
-  IBaseTest, ITestImplementation, ITestSpecification
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
 } from "../../../Types";
 
 export type IWhenShape = any;
 export type IThenShape = any;
 export type InitialState = unknown;
 export type IInput = () => JSX.Element;
-export type ISelection = CElement<any, any>
-export type IStore = CElement<any, any>
-export type ISubject = CElement<any, any>
+export type ISelection = CElement<any, any>;
+export type IStore = CElement<any, any>;
+export type ISubject = CElement<any, any>;
 
-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 (
-    x,
-    ndx,
-    testRsource,
-    artificer
-  ): Promise<IStore> => {
+  beforeEach: async (x, ndx, testRsource, artificer): Promise<IStore> => {
     return new Promise((resolve, rej) => {
-      resolve(x())
+      resolve(x());
     });
   },
   andWhen: function (s: IStore, whenCB): Promise<ISelection> {
     return whenCB(s);
   },
-
-}
+};

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

@@ -1,28 +1,30 @@
-import { IBaseTest, IPartialInterface } from "../../../Types";
+import {
+  IBaseTest,
+  IPartialInterface,
+  IPartialWebInterface,
+} from "../../../Types";
 import Testeranto from "../../../Web.js";
 
 import {
   ITestImpl,
   ITestSpec,
   IInput,
-  testInterface as baseInterface
+  testInterface as baseInterface,
 } from "./index.js";
 
 export default <ITestShape extends IBaseTest>(
   testImplementations: ITestImpl<ITestShape>,
   testSpecifications: ITestSpec<ITestShape>,
   testInput: IInput,
-  testInterface: IPartialInterface<ITestShape>
+  testInterface: IPartialWebInterface<ITestShape>
 ) => {
-  return Testeranto<
-    ITestShape
-  >(
+  return Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
     {
       ...baseInterface,
-      ...testInterface
+      ...testInterface,
     }
-  )
+  );
 };

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

@@ -1,10 +1,17 @@
 import React, { ReactNode, 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, ITestImplementation, ITestSpecification } from "../../../Types";
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
 
 type IInput = typeof React.Component;
 type InitialState = unknown;
@@ -14,22 +21,14 @@ export type ISelection = ReactNode;
 export type IStore = ReactNode;
 export type ISubject = ReactNode;
 
-export {
-  renderToStaticMarkup, renderToStaticNodeStream, Stream
-}
+export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
 
 export default <ITestShape extends IBaseTest>(
-  testImplementations: ITestImplementation<
-    ITestShape, object
-  >,
-  testSpecifications: ITestSpecification<
-    ITestShape
-  >,
+  testImplementations: ITestImplementation<ITestShape>,
+  testSpecifications: ITestSpecification<ITestShape>,
   testInput: IInput
 ) => {
-  return Testeranto<
-    ITestShape
-  >(
+  return Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
@@ -64,21 +63,16 @@ export default <ITestShape extends IBaseTest>(
       butThen: async function (s: IStore): Promise<ISelection> {
         return s;
       },
-      afterEach: async function (
-        store: IStore,
-        ndx,
-        artificer
-      ) {
+      afterEach: async function (store: IStore, ndx, artificer) {
         return {};
       },
       afterAll: (store: IStore, artificer) => {
         return;
       },
-    },
-  )
+    }
+  );
 };
 
-
 // type IInput = typeof React.Component;
 // type InitialState = unknown;
 // type IWhenShape = any;

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

@@ -5,39 +5,29 @@ import Testeranto from "../../../Web.js";
 import {
   IBaseTest,
   ITestImplementation,
-  ITestSpecification
+  ITestSpecification,
 } from "../../../Types";
 
 type IInput = typeof React.Component;
 type InitialState = unknown;
 type ISelection = {
-  htmlElement: HTMLElement,
-  reactElement: CElement<any, any>,
+  htmlElement: HTMLElement;
+  reactElement: any; //CElement<any, any>;
 };
 
 type IStore = {
-  htmlElement: HTMLElement,
-  reactElement: CElement<any, any>,
+  htmlElement: HTMLElement;
+  reactElement: any; //CElement<any, any>,
 };
 
 type ISubject = {
-  htmlElement: HTMLElement
+  htmlElement: HTMLElement;
 };
 
-export default <
-  ITestShape extends IBaseTest,
-  IWhen,
-  IGiven
->(
+export default <ITestShape extends IBaseTest, IWhen, IGiven>(
   testInput: IInput,
-  testSpecifications: ITestSpecification<
-    ITestShape
-  >,
-  testImplementations: ITestImplementation<
-    ITestShape,
-    any
-  >,
-
+  testSpecifications: ITestSpecification<ITestShape>,
+  testImplementations: ITestImplementation<ITestShape, any>
 ) => {
   document.addEventListener("DOMContentLoaded", function () {
     const elem = document.getElementById("root");
@@ -54,25 +44,19 @@ export default <
         }
       }
 
-      return Testeranto<
-        ITestShape
-      >(
+      return Testeranto<ITestShape>(
         testInput,
         testSpecifications,
         testImplementations,
         {
-          beforeAll: async (
-            initialProps,
-            artificer
-          ): Promise<ISubject> => {
+          beforeAll: async (initialProps, artificer): Promise<ISubject> => {
             console.log("mark5", initialProps);
             return await new Promise((resolve, rej) => {
               const elem = document.getElementById("root");
               if (elem) {
                 resolve({ htmlElement: elem });
               }
-
-            })
+            });
           },
           beforeEach: async (
             { htmlElement },
@@ -84,19 +68,21 @@ export default <
             return new Promise((resolve, rej) => {
               // console.log("beforeEach" + JSON.stringify(initializer) + JSON.stringify(initialValues));
               // Ignore these type errors
-              ReactDom.createRoot(htmlElement).render(createElement(
-                TesterantoComponent, {
-                ...initializer.props,
-                done: (reactElement) => {
-                  resolve(
-                    {
-                      htmlElement,
-                      reactElement,
-                    }
-                  );
-                }
-              }, []
-              ));
+              ReactDom.createRoot(htmlElement).render(
+                createElement(
+                  TesterantoComponent,
+                  {
+                    ...initializer,
+                    done: (reactElement) => {
+                      resolve({
+                        htmlElement,
+                        reactElement,
+                      });
+                    },
+                  },
+                  []
+                )
+              );
             });
           },
           andWhen: function (s: IStore, whenCB): Promise<ISelection> {
@@ -105,20 +91,14 @@ export default <
           butThen: async function (s: IStore): Promise<ISelection> {
             return s;
           },
-          afterEach: async function (
-            store: IStore,
-            ndx,
-            artificer
-          ) {
+          afterEach: async function (store: IStore, ndx, artificer) {
             return {};
           },
           afterAll: (store: IStore, artificer) => {
             return;
           },
-        },
-      )
+        }
+      );
     }
   });
-
-
 };

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({});
+              });
             });
           },
-        },
-      )
+        }
+      );
     }
   });
 };