testeranto 0.74.0 → 0.79.0

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

@@ -1,4 +1,6 @@
 import React, { useEffect, useRef } from "react";
+import { CElement, createElement } from "react";
+import ReactDom from "react-dom/client";
 import { createPortal } from "react-dom";
 
 import Testeranto from "../../../Web.js";
@@ -12,91 +14,123 @@ import type { IInput, ISelection, IStore } from "./index";
 
 export type ISubject = HTMLElement;
 
+const TesterantoComponent = ({
+  done,
+  innerComp,
+}: {
+  done: (ref: React.MutableRefObject<any>) => any;
+  innerComp: IInput;
+}) => {
+  const myContainer = useRef<any>(null);
+  useEffect(() => {
+    console.log("useEffect called!", myContainer.current);
+    done(myContainer.current);
+  }, []);
+
+  return React.createElement("div", { ref: myContainer }, innerComp());
+};
+
 export default <ITestShape extends IBaseTest>(
   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 myContainer = useRef<any>(null);
-        useEffect(() => {
-          console.log("useEffect called", myContainer.current);
-          done(myContainer.current);
-        }, []);
+  const t = Testeranto<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeAll: async (reactElement, itr): Promise<any> => {
+        return await new Promise((resolve, rej) => {
+          const htmlElement = document.getElementById("root");
 
-        return React.createElement("div", { ref: myContainer }, innerComp());
-      };
+          if (htmlElement) {
+            const domRoot = ReactDom.createRoot(htmlElement);
 
-      Testeranto<ITestShape>(
-        testInput,
-        testSpecifications,
-        testImplementations,
-        {
-          beforeAll: async (input, artificer): Promise<HTMLElement> => {
-            return await new Promise((resolve, rej) => {
-              resolve(rootElement);
-            });
-          },
-
-          beforeEach: async (
-            subject,
-            ndx,
-            testRsource,
-            artificer
-          ): Promise<IStore> => {
-            return new Promise((resolve, rej) => {
-              createPortal(
-                TesterantoComponent({
-                  innerComp: testInput,
-                  done: (reactElement: any) => {
-                    process.nextTick(() => {
-                      resolve(reactElement);
+            domRoot.render(
+              createElement(
+                TesterantoComponent,
+                {
+                  // ...initialProps,
+                  innerComp: reactElement,
+                  done: (reactElement) => {
+                    resolve({
+                      htmlElement,
+                      reactElement,
+                      domRoot,
                     });
                   },
-                }),
-                rootElement
-              );
-            });
-          },
-          andWhen: function (s: IStore, whenCB): Promise<ISelection> {
-            return new Promise((resolve, rej) => {
-              process.nextTick(() => {
-                resolve(whenCB()(s));
-              });
-            });
-          },
-          butThen: async function (s: IStore): Promise<ISelection> {
-            return new Promise((resolve, rej) => {
-              process.nextTick(() => {
-                resolve(s);
-              });
-            });
-          },
-          afterEach: async function (store: IStore, ndx, artificer) {
-            return new Promise((resolve, rej) => {
-              process.nextTick(() => {
-                resolve({});
-              });
-            });
-          },
-          afterAll: (store: IStore, artificer) => {
-            return new Promise((resolve, rej) => {
-              process.nextTick(() => {
-                resolve({});
-              });
-            });
-          },
-        }
-      );
+                },
+                []
+              )
+            );
+
+            // resolve({ htmlElement });
+          }
+        });
+      },
+
+      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);
+        });
+      },
+      andWhen: function (s: IStore, whenCB, tr, utils): Promise<ISelection> {
+        return new Promise((resolve, rej) => {
+          console.log("mark9", s, whenCB);
+          resolve(whenCB(s, utils));
+          // process.nextTick(() => {
+          //   resolve(whenCB()(s));
+          // });
+        });
+      },
+      butThen: async function (s: IStore, thenCB): Promise<ISelection> {
+        return new Promise((resolve, rej) => {
+          resolve(thenCB(s));
+        });
+      },
+      afterEach: async function (store: IStore, ndx, artificer) {
+        return new Promise((resolve, rej) => {
+          resolve({});
+        });
+      },
+      afterAll: (store: IStore, artificer) => {
+        return new Promise((resolve, rej) => {
+          resolve({});
+        });
+      },
+    }
+  );
+
+  document.addEventListener("DOMContentLoaded", function () {
+    const rootElement = document.getElementById("root");
+    if (rootElement) {
     }
   });
+
+  return t;
 };

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

