testeranto 0.49.10 → 0.70.0

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

@@ -1,75 +0,0 @@
-import React from "react";
-
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
-import Testeranto from "../../../Node";
-
-type IWhenShape = any;
-type IThenShape = any;
-
-type IInput = typeof React.Component;
-type ISelection = React.CElement<any, any>
-type IStore = React.CElement<any, any>
-type ISubject = React.CElement<any, any>
-
-export type IImpl<
-  ISpec extends ITTestShape,
-  IState
-> = ITestImplementation<
-  IState,
-  ISelection,
-  IWhenShape,
-  IThenShape,
-  ISpec
->
-
-export type ISpec<
-  T extends ITTestShape
-> = ITestSpecification<
-  T,
-  ISubject,
-  IStore,
-  ISelection,
-  IThenShape
->;
-
-export default <
-  ITestShape extends ITTestShape,
-  IState
->(
-  testImplementations: ITestImplementation<
-    IState,
-    ISelection,
-    IWhenShape,
-    IThenShape,
-    ITestShape
-  >,
-  testSpecifications: ISpec<ITestShape>,
-  testInput: IInput
-) => {
-  return Testeranto<
-    ITestShape,
-    IInput,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape,
-    IWhenShape,
-    IState
-  >(
-    testInput,
-    testSpecifications,
-    testImplementations,
-    {
-      beforeEach: async (
-      ): Promise<IStore> => {
-        return new Promise((resolve, rej) => {
-          resolve(React.createElement(testInput, {
-          }, []));
-        });
-      },
-      andWhen: function (s: IStore, actioner): Promise<ISelection> {
-        return actioner()(s);
-      },
-    },
-  )
-};

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

@@ -1,80 +0,0 @@
-import React from "react";
-
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
-import Testeranto from "../../../Web";
-
-import { CElement } from "react";
-
-type IWhenShape = any;
-type IThenShape = any;
-
-type Super<T> = T extends infer U ? U : object;
-
-type IInput = typeof React.Component;  //Super<React.Element>;  //number;  //typeof React.Component;
-// type IState  is the props
-type ISelection = React.CElement<any, any>
-type Store = React.CElement<any, any>
-type Subject = React.CElement<any, any>
-
-export type IImpl<
-  ISpec extends ITTestShape,
-  IState
-> = ITestImplementation<
-  IState,
-  ISelection,
-  IWhenShape,
-  IThenShape,
-  ISpec
->
-
-export type ISpec<
-  T extends ITTestShape
-> = ITestSpecification<
-  T,
-  Subject,
-  Store,
-  ISelection,
-  IThenShape
->;
-
-export default <
-  ITestShape extends ITTestShape,
-  IState
->(
-  testImplementations: ITestImplementation<
-    IState,
-    ISelection,
-    IWhenShape,
-    IThenShape,
-    ITestShape
-  >,
-  testSpecifications: ISpec<ITestShape>,
-  testInput: IInput
-) => {
-  return Testeranto<
-    ITestShape,
-    IInput,
-    Subject,
-    Store,
-    ISelection,
-    IThenShape,
-    IWhenShape,
-    IState
-  >(
-    testInput,
-    testSpecifications,
-    testImplementations,
-    {
-      beforeEach: async (
-      ): Promise<Store> => {
-        return new Promise((resolve, rej) => {
-          resolve(React.createElement(testInput, {
-          }, []));
-        });
-      },
-      andWhen: function (s: Store, actioner): Promise<ISelection> {
-        return actioner()(s);
-      },
-    },
-  )
-};

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

@@ -1,64 +0,0 @@
-import { CElement, useEffect, useRef } from "react";
-import React from "react";
-
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
-
-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 ITestImpl<
-  ITestShape extends ITTestShape
-> = ITestImplementation<
-  InitialState,
-  ISelection,
-  IWhenShape,
-  IThenShape,
-  ITestShape
->
-
-export type ITestSpec<
-  ITestShape extends ITTestShape
-> = ITestSpecification<
-  ITestShape,
-  ISubject,
-  IStore,
-  ISelection,
-  IThenShape
->
-
-// const TesterantoComponent = (testInput) => (props) => {
-//   const myContainer = useRef(null);
-
-//   useEffect(() => {
-//     console.log(
-//       "useeffectCalled"
-//     );
-
-//     props.done(myContainer.current);
-//   }, []);
-
-//   return React.createElement('div', { ref: myContainer }, testInput());  //testInput();
-// };
-
-export const testInterface = (testInput) => {
-  return {
-    beforeEach: async (
-      x,
-      ndx,
-      testRsource,
-      artificer
-    ): Promise<IStore> => {
-      return new Promise((resolve, rej) => {
-        resolve(testInput())
-      });
-    },
-    andWhen: function (s: IStore, actioner): Promise<ISelection> {
-      return actioner()(s);
-    },
-  }
-}

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

