testeranto 0.114.1 → 0.125.0

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

@@ -1,37 +1,20 @@
 import Testeranto from "../../../Node.js";
-import { Ibdd_in, Ibdd_out, IPartialInterface } from "../../../Types";
-
 import {
-  ITestImpl,
-  ITestSpec,
-  IInput,
-  testInterface as baseInterface,
-} from "./index.js";
+  IPartialInterface,
+  ITestImplementation,
+  ITestSpecification,
+  OT,
+} from "../../../Types";
+
+import { testInterface as baseInterface, I } from "./index.js";
 
-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: ITestImpl<I, O>,
-  testSpecifications: ITestSpec<I, O>,
-  testInput: IInput,
+export default <O extends OT, M = {}>(
+  testImplementations: ITestImplementation<I, O, M>,
+  testSpecifications: ITestSpecification<I, O>,
+  testInput: I["iinput"],
   testInterface: IPartialInterface<I> = baseInterface
 ) => {
-  return Testeranto<I, O>(
+  return Testeranto<I, O, M>(
     testInput,
     testSpecifications,
     testImplementations,

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

@@ -0,0 +1,23 @@
+import Testeranto from "../../../Pure.js";
+import {
+  IPartialInterface,
+  ITestImplementation,
+  ITestSpecification,
+  OT,
+} from "../../../Types";
+
+import { testInterface as baseInterface, I } from "./index.js";
+
+export default <O extends OT, M = {}>(
+  testImplementations: ITestImplementation<I, O, M>,
+  testSpecifications: ITestSpecification<I, O>,
+  testInput: I["iinput"],
+  testInterface: IPartialInterface<I> = baseInterface
+) => {
+  return Testeranto<I, O, M>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface
+  );
+};

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

@@ -1,43 +1,24 @@
+import Testeranto from "../../../Web.js";
+
 import {
-  Ibdd_in,
-  Ibdd_out,
   IPartialInterface,
-  IPartialWebInterface,
+  ITestImplementation,
+  ITestSpecification,
+  OT,
 } from "../../../Types";
-import Testeranto from "../../../Web.js";
 
-import {
-  ITestImpl,
-  ITestSpec,
-  IInput,
-  testInterface as baseInterface,
-} from "./index.js";
+import { testInterface as baseInterface, I } from "./index.js";
 
-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: ITestImpl<I, O>,
-  testSpecifications: ITestSpec<I, O>,
-  testInput: IInput,
-  testInterface: IPartialWebInterface<I>
+export default <O extends OT, M = {}>(
+  testImplementations: ITestImplementation<I, O, M>,
+  testSpecifications: ITestSpecification<I, O>,
+  testInput: I["iinput"],
+  testInterface: IPartialInterface<I> = baseInterface
 ) => {
-  return Testeranto<I, O>(testInput, testSpecifications, testImplementations, {
-    ...baseInterface,
-    ...testInterface,
-  });
+  return Testeranto<I, O, M>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface
+  );
 };

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

@@ -0,0 +1,107 @@
+import React from "react";
+import ReactDom from "react-dom/client";
+
+import { Ibdd_in, IPartialInterface, ITestInterface } from "../../../Types";
+
+export type IInput = typeof React.Component;
+
+export type ISelection = {
+  htmlElement: HTMLElement;
+  reactElement: any; //CElement<any, any>;
+  domRoot: ReactDom.Root;
+};
+
+export type IStore = {
+  htmlElement: HTMLElement;
+  reactElement: any; //CElement<any, any>,
+  domRoot: ReactDom.Root;
+};
+
+export type ISubject = {
+  htmlElement: HTMLElement;
+  // reactElement: any; //CElement<any, any>,
+  domRoot: ReactDom.Root;
+};
+
+export type I = Ibdd_in<
+  IInput,
+  ISubject,
+  ISelection,
+  IStore,
+  (s: IStore) => IStore,
+  (s: IStore) => IStore,
+  (s: IStore) => IStore
+>;
+
+export const testInterfacer: (
+  testInput: IInput
+) => IPartialInterface<I> = () => {
+  class TesterantoComponent extends React.Component {
+    done: (t: TesterantoComponent) => void;
+    constructor(props) {
+      super(props);
+      this.done = props.done;
+    }
+    componentDidMount() {
+      super.componentDidMount && super.componentDidMount();
+      return this.done(this);
+    }
+  }
+
+  return {
+    beforeAll: async (subject, artificer) => {
+      return await new Promise((resolve, rej) => {
+        const htmlElement = document.getElementById("root");
+        if (htmlElement) {
+          const domRoot = ReactDom.createRoot(htmlElement);
+          resolve({ domRoot, htmlElement });
+        }
+      });
+    },
+    beforeEach: async (
+      { domRoot, htmlElement },
+      initialValues,
+      testResource,
+      artificer
+    ) => {
+      return new Promise(async (resolve, rej) => {
+        domRoot.render(
+          createElement(
+            TesterantoComponent,
+            {
+              ...initialValues,
+              done: (reactElement) => {
+                resolve({
+                  htmlElement,
+                  reactElement,
+                  domRoot,
+                });
+              },
+            },
+            []
+          )
+        );
+      });
+    },
+    andWhen: async function (s, whenCB) {
+      return whenCB(s);
+    },
+    butThen: async function (s, thenCB) {
+      return thenCB(s);
+    },
+    afterEach:
+      testInterface?.afterEach ||
+      async function (store, ndx, utils) {
+        return store;
+      },
+
+    afterAll: async (store, utils) => {
+      // setTimeout(() => {
+      //   console.log("This will run after 1 second");
+      // }, 1000); // 1000 milliseconds = 1 second
+      // store.htmlElement.remove();
+      // store.htmlElement = document.createElement("root");
+      return store;
+    },
+  };
+};

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

@@ -1,122 +1,17 @@
-import React, { ReactNode, createElement } from "react";
-import {
-  renderToStaticMarkup,
-  renderToStaticNodeStream,
-} from "react-dom/server";
-import Stream from "stream";
-
 import Testeranto from "../../../Node.js";
+import { ITestImplementation, ITestSpecification, OT } from "../../../Types";
 
-import {
-  Ibdd_in,
-  Ibdd_out,
-  ITestImplementation,
-  ITestSpecification,
-} from "../../../Types";
-
-type IInput = typeof React.Component;
-
-export type ISelection = ReactNode;
-export type IStore = ReactNode;
-export type ISubject = ReactNode;
+import { I, testInterfacer } from "./static.js";
 
-export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
-
-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>,
+export default <O extends OT, M>(
+  testImplementations: ITestImplementation<I, O, M>,
   testSpecifications: ITestSpecification<I, O>,
-  testInput: IInput
+  testInput: I["iinput"]
 ) => {
-  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;
-    },
-  });
+  return Testeranto<I, O, M>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterfacer(testInput)
+  );
 };
