testeranto 0.79.5 → 0.79.6

package/dist/module/SubPackages/react-dom/component/node.js

@@ -1,93 +0,0 @@
-import { createElement } from "react";
-import { renderToStaticMarkup, renderToStaticNodeStream, } from "react-dom/server";
-import Stream from "stream";
-import Testeranto from "../../../Node.js";
-export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
-export default (testImplementations, testSpecifications, testInput) => {
-    return Testeranto(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) => {
-            return new Promise((resolve, rej) => {
-                // Ignore these type errors
-                resolve(createElement(testInput));
-            });
-        },
-        andWhen: async function (s, whenCB) {
-            return whenCB(s);
-            // return s
-        },
-        butThen: async function (s) {
-            return s;
-        },
-        afterEach: async function (store, ndx, artificer) {
-            return {};
-        },
-        afterAll: (store, 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, whenCB): Promise<ISelection> {
-//         throw new Error(`"andWhens" are not permitted`);
-//       }
-//     },
-//   )
-// };

package/dist/module/SubPackages/react-dom/component/web.js

@@ -1,88 +0,0 @@
-import { createElement } from "react";
-import ReactDom from "react-dom/client";
-import Testeranto from "../../../Web.js";
-export default (testInput, testSpecifications, testImplementations, testInterface) => {
-    class TesterantoComponent extends testInput {
-        constructor(props) {
-            super(props);
-            this.done = props.done;
-        }
-        componentDidMount() {
-            super.componentDidMount && super.componentDidMount();
-            return this.done(this);
-        }
-    }
-    const t = Testeranto(testInput, testSpecifications, testImplementations, {
-        beforeAll: async (initialProps, artificer) => {
-            return await new Promise((resolve, rej) => {
-                const htmlElement = document.getElementById("root");
-                if (htmlElement) {
-                    const domRoot = ReactDom.createRoot(htmlElement);
-                    // Ignore these type errors
-                    domRoot.render(createElement(TesterantoComponent, Object.assign(Object.assign({}, initialProps), { done: (reactElement) => {
-                            resolve({
-                                htmlElement,
-                                reactElement,
-                                domRoot,
-                            });
-                        } }), []));
-                    // resolve({ htmlElement });
-                }
-            });
-        },
-        // beforeEach: async (
-        //   s,
-        //   initializer,
-        //   testResource,
-        //   artificer,
-        //   initialValues
-        // ): Promise<IStore> => {
-        //   return new Promise((resolve, rej) => {
-        //     console.log("beforeEach" + TesterantoComponent);
-        //     // const domRoot = ReactDom.createRoot(htmlElement);
-        //     // // Ignore these type errors
-        //     // domRoot.render(
-        //     //   createElement(
-        //     //     TesterantoComponent,
-        //     //     {
-        //     //       ...initializer,
-        //     //       done: (reactElement) => {
-        //     //         resolve({
-        //     //           htmlElement,
-        //     //           reactElement,
-        //     //           domRoot,
-        //     //         });
-        //     //       },
-        //     //     },
-        //     //     []
-        //     //   )
-        //     // );
-        //   });
-        // },
-        andWhen: function (s, whenCB) {
-            return whenCB(s);
-        },
-        butThen: async function (s, thenCB) {
-            return thenCB(s);
-        },
-        afterEach: (testInterface === null || testInterface === void 0 ? void 0 : testInterface.afterEach) ||
-            async function (store, ndx, artificer, utils) {
-                return store;
-            },
-        afterAll: async (store, artificer, 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;
-        },
-    });
-    document.addEventListener("DOMContentLoaded", function () {
-        const elem = document.getElementById("root");
-        if (elem) {
-            return t;
-        }
-    });
-    return t;
-};

package/dist/module/SubPackages/react-dom/jsx/index.js

@@ -1 +0,0 @@
-export {};

package/dist/module/SubPackages/react-dom/jsx/node.js

@@ -1,31 +0,0 @@
-import { createElement } from "react";
-import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
-import Stream from 'stream';
-import Testeranto from "../../../Node.js";
-export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
-export default (testImplementations, testSpecifications, testInput) => {
-    return Testeranto(testInput, testSpecifications, testImplementations, {
-        beforeAll: async (prototype, artificer) => {
-            return await new Promise((resolve, rej) => {
-                resolve(null);
-            });
-        },
-        beforeEach: async (reactComponent, ndx, testRsource, artificer) => {
-            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/dist/module/SubPackages/react-dom/jsx/web.js

@@ -1,90 +0,0 @@
-import React, { useEffect, useRef } from "react";
-import { createElement } from "react";
-import ReactDom from "react-dom/client";
-import { createPortal } from "react-dom";
-import Testeranto from "../../../Web.js";
-export default (testImplementations, testSpecifications, testInput) => {
-    console.log("testInput", testInput);
-    const TesterantoComponent = function ({ done, innerComp, }) {
-        const myContainer = useRef(null);
-        useEffect(() => {
-            console.log("useEffect called!", myContainer.current);
-            done(myContainer.current);
-        }, []);
-        // debugger;
-        return React.createElement("div", { ref: myContainer }, innerComp());
-    };
-    const t = Testeranto(testInput, testSpecifications, testImplementations, {
-        beforeAll: async (reactElement, itr) => {
-            return await new Promise((resolve, rej) => {
-                const htmlElement = document.getElementById("root");
-                if (htmlElement) {
-                    const domRoot = ReactDom.createRoot(htmlElement);
-                    domRoot.render(createElement(TesterantoComponent, {
-                        // ...initialProps,
-                        innerComp: reactElement,
-                        done: (reactElement) => {
-                            resolve({
-                                htmlElement,
-                                reactElement,
-                                domRoot,
-                            });
-                        },
-                    }, []));
-                    // resolve({ htmlElement });
-                }
-            });
-        },
-        beforeEach: async (subject, initializer, artificer, testResource, pm) => {
-            return new Promise((resolve, rej) => {
-                createPortal(TesterantoComponent({
-                    innerComp: () => testInput({
-                        port: 3003,
-                        address: "some-address",
-                        secretKey: "someSecretKey",
-                        abi: "foo",
-                    }),
-                    done: (reactElement) => {
-                        process.nextTick(() => {
-                            resolve(reactElement);
-                        });
-                    },
-                }), subject.domRoot);
-            });
-        },
-        andWhen: function (s, whenCB) {
-            return new Promise((resolve, rej) => {
-                process.nextTick(() => {
-                    resolve(whenCB()(s));
-                });
-            });
-        },
-        butThen: async function (s) {
-            return new Promise((resolve, rej) => {
-                process.nextTick(() => {
-                    resolve(s);
-                });
-            });
-        },
-        afterEach: async function (store, ndx, artificer) {
-            return new Promise((resolve, rej) => {
-                process.nextTick(() => {
-                    resolve({});
-                });
-            });
-        },
-        afterAll: (store, artificer) => {
-            return new Promise((resolve, rej) => {
-                process.nextTick(() => {
-                    resolve({});
-                });
-            });
-        },
-    });
-    document.addEventListener("DOMContentLoaded", function () {
-        const rootElement = document.getElementById("root");
-        if (rootElement) {
-        }
-    });
-    return t;
-};

package/dist/module/SubPackages/react-test-renderer/MemoExoticComponent/node.js

@@ -1,16 +0,0 @@
-import React from "react";
-import renderer, { act } from "react-test-renderer";
-import test from "../../../Node";
-export default (testImplementations, testSpecifications, testInput) => test(testInput, testSpecifications, testImplementations, {
-    beforeEach: function (CComponent, props) {
-        let component;
-        act(() => {
-            component = renderer.create(React.createElement(CComponent, props, []));
-        });
-        return component;
-    },
-    andWhen: async function (renderer, whenCB) {
-        await act(() => whenCB()(renderer));
-        return renderer;
-    },
-});

package/dist/module/SubPackages/react-test-renderer/component/index.js

@@ -1 +0,0 @@
-export {};

package/dist/module/SubPackages/react-test-renderer/component/interface.js

@@ -1,39 +0,0 @@
-import React from "react";
-import renderer, { act } from "react-test-renderer";
-export const testInterface = {
-    beforeEach: function (CComponent, propsAndChildren) {
-        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, whenCB) {
-        // console.log("andWhen", whenCB)
-        await act(() => whenCB(renderer));
-        return renderer;
-    },
-    // andWhen: function (s: Store, whenCB): Promise<Selection> {
-    //   return whenCB()(s);
-    // },
-    butThen: async function (s, thenCB, tr) {
-        console.log("butThen", thenCB.toString());
-        return thenCB(s);
-    },
-    afterEach: async function (store, ndx, artificer) {
-        // console.log("afterEach", store);
-        return {};
-    },
-    afterAll: (store, artificer) => {
-        // console.log("afterAll", store);
-        return;
-    },
-};

package/dist/module/SubPackages/react-test-renderer/component/node.js

@@ -1,3 +0,0 @@
-import Testeranto from "../../../Node.js";
-import { testInterface } from "./interface.js";
-export default (testImplementations, testSpecifications, testInput) => Testeranto(testInput, testSpecifications, testImplementations, testInterface);

package/dist/module/SubPackages/react-test-renderer/component/web.js

@@ -1,3 +0,0 @@
-import Testeranto from "../../../Web.js";
-import { testInterface } from "./interface";
-export default (testImplementations, testSpecifications, testInput) => Testeranto(testInput, testSpecifications, testImplementations, testInterface);

package/dist/module/SubPackages/react-test-renderer/fc/node.js

@@ -1,22 +0,0 @@
-import React from "react";
-import renderer, { act } from "react-test-renderer";
-import test from "../../../Node.js";
-export default (testImplementations, testSpecifications, testInput) => test(testInput, testSpecifications, testImplementations, {
-    beforeEach: function (CComponent, props) {
-        return new Promise((res, rej) => {
-            let component;
-            act(() => {
-                component = renderer.create(React.createElement(CComponent, props, []));
-                res(component);
-            });
-        });
-    },
-    andWhen: async function (renderer, whenCB) {
-        await act(() => whenCB()(renderer));
-        return renderer;
-    },
-    afterEach: async (store, key, artificer) => {
-        console.log("afterall");
-        store.unmount();
-    },
-});

package/dist/module/SubPackages/react-test-renderer/fc/web.js

@@ -1,22 +0,0 @@
-import React from "react";
-import renderer, { act } from "react-test-renderer";
-import test from "../../../Web.js";
-export default (testImplementations, testSpecifications, testInput) => test(testInput, testSpecifications, testImplementations, {
-    beforeEach: function (CComponent, props) {
-        return new Promise((res, rej) => {
-            let component;
-            act(() => {
-                component = renderer.create(React.createElement(CComponent, props, []));
-                res(component);
-            });
-        });
-    },
-    andWhen: async function (renderer, whenCB) {
-        await act(() => whenCB()(renderer));
-        return renderer;
-    },
-    afterEach: async (store, key, artificer) => {
-        console.log("afterall");
-        store.unmount();
-    },
-});

package/dist/module/SubPackages/react-test-renderer/jsx/index.js

@@ -1,19 +0,0 @@
-import React from "react";
-import renderer, { act } from "react-test-renderer";
-export const testInterface = {
-    butThen: async function (s, thenCB, tr) {
-        console.log("butThen", thenCB.toString());
-        return thenCB(s);
-    },
-    beforeEach: function (CComponent, props) {
-        let component;
-        act(() => {
-            component = renderer.create(React.createElement(CComponent, props, []));
-        });
-        return component;
-    },
-    andWhen: async function (renderer, whenCB) {
-        await act(() => whenCB(renderer));
-        return renderer;
-    },
-};

package/dist/module/SubPackages/react-test-renderer/jsx/node.js

@@ -1,5 +0,0 @@
-import test from "../../../Node.js";
-import { testInterface } from "./index.js";
-export default (testImplementations, testSpecifications, testInput, testInterface2 = testInterface) => {
-    return test(testInput, testSpecifications, testImplementations, testInterface2);
-};

package/dist/module/SubPackages/react-test-renderer/jsx/web.js

@@ -1,5 +0,0 @@
-import test from "../../../Web.js";
-import { testInterface } from "./index.js";
-export default (testImplementations, testSpecifications, testInput, testInterface2 = testInterface) => {
-    return test(testInput, testSpecifications, testImplementations, testInterface2);
-};

package/dist/module/SubPackages/react-test-renderer/jsx-promised/index.js

@@ -1,16 +0,0 @@
-import renderer, { act } from "react-test-renderer";
-export const testInterface = {
-    beforeEach: async (CComponent) => {
-        return new Promise((res, rej) => {
-            let component;
-            act(async () => {
-                component = renderer.create(CComponent);
-            });
-            res(component);
-        });
-    },
-    andWhen: async function (renderer, whenCB) {
-        await act(() => whenCB()(renderer));
-        return renderer;
-    },
-};

package/dist/module/SubPackages/react-test-renderer/jsx-promised/node.js

@@ -1,5 +0,0 @@
-import { testInterface } from ".";
-import test from "../../../Node";
-export default (testImplementations, testSpecifications, testInput) => {
-    return test(testInput, testSpecifications, testImplementations, testInterface);
-};

package/dist/module/SubPackages/react-test-renderer/jsx-promised/web.js

@@ -1,5 +0,0 @@
-import test from "../../../Web";
-import { testInterface } from "./index";
-export default (testImplementations, testSpecifications, testInput) => {
-    return test(testInput, testSpecifications, testImplementations, testInterface);
-};

package/dist/module/TaskManBackEnd.js

@@ -1,169 +0,0 @@
-import express from "express";
-import { MongoClient } from "mongodb";
-import mongoose from "mongoose";
-import path from "path";
-import fs from "fs";
-import { ganttSchema, kanbanSchema, userSchema, featuresSchema, RoomSchema, HuddleSchema, channelsFeature, chatCatMessageSchema, } from "./mongooseSchemas";
-// export const chatChannel = new mongoose.Schema<IChatChannel>({
-//   // name: { type: String, required: true },
-//   users: [
-//     {
-//       type: mongoose.Schema.Types.ObjectId,
-//       ref: "User",
-//       required: true,
-//     },
-//   ],
-// });
-const app = express();
-const port = 3000;
-function findTextFiles(dir, fileList = []) {
-    const files = fs.readdirSync(dir);
-    for (const file of files) {
-        const filePath = path.join(dir, file);
-        const fileStat = fs.statSync(filePath);
-        if (fileStat.isDirectory() && file !== "node_modules") {
-            findTextFiles(filePath, fileList); // Recursive call for subdirectories
-        }
-        else if (path.extname(file) === ".txt") {
-            fileList.push(filePath);
-        }
-        else if (path.extname(file) === ".md") {
-            fileList.push(filePath);
-        }
-    }
-    return fileList;
-}
-function listToTree(fileList) {
-    const root = {
-        name: "root",
-        children: [],
-    };
-    for (const path of fileList) {
-        const parts = path.split("/");
-        let current = root;
-        for (let i = 0; i < parts.length; i++) {
-            const part = parts[i];
-            if (!part)
-                continue; // Skip empty parts (e.g., from leading '/')
-            let child = current.children.find((c) => c.name === part);
-            if (!child) {
-                child = { name: part, children: [] };
-                current.children.push(child);
-            }
-            current = child;
-        }
-    }
-    return root.children;
-}
-new MongoClient(`mongodb://${process.env.MONGO_HOST || "127.0.0.1"}:27017`)
-    .connect()
-    .then(async (conn) => {
-    const db = conn.db("taskman");
-    await mongoose.connect(`mongodb://${process.env.MONGO_HOST || "127.0.0.1"}:27017/taskman`);
-    const usersModel = mongoose.model("User", userSchema);
-    const kanbanModel = mongoose.model("Kanban", kanbanSchema);
-    const ganttModel = mongoose.model("Gantt", ganttSchema);
-    const featuresModel = mongoose.model("Features", featuresSchema);
-    // const roomsModel = mongoose.model<any>("Rooms", RoomSchema);
-    // const huddleModdle = mongoose.model<any>("Huddles", HuddleSchema);
-    const MessagesModel = mongoose.model("Messages", chatCatMessageSchema);
-    const ChatChannel = mongoose.model("ChatChannel", channelsFeature);
-    const huddleModdle = ChatChannel.discriminator("Huddle", HuddleSchema);
-    const roomsModel = ChatChannel.discriminator("Room", RoomSchema);
-    app.get("/TaskManFrontend.js", (req, res) => {
-        res.sendFile(`${process.cwd()}/TaskManFrontEnd.js`);
-    });
-    app.get("/TaskManFrontEnd.css", (req, res) => {
-        res.sendFile(`${process.cwd()}/TaskManFrontEnd.css`);
-    });
-    // app.get(`/preMergeCheck`, async (req, res) => {
-    //   const commit = req.params["commit"];
-    //   // res.json(await keyedModels[key].find({}));
-    // });
-    // app.get("/TaskManFrontend.js", (req, res) => {
-    //   res.sendFile(
-    //     `${process.cwd()}/node_modules/testeranto/dist/prebuild/TaskManFrontEnd.js`
-    //   );
-    // });
-    // app.get("/TaskManFrontEnd.css", (req, res) => {
-    //   res.sendFile(
-    //     `${process.cwd()}/node_modules/testeranto/dist/prebuild/TaskManFrontEnd.css`
-    //   );
-    // });
-    app.get("/testeranto.json", (req, res) => {
-        res.sendFile(`${process.cwd()}/docs/testeranto.json`);
-    });
-    app.get("/", (req, res) => {
-        res.send(`<!DOCTYPE html>
-<html lang="en">
-
-<head>
-  <meta name="description" content="Webpage description goes here" />
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <meta name="author" content="" />
-
-  <title>TaskMan</title>
-
-  <link rel="stylesheet" href="/TaskManFrontEnd.css" />
-  <script type="module" src="/TaskManFrontEnd.js"></script>
-</head>
-
-<body><div id="root">react is loading</div></body>
-
-</html>`);
-    });
-    app.listen(port, () => {
-        console.log(`Example app listening on port ${port}`);
-    });
-    ///////////////////////////////////////////////
-    const keyedModels = {
-        users: usersModel,
-        kanbans: kanbanModel,
-        features: featuresModel,
-        gantts: ganttModel,
-        rooms: roomsModel,
-        huddles: huddleModdle,
-        messages: MessagesModel,
-    };
-    Object.keys(keyedModels).forEach((key) => {
-        app.get(`/${key}.json`, async (req, res) => {
-            console.log("GET", key, keyedModels[key]);
-            res.json(await keyedModels[key].find({}));
-        });
-        app.get(`/${key}/:id.json`, async (req, res) => {
-            res.json(await keyedModels[key]
-                .find({ id: { $eq: req.params["id"] } })
-                .toArray());
-        });
-        app.post(`/${key}/:id.json`, async (req, res) => {
-            res.json(await keyedModels[key]
-                .find({ id: { $eq: req.params["id"] } })
-                .toArray());
-        });
-        app.post(`/${key}.json`, async (req, res) => {
-            res.json(await keyedModels[key]
-                .find({ id: { $eq: req.params["id"] } })
-                .toArray());
-        });
-    });
-    app.use("/docs", express.static(path.join(process.cwd(), "docs")));
-    app.get("/docGal/fs.json", (req, res) => {
-        const directoryPath = "./"; // Replace with the desired directory path
-        // const textFiles = findTextFiles(directoryPath);
-        res.json(listToTree(findTextFiles(directoryPath)));
-        //     res.send(`<!DOCTYPE html>
-        // <html lang="en">
-        // <head>
-        //   <meta name="description" content="Webpage description goes here" />
-        //   <meta charset="utf-8" />
-        //   <meta name="viewport" content="width=device-width, initial-scale=1" />
-        //   <meta name="author" content="" />
-        //   <title>TaskMan</title>
-        //   <link rel="stylesheet" href="/TaskManFrontEnd.css" />
-        //   <script type="module" src="/TaskManFrontEnd.js"></script>
-        // </head>
-        // <body><div id="root">react is loading</div></body>
-        // </html>`);
-    });
-});