testeranto 0.47.34 → 0.47.52

package/src/electron.ts

@@ -1,59 +0,0 @@
-import { app, BrowserWindow, ipcMain } from "electron";
-import path from "path";
-import url from "url";
-
-let win: BrowserWindow;
-
-function createWindow() {
-  win = new BrowserWindow({
-
-    webPreferences: {
-      devTools: true,
-      nodeIntegration: true,
-      nodeIntegrationInWorker: true,
-      contextIsolation: false,
-      preload: path.join(app.getAppPath(), 'preload.js'),
-      sandbox: false
-
-    },
-    width: 800,
-    height: 600,
-    show: false,
-  });
-  const u = url.format({
-    pathname: path.join(process.cwd(), process.argv[2]),
-    protocol: "file:",
-    slashes: true,
-    query: {
-      requesting: encodeURIComponent(process.argv[3]),
-    }
-  });
-  console.log("loading", u);
-  win.loadURL(u);
-  win.webContents.openDevTools()
-}
-
-app.on("ready", createWindow);
-
-ipcMain.handle('web-log', (x, message: string) => {
-  console.log("web-log)", message);
-});
-
-ipcMain.handle('web-error', (x, message: string) => {
-  console.log("web-error)", message);
-});
-
-ipcMain.handle('web-warn', (x, message: string) => {
-  console.log("web-warn)", message);
-});
-
-ipcMain.handle('web-info', (x, message: string) => {
-  console.log("web-info)", message);
-});
-
-ipcMain.handle('quit-app', (x, failed: number) => {
-  console.log("quit-app", failed);
-  app.exit(failed);
-});
-
-export { };

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,150 +0,0 @@
-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`);
-//       }
-//     },
-//   )
-// };