-
-// type IInput = typeof React.Component;
-// type InitialState = unknown;
-// type IWhenShape = any;
-// type IThenShape = any;
-// type ISelection = string;
-// type IStore = string;
-// type ISubject = string
-
-// export default <ITestShape extends ITTestShape>(
-//   testImplementations: ITestImplementation<
-//     InitialState,
-//     ISelection,
-//     IWhenShape,
-//     IThenShape,
-//     ITestShape
-//   >,
-//   testSpecifications: ITestSpecification<
-//     ITestShape,
-//     ISubject,
-//     IStore,
-//     ISelection,
-//     IThenShape
-//   >,
-//   testInput: IInput
-// ) => {
-//   return Testeranto<
-//     ITestShape,
-//     IInput,
-//     ISubject,
-//     IStore,
-//     ISelection,
-//     IThenShape,
-//     IWhenShape,
-//     InitialState
-//   >(
-//     testInput,
-//     testSpecifications,
-//     testImplementations,
-//     {
-//       beforeEach: async (
-//         element,
-//         ndx,
-//         testResource,
-//         artificer
-//       ): Promise<IStore> => {
-//         return new Promise((resolve, rej) => {
-//           resolve(ReactDOMServer.renderToStaticMarkup(element));
-//         });
-//       },
-//       andWhen: function (s: IStore, whenCB): Promise<ISelection> {
-//         throw new Error(`"andWhens" are not permitted`);
-//       }
-//     },
-//   )
-// };

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

@@ -0,0 +1,17 @@
+import Testeranto from "../../../Pure.js";
+import { ITestImplementation, ITestSpecification, OT } from "../../../Types";
+
+import { I, testInterfacer } from "./static.js";
+
+export default <O extends OT, M>(
+  testImplementations: ITestImplementation<I, O, M>,
+  testSpecifications: ITestSpecification<I, O>,
+  testInput: I["iinput"]
+) => {
+  return Testeranto<I, O, M>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterfacer(testInput)
+  );
+};

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

@@ -0,0 +1,41 @@
+import React, { ReactNode, createElement } from "react";
+
+import { Ibdd_in } from "../../../Types";
+
+type IInput = typeof React.Component;
+
+export type ISelection = ReactNode;
+export type IStore = ReactNode;
+export type ISubject = ReactNode;
+
+export type I = Ibdd_in<
+  IInput,
+  ISubject,
+  IStore,
+  ISelection,
+  unknown,
+  (s: IStore) => IStore,
+  unknown
+>;
+
+export const testInterfacer: (testInput: any) => any = (testInput) => {
+  return {
+    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;
+    },
+  };
+};

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

@@ -1,130 +1,24 @@
-import React, { CElement, createElement } from "react";
-import ReactDom from "react-dom/client";
-
 import Testeranto from "../../../Web.js";
 import {
-  Ibdd_in,
-  Ibdd_out,
-  IPartialInterface,
   IPartialWebInterface,
   ITestImplementation,
   ITestSpecification,
+  OT,
 } from "../../../Types";
 