@@ -1,29 +0,0 @@
-import Testeranto from "../../../Node";
-
-import { ITTestShape } from "../../../core";
-
-import {
-  ITestImpl, ITestSpec, IInput, ISubject, IStore, ISelection, IThenShape, IWhenShape, InitialState, testInterface
-} from ".";
-
-export default <ITestShape extends ITTestShape>(
-  testImplementations: ITestImpl<ITestShape>,
-  testSpecifications: ITestSpec<ITestShape>,
-  testInput: IInput
-) => {
-  return Testeranto<
-    ITestShape,
-    IInput,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape,
-    IWhenShape,
-    InitialState
-  >(
-    testInput,
-    testSpecifications,
-    testImplementations,
-    testInterface(testInput),
-  )
-};

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

@@ -1,29 +0,0 @@
-import Testeranto from "../../../Web";
-
-import { ITTestShape } from "../../../core";
-
-import {
-  ITestImpl, ITestSpec, IInput, ISubject, IStore, ISelection, IThenShape, IWhenShape, InitialState, testInterface
-} from ".";
-
-export default <ITestShape extends ITTestShape>(
-  testImplementations: ITestImpl<ITestShape>,
-  testSpecifications: ITestSpec<ITestShape>,
-  testInput: IInput
-) => {
-  return Testeranto<
-    ITestShape,
-    IInput,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape,
-    IWhenShape,
-    InitialState
-  >(
-    testInput,
-    testSpecifications,
-    testImplementations,
-    testInterface(testInput),
-  )
-};

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

@@ -1,129 +0,0 @@
-import React, { CElement, createElement } from "react";
-import ReactDom from "react-dom/client";
-
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
-import Testeranto from "../../../Web";
-
-type IInput = typeof React.Component;
-type InitialState = unknown;
-type IWhenShape = any;
-type IThenShape = any;
-type ISelection = {
-  htmlElement: HTMLElement,
-  reactElement: CElement<any, any>,
-};
-
-type IStore = {
-  htmlElement: HTMLElement,
-  reactElement: CElement<any, any>,
-};
-
-type ISubject = {
-  htmlElement: HTMLElement
-};
-
-export default <ITestShape extends ITTestShape>(
-  testImplementations: ITestImplementation<
-    InitialState,
-    ISelection,
-    IWhenShape,
-    IThenShape,
-    ITestShape
-  >,
-  testSpecifications: ITestSpecification<
-    ITestShape,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape
-  >,
-  testInput: IInput
-) => {
-
-  document.addEventListener("DOMContentLoaded", function () {
-    console.log("DOMContentLoaded")
-    const elem = document.getElementById("root");
-    if (elem) {
-      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);
-        }
-      }
-
-      return Testeranto<
-        ITestShape,
-        IInput,
-        ISubject,
-        IStore,
-        ISelection,
-        IThenShape,
-        IWhenShape,
-        InitialState
-      >(
-        testInput,
-        testSpecifications,
-        testImplementations,
-        {
-          beforeAll: async (
-            prototype,
-            artificer
-          ): Promise<ISubject> => {
-            return await new Promise((resolve, rej) => {
-              const elem = document.getElementById("root");
-              if (elem) {
-                resolve({ htmlElement: elem });
-              }
-
-            })
-          },
-          beforeEach: async (
-            { htmlElement },
-            ndx,
-            testRsource,
-            artificer
-          ): Promise<IStore> => {
-            return new Promise((resolve, rej) => {
-              // Ignore these type errors
-              ReactDom.createRoot(htmlElement).render(createElement(
-                TesterantoComponent, {
-                done: (reactElement) => {
-                  resolve(
-                    {
-                      htmlElement,
-                      reactElement,
-                    }
-                  );
-                }
-              }, []
-              ));
-            });
-          },
-          andWhen: function (s: IStore, actioner): Promise<ISelection> {
-            return actioner()(s);
-          },
-          butThen: async function (s: IStore): Promise<ISelection> {
-            return s;
-          },
-          afterEach: async function (
-            store: IStore,
-            ndx,
-            artificer
-          ) {
-            return {};
-          },
-          afterAll: (store: IStore, artificer) => {
-            return;
-          },
-        },
-      )
-    }
-  });
-
-
-};

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

