testeranto 0.47.30 → 0.47.31

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

@@ -1,4 +1,4 @@
-import React, { CElement } from "react";
+import React, { CElement, createElement } from "react";
 import ReactDom from "react-dom/client";
 
 import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
@@ -39,81 +39,91 @@ export default <ITestShape extends ITTestShape>(
   >,
   testInput: IInput
 ) => {
-  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) => {
-          document.addEventListener("DOMContentLoaded", function () {
-            const elem = document.getElementById("root");
-            if (elem) {
-              resolve({ htmlElement: elem });
-            }
-          });
-        })
-      },
-      beforeEach: async (
-        { htmlElement },
-        ndx,
-        testRsource,
-        artificer
-      ): Promise<IStore> => {
-        return new Promise((resolve, rej) => {
-          const reactElement = React.createElement(TesterantoComponent, {
-            done: (reactElement) => {
-              resolve(
-                {
-                  htmlElement,
-                  reactElement,
+  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,
+                    }
+                  );
                 }
-              );
-            }
-          }, []);
-          ReactDom.createRoot(htmlElement).render(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;
-      },
-    },
-  )
+              }, []
+              ));
+            });
+          },
+          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

@@ -0,0 +1,150 @@
+import React, { ReactNode, createElement } from "react";
+import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
+import Stream from 'stream'
+
+import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
+import Testeranto from "../../../Node";
+
+export type IInput = () => JSX.Element;
+type InitialState = unknown;
+type IWhenShape = any;
+export type IThenShape = any;
+export type ISelection = ReactNode;
+export type IStore = ReactNode;
+export type ISubject = ReactNode;
+
+export {
+  renderToStaticMarkup, renderToStaticNodeStream, Stream
+}
+
+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,
+    {
+      // beforeAll: async (
+      //   prototype,
+      //   artificer
+      // ): Promise<ISubject> => {
+      //   return await new Promise((resolve, rej) => {
+      //     const elem = document.getElementById("root");
+      //     if (elem) {
+      //       resolve({ htmlElement: elem });
+      //     }
+
+      //   })
+      // },
+      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-test-renderer/component/index.ts

@@ -0,0 +1,101 @@
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+
+import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
+
+export type ISuper<T> = T extends infer U ? U : object;
+
+// export type IInput<P, S> = React.Component<P, S>
+export type IInput<P, S> = typeof React.Component<P, S>;
+export type InitialState = unknown;
+export type IWhenShape = any;
+export type IThenShape = any;
+export type ISelection = renderer.ReactTestRenderer;
+export type IStore = renderer.ReactTestRenderer;
+export type ISubject = renderer.ReactTestRenderer;
+
+export type IImpl<
+  ITestShape extends ITTestShape,
+  IProps
+> = ITestImplementation<
+  IProps,
+  renderer.ReactTestRenderer,
+  IWhenShape,
+  IThenShape,
+  ITestShape
+>
+export type ISpec<
+  ITestShape extends ITTestShape
+> = ITestSpecification<
+  ITestShape,
+  ISubject,
+  IStore,
+  ISelection,
+  IThenShape
+>
+
+// 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,
+//     actioner: () => (any) => any
+//   ): Promise<renderer.ReactTestRenderer> {
+//     await act(() => actioner()(renderer));
+//     return renderer
+//   }
+// }
+
+export const testInterface = {
+  beforeEach: function (CComponent, props): Promise<renderer.ReactTestRenderer> {
+
+    return new Promise((res, rej) => {
+      act(() => {
+        const x = renderer.create(new CComponent(props));
+        console.log("beforeEach", x.getInstance())
+        res(x);
+      });
+    });
+  },
+  andWhen: async function (
+    renderer: renderer.ReactTestRenderer,
+    actioner: any
+  ): Promise<renderer.ReactTestRenderer> {
+    // console.log("andWhen", renderer)
+    await act(() => actioner()(renderer));
+    return renderer
+  },
+
+  // andWhen: function (s: Store, actioner): Promise<Selection> {
+  //   return actioner()(s);
+  // },
+  butThen: async function (s: IStore): Promise<ISelection> {
+
+    // console.log("butThen", s)
+    return 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

@@ -0,0 +1,30 @@
+import Testeranto from "../../../Node";
+
+import { ITTestShape } from "../../../core";
+
+import { IImpl, ISpec, IInput, testInterface } from ".";
+
+export default <
+  ITestShape extends ITTestShape,
+  IProps,
+  IState
+>(
+  testImplementations: IImpl<ITestShape, IProps>,
+  testSpecifications: ISpec<ITestShape>,
+  testInput: IInput<IProps, IState>,
+) =>
+  Testeranto<
+    ITestShape,
+    IInput<IProps, IState>,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any
+  >(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface
+  )

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

@@ -0,0 +1,30 @@
+import Testeranto from "../../../Web";
+
+import { ITTestShape } from "../../../core";
+
+import { IImpl, ISpec, IInput, testInterface } from ".";
+
+export default <
+  ITestShape extends ITTestShape,
+  IProps,
+  IState
+>(
+  testImplementations: IImpl<ITestShape, IProps>,
+  testSpecifications: ISpec<ITestShape>,
+  testInput: IInput<IProps, IState>,
+) =>
+  Testeranto<
+    ITestShape,
+    IInput<IProps, IState>,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any
+  >(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface
+  )

package/src/subPackages/react-test-renderer/jsx/index.ts

@@ -0,0 +1,51 @@
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+
+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 = renderer.ReactTestRenderer;
+export type IStore = renderer.ReactTestRenderer;
+export type ISubject = renderer.ReactTestRenderer;
+
+export type ITestImpl<
+  ITestShape extends ITTestShape
+> = ITestImplementation<
+  InitialState,
+  ISelection,
+  IWhenShape,
+  IThenShape,
+  ITestShape
+>
+
+export type ITestSpec<
+  ITestShape extends ITTestShape
+> = ITestSpecification<
+  ITestShape,
+  ISubject,
+  IStore,
+  ISelection,
+  IThenShape
+>
+
+export const testInterface = {
+  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,
+    actioner: () => (any) => any
+  ): Promise<renderer.ReactTestRenderer> {
+    await act(() => actioner()(renderer));
+    return renderer
+  }
+}

package/src/subPackages/react-test-renderer/jsx/node.ts

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

package/src/subPackages/react-test-renderer/jsx/web.ts

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

package/dist/common/subPackages/react-test-render/component/node.js

@@ -1,44 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = __importDefault(require("react"));
-const react_test_renderer_1 = __importStar(require("react-test-renderer"));
-const Node_1 = __importDefault(require("../../../Node"));
-exports.default = (testImplementations, testSpecifications, testInput) => (0, Node_1.default)(testInput, testSpecifications, testImplementations, {
-    beforeEach: function (CComponent, props) {
-        let component;
-        (0, react_test_renderer_1.act)(() => {
-            component = react_test_renderer_1.default.create(react_1.default.createElement(CComponent, props, []));
-        });
-        return component;
-    },
-    andWhen: async function (renderer, actioner) {
-        await (0, react_test_renderer_1.act)(() => actioner()(renderer));
-        return renderer;
-    }
-});

package/dist/common/subPackages/react-test-render/jsx/node.js

@@ -1,46 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReactTestRendererTesteranto = void 0;
-const react_1 = __importDefault(require("react"));
-const react_test_renderer_1 = __importStar(require("react-test-renderer"));
-const Web_1 = __importDefault(require("../../../Web"));
-const ReactTestRendererTesteranto = (testImplementations, testSpecifications, testInput) => (0, Web_1.default)(testInput, testSpecifications, testImplementations, {
-    beforeEach: function (CComponent, props) {
-        let component;
-        (0, react_test_renderer_1.act)(() => {
-            component = react_test_renderer_1.default.create(react_1.default.createElement(CComponent, props, []));
-        });
-        return component;
-    },
-    andWhen: async function (renderer, actioner) {
-        await (0, react_test_renderer_1.act)(() => actioner()(renderer));
-        return renderer;
-    }
-});
-exports.ReactTestRendererTesteranto = ReactTestRendererTesteranto;