-type IInput = typeof React.Component;
-type ISelection = {
-  htmlElement: HTMLElement;
-  reactElement: any; //CElement<any, any>;
-  domRoot: ReactDom.Root;
-};
-
-export type IStore = {
-  htmlElement: HTMLElement;
-  reactElement: any; //CElement<any, any>,
-  domRoot: ReactDom.Root;
-};
-
-type ISubject = {
-  htmlElement: HTMLElement;
-  // reactElement: any; //CElement<any, any>,
-  domRoot: ReactDom.Root;
-};
+import { I, IInput } from "./dynamic.js";
 
-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>
-  >
->(
+export default <O extends OT, M>(
   testInput: IInput,
   testSpecifications: ITestSpecification<I, O>,
-  testImplementations: ITestImplementation<I, O>,
-  testInterface?: IPartialWebInterface<any>
+  testImplementations: ITestImplementation<I, O, M>,
+  testInterface: IPartialWebInterface<I>
 ) => {
-  class TesterantoComponent extends testInput {
-    done: (t: TesterantoComponent) => void;
-    constructor(props) {
-      super(props);
-      this.done = props.done;
-    }
-    componentDidMount() {
-      super.componentDidMount && super.componentDidMount();
-      return this.done(this);
-    }
-  }
-
-  const t = Testeranto<I, O>(
+  const t = Testeranto<I, O, M>(
     testInput,
     testSpecifications,
     testImplementations,
-    {
-      beforeAll: async (subject, artificer): Promise<ISubject> => {
-        return await new Promise((resolve, rej) => {
-          const htmlElement = document.getElementById("root");
-          if (htmlElement) {
-            const domRoot = ReactDom.createRoot(htmlElement);
-            resolve({ domRoot, htmlElement });
-          }
-        });
-      },
-      beforeEach: async (
-        { domRoot, htmlElement },
-        initialValues,
-        testResource,
-        artificer
-      ): Promise<IStore> => {
-        return new Promise(async (resolve, rej) => {
-          domRoot.render(
-            createElement(
-              TesterantoComponent,
-              {
-                ...initialValues,
-                done: (reactElement) => {
-                  resolve({
-                    htmlElement,
-                    reactElement,
-                    domRoot,
-                  });
-                },
-              },
-              []
-            )
-          );
-        });
-      },
-      andWhen: async function (s, whenCB) {
-        return whenCB(s);
-      },
-      butThen: async function (s, thenCB) {
-        return thenCB(s);
-      },
-      afterEach:
-        testInterface?.afterEach ||
-        async function (store: IStore, ndx, utils) {
-          return store;
-        },
-
-      afterAll: async (store: IStore, utils) => {
-        // setTimeout(() => {
-        //   console.log("This will run after 1 second");
-        // }, 1000); // 1000 milliseconds = 1 second
-        // store.htmlElement.remove();
-        // store.htmlElement = document.createElement("root");
-        return store;
-      },
-    }
+    testInterface
   );
 
   document.addEventListener("DOMContentLoaded", function () {

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

@@ -0,0 +1,46 @@
+import { createElement } from "react";
+
+import { Ibdd_in, IPartialInterface } from "../../../Types";
+
+import { IInput, ISelection, IStore, IWhenShape, IThenShape } from ".";
+
+export type ISubject = HTMLElement;
+
+export type I = Ibdd_in<
+  IInput,
+  ISubject,
+  ISelection,
+  IStore,
+  unknown,
+  IWhenShape,
+  IThenShape
+>;
+
+export const testInterfacer = (
+  testInput: I["iinput"]
+): IPartialInterface<I> => {
+  return {
+    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) {
+      return s;
+    },
+    afterEach: async function (store, ndx, artificer) {
+      return {};
+    },
+    afterAll: (store, artificer) => {
+      return;
+    },
+  };
+};

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

@@ -1,66 +1,18 @@
-import { createElement } from "react";
-import {
-  renderToStaticMarkup,
-  renderToStaticNodeStream,
-} from "react-dom/server";
-import Stream from "stream";
-
 import Testeranto from "../../../Node.js";
-import {
-  Ibdd_in,
-  Ibdd_out,
-  ITestImplementation,
-  ITestSpecification,
-} from "../../../Types";
 
-import { IInput, ISelection, IStore } from "./index.js";
+import { ITestImplementation, ITestSpecification, OT } from "../../../Types";
 
-export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
+import { I, testInterface } from "./static.js";
 
-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>,
+export default <O extends OT, M>(
+  testImplementations: ITestImplementation<I, O, M>,
   testSpecifications: ITestSpecification<I, O>,
   testInput: I["iinput"]
 ) => {
-  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;
-    },
-  });
+  return Testeranto<I, O, M>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface
+  );
 };