@@ -1,145 +0,0 @@
-import Testeranto from "../../../Node";
-
-import React, { ReactNode, createElement } from "react";
-import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
-import Stream from 'stream'
-
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
-import {
-  IInput, ISelection, IStore,
-  // ISubject,
-  IThenShape, IWhenShape, IState
-} from ".";
-
-type ISubject = void;
-export {
-  renderToStaticMarkup, renderToStaticNodeStream, Stream
-}
-
-export default <ITestShape extends ITTestShape>(
-  testImplementations: ITestImplementation<
-    IState,
-    ISelection,
-    IWhenShape,
-    IThenShape,
-    ITestShape
-  >,
-  testSpecifications: ITestSpecification<
-    ITestShape,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape
-  >,
-  testInput: IInput
-) => {
-  return Testeranto<
-    ITestShape,
-    IInput,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape,
-    IWhenShape,
-    IState
-  >(
-    testInput,
-    testSpecifications,
-    testImplementations,
-    {
-      beforeAll: async (
-        prototype,
-        artificer
-      ): Promise<ISubject> => {
-        return await new Promise((resolve, rej) => {
-          resolve();
-        })
-      },
-      beforeEach: async (
-        reactComponent,
-        ndx,
-        testRsource,
-        artificer
-      ): Promise<IStore> => {
-        return new Promise((resolve, rej) => {
-          // Ignore these type errors
-          resolve(createElement(testInput));
-        });
-      },
-      andWhen: async function (s: IStore, actioner): Promise<ISelection> {
-        // return actioner()(s);
-        return s
-      },
-      butThen: async function (s: IStore): Promise<ISelection> {
-        return s;
-      },
-      afterEach: async function (
-        store: IStore,
-        ndx,
-        artificer
-      ) {
-        return {};
-      },
-      afterAll: (store: IStore, artificer) => {
-        return;
-      },
-    },
-  )
-};
-
-
-// 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, actioner): Promise<ISelection> {
-//         throw new Error(`"andWhens" are not permitted`);
-//       }
-//     },
-//   )
-// };

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

@@ -1,145 +0,0 @@
-import Testeranto from "../../../Web";
-
-import React, {
-  useEffect, useRef,
-} from "react";
-import ReactDom from "react-dom/client";
-import { createPortal } from 'react-dom';
-
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
-import {
-  IInput, ISelection, IStore,
-  IThenShape, IWhenShape, IState
-} from ".";
-
-export type ISubject = HTMLElement;
-
-export default <
-  ITestShape extends ITTestShape,
-  IProps
->(
-  testImplementations: ITestImplementation<
-    IState,
-    ISelection,
-    IWhenShape,
-    IThenShape,
-    ITestShape
-  >,
-  testSpecifications: ITestSpecification<
-    ITestShape,
-    // [HTMLElement, IProps], // ISubject,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape
-  >,
-  testInput: IInput
-) => {
-  document.addEventListener("DOMContentLoaded", function () {
-    console.log("DOMContentLoaded");
-    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
-          );
-
-          // if (!myContainer.current) {
-          //   // do componentDidMount logic
-          //   myContainer.current = true;
-          // } else {
-          //   // do componentDidUpdate logic
-          // }
-
-          done(myContainer.current);
-        }, []);
-
-        return React.createElement(
-          'div',
-          { ref: myContainer },
-          innerComp()
-        );
-      };
-
-      Testeranto<
-        ITestShape,
-        IInput,
-        // [HTMLElement, IProps], // ISubject,
-        ISubject,
-        IStore,
-        ISelection,
-        IThenShape,
-        IWhenShape,
-        IState
-      >(
-        testInput,
-        testSpecifications,
-        testImplementations,
-        {
-          beforeAll: async (
-            input,
-            artificer
-          ): Promise<HTMLElement> => {
-            console.log("beforeAll", input);
-            return await new Promise((resolve, rej) => {
-              resolve(rootElement);
-            })
-          },
-
-          beforeEach: async (
-            subject,
-            ndx,
-            testRsource,
-            artificer
-          ): Promise<IStore> => {
-            return new Promise((resolve, rej) => {
-
-              console.log("beforeEach", subject);
-
-              createPortal(
-                TesterantoComponent({
-                  innerComp: testInput,
-                  done: (reactElement: any) => {
-                    process.nextTick(() => {
-                      resolve(reactElement)// do something
-                    })
-                  }
-                }
-                  ,
-                ),
-                rootElement
-              );
-            });
-          },
-          andWhen: function (s: IStore, actioner): Promise<ISelection> {
-            return new Promise((resolve, rej) => {
-              process.nextTick(() => { resolve(actioner()(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({}) })
-            });
-          },
-        },
-      )
-    }
-  });
-};