@@ -21,69 +21,3 @@ 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> {
-//     return new Promise((res, rej) => {
-//       let component: renderer.ReactTestRenderer;
-//       act(() => {
-//         component = renderer.create(
-//           CComponent(props)
-//         );
-//         res(component);
-//       });
-//     });
-//   },
-//   andWhen: async function (
-//     renderer: renderer.ReactTestRenderer,
-//     whenCB: () => (any) => any
-//   ): Promise<renderer.ReactTestRenderer> {
-//     await act(() => whenCB()(renderer));
-//     return renderer
-//   }
-// }
-
-export const testInterface = {
-  beforeEach: function (
-    CComponent,
-    propsAndChildren
-  ): Promise<renderer.ReactTestRenderer> {
-    function Link(props) {
-      const p = props.props;
-      const c = props.children;
-      return React.createElement(CComponent, p, c);
-    }
-    return new Promise((res, rej) => {
-      act(async () => {
-        const p = propsAndChildren;
-        const y = new CComponent(p.props);
-        const testRenderer = await renderer.create(Link(propsAndChildren));
-        res(testRenderer);
-      });
-    });
-  },
-  andWhen: async function (
-    renderer: renderer.ReactTestRenderer,
-    whenCB: any
-  ): Promise<renderer.ReactTestRenderer> {
-    // console.log("andWhen", whenCB)
-    await act(() => whenCB(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());
-    return thenCB(s);
-  },
-  afterEach: async function (store: IStore, ndx, artificer) {
-    // console.log("afterEach", store);
-    return {};
-  },
-  afterAll: (store: IStore, artificer) => {
-    // console.log("afterAll", store);
-    return;
-  },
-};

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

@@ -0,0 +1,48 @@
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+import { ISelection, IStore } from ".";
+
+export const testInterface = {
+  beforeEach: function (
+    CComponent,
+    propsAndChildren
+  ): Promise<renderer.ReactTestRenderer> {
+    function Link(props) {
+      const p = props.props;
+      const c = props.children;
+      return React.createElement(CComponent, p, c);
+    }
+    return new Promise((res, rej) => {
+      act(async () => {
+        const p = propsAndChildren;
+        const y = new CComponent(p.props);
+        const testRenderer = await renderer.create(Link(propsAndChildren));
+        res(testRenderer);
+      });
+    });
+  },
+  andWhen: async function (
+    renderer: renderer.ReactTestRenderer,
+    whenCB: any
+  ): Promise<renderer.ReactTestRenderer> {
+    // console.log("andWhen", whenCB)
+    await act(() => whenCB(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());
+    return thenCB(s);
+  },
+  afterEach: async function (store: IStore, ndx, artificer) {
+    // console.log("afterEach", store);
+    return {};
+  },
+  afterAll: (store: IStore, artificer) => {
+    // console.log("afterAll", store);
+    return;
+  },
+};

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

@@ -1,7 +1,8 @@
 import Testeranto from "../../../Node.js";
 import type { IBaseTest } from "../../../Types";
 
-import { IImpl, ISpec, IInput, testInterface } from "./index.js";
+import { IImpl, ISpec, IInput } from "./index.js";
+import { testInterface } from "./interface.js";
 
 export default <ITestShape extends IBaseTest, IProps, IState>(
   testImplementations: IImpl<ITestShape>,

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

@@ -1,7 +1,8 @@
 import { IBaseTest } from "../../../Types";
 import Testeranto from "../../../Web.js";
 
-import { IImpl, ISpec, IInput, testInterface } from "./index.js";
+import { IImpl, ISpec, IInput } from "./index.js";
+import { testInterface } from "./interface";
 
 export default <ITestShape extends IBaseTest, IProps, IState>(
   testImplementations: IImpl<ITestShape>,

package/src/Types.ts

@@ -13,17 +13,74 @@ import {
   ITestInterface,
   IWebTestInterface,
 } from "./lib/types.js";
+import { PM } from "./PM/index.js";
 
-export type IPartialInterface<I extends IBaseTest> = Partial<ITestInterface<I>>;
+export 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 type IPartialNodeInterface<I extends IBaseTest> = Partial<
-  INodeTestInterface<I>
->;
-export type IPartialWebInterface<I extends IBaseTest> = Partial<
-  IWebTestInterface<I>
->;
+export 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 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 type IEntry<ITestShape extends IBaseTest> = (
+export 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>,
@@ -31,7 +88,22 @@ export type IEntry<ITestShape extends IBaseTest> = (
   testResourceRequirement: ITTestResourceRequest
 ) => Promise<Testeranto<ITestShape>>;
 
-export type ITestSpecification<ITestShape extends IBaseTest> = (
+export 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,
@@ -61,7 +133,20 @@ export type ITestSpecification<ITestShape extends IBaseTest> = (
 ) => any[];
 
 export type ITestImplementation<
-  ITestShape extends IBaseTest,
+  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<
   {
@@ -76,7 +161,7 @@ export type ITestImplementation<
     whens: {
       [K in keyof ITestShape["whens"]]: (
         ...Iw: ITestShape["whens"][K]
-      ) => (zel: ITestShape["iselection"]) => ITestShape["when"];
+      ) => (zel: ITestShape["iselection"], utils: PM) => ITestShape["when"];
     };
     thens: {
       [K in keyof ITestShape["thens"]]: (
@@ -94,24 +179,48 @@ export type ITestImplementation<
 
 type Modify<T, R> = Omit<T, keyof R> & R;
 
-export type IBaseTest<Shape = any, II = Shape> = {
-  iinput: II;
-  isubject: Shape;
-  istore: Shape;
-  iselection: Shape;
-  // iinitial;
+// export type IBaseTest<Shape = any, II = Shape> = {
+//   iinput: II;
+//   isubject: Shape;
+//   istore: Shape;
+//   iselection: Shape;
+//   // iinitial;
 
-  given;
-  when;
-  then;
-
-  suites: Record<string, any>;
-  givens: Record<string, any>;
-  whens: Record<string, any>;
-  thens: Record<string, any>;
-  checks: Record<string, any>;
-};
-
-// export type ITTestShape = {
+//   given;
+//   when;
+//   then;
 
+//   suites: Record<string, any>;
+//   givens: Record<string, any>;
+//   whens: Record<string, any>;
+//   thens: Record<string, any>;
+//   checks: Record<string, any>;
 // };
+
+export 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;
+};

package/src/Web.ts

@@ -12,7 +12,22 @@ import {
 } from "./lib/index.js";
 import { ITestInterface, IWebTestInterface } from "./lib/types";
 
-class WebTesteranto<TestShape extends IBaseTest> extends Testeranto<TestShape> {
+class WebTesteranto<
+  TestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> extends Testeranto<TestShape> {
   constructor(
     input: TestShape["iinput"],
     testSpecification: ITestSpecification<TestShape>,
@@ -55,7 +70,22 @@ class WebTesteranto<TestShape extends IBaseTest> extends Testeranto<TestShape> {
   }
 }
 
-export default async <ITestShape extends IBaseTest>(
+export default async <
+  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>,

package/src/esbuildConfigs/index.ts

@@ -4,6 +4,7 @@ import { IBaseConfig } from "../lib/types";
 
 export default (config: IBaseConfig): BuildOptions => {
   return {
+    // packages: "external",
     target: "esnext",
     format: "esm",
     splitting: true,

package/src/esbuildConfigs/inputFilesPlugin.ts

@@ -0,0 +1,67 @@
+import fs from "fs";
+import path from "path";
+
+export default (
+  platform: "web" | "node",
+  entryPoints: Set<string> | string[]
+) => {
+  console.log("mark3", platform);
+
+  return {
+    name: "metafileWriter",
+    setup(build) {
+      build.onEnd((result) => {
+        if (result.errors.length === 0) {
+          entryPoints.forEach((entryPoint) => {
+            console.log("mark1", entryPoint);
+            const filePath = path.join(
+              "./docs/",
+              platform,
+              entryPoint.split(".").slice(0, -1).join("."),
+              `inputFiles.json`
+            );
+
+            const dirName = path.dirname(filePath);
+
+            if (!fs.existsSync(dirName)) {
+              fs.mkdirSync(dirName, { recursive: true });
+            }
+
+            const jsonContent = JSON.stringify(
+              Object.keys(
+                Object.keys(result.metafile.outputs)
+                  .filter((s: string) => {
+                    if (!result.metafile.outputs[s].entryPoint) {
+                      return false;
+                    }
+                    return (
+                      path.resolve(result.metafile.outputs[s].entryPoint) ===
+                      path.resolve(entryPoint)
+                    );
+                  })
+                  .reduce((mm: string[], el) => {
+                    mm.push(result.metafile.outputs[el].inputs);
+                    return mm;
+                  }, [])[0]
+              )
+                .filter((f: string) => {
+                  const regex = /^src\/.*/g;
+                  const matches = f.match(regex);
+                  const passes = matches?.length === 1;
+                  return passes;
+                })
+                .filter((f: string) => {
+                  const regex = /.*\.test\..*/g;
+                  const matches = f.match(regex);
+                  const passes = matches?.length === 1;
+                  return !passes;
+                })
+            );
+
+            fs.writeFileSync(filePath, jsonContent);
+          });
+        }
+      });
+    },
+  };
+};