testeranto 0.81.3 → 0.84.0

package/dist/module/src/SubPackages/react-dom/jsx/web.js

@@ -1,6 +1,6 @@
 import React, { useEffect, useRef } from "react";
 import { createElement } from "react";
-import ReactDom from "react-dom/client";
+import ReactDom from "react-dom";
 import Testeranto from "../../../Web.js";
 const TesterantoComponent = ({ done, innerComp, }) => {
     const myContainer = useRef(null);
@@ -56,17 +56,17 @@ export default (testImplementations, testSpecifications, testInput) => {
             });
         },
         andWhen: function (s, whenCB, tr, utils) {
-            return new Promise((resolve, rej) => {
-                console.log("mark9", s, whenCB);
-                resolve(whenCB(s, utils));
-                // process.nextTick(() => {
-                //   resolve(whenCB()(s));
-                // });
-            });
+            return whenCB(s, utils);
+            // return new Promise(async (resolve, rej) => {
+            //   // resolve(await whenCB(s, utils));
+            //   // process.nextTick(() => {
+            //   //   resolve(whenCB()(s));
+            //   // });
+            // });
         },
-        butThen: async function (s, thenCB) {
+        butThen: async function (s, thenCB, tr, utils) {
             return new Promise((resolve, rej) => {
-                resolve(thenCB(s));
+                resolve(thenCB(s, utils));
             });
         },
         afterEach: async function (store, ndx, artificer) {

package/dist/module/src/Web.js

@@ -1,15 +1,19 @@
 import { PM_Web } from "./PM/web";
 import Testeranto from "./lib/core.js";
 import { defaultTestResourceRequirement, } from "./lib/index.js";
-class WebTesteranto extends Testeranto {
+export class WebTesteranto extends Testeranto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
         super(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
     }
     async receiveTestResourceConfig(partialTestResource) {
         const t = partialTestResource; //JSON.parse(partialTestResource);
         const pm = new PM_Web(t);
-        const { failed, artifacts, logPromise } = await this.testJobs[0].receiveTestResourceConfig(pm);
+        const { failed, artifacts, logPromise, features } = await this.testJobs[0].receiveTestResourceConfig(pm);
         pm.customclose();
+        return new Promise((res, rej) => {
+            res(features);
+        });
+        // return features;
         // Promise.all([...artifacts, logPromise]).then(async () => {
         //   console.log("hello world");
         //   pm.customclose();

package/dist/module/src/esbuildConfigs/featuresPlugin.js

@@ -0,0 +1,34 @@
+import path from "path";
+export default {
+    name: "feature-markdown",
+    setup(build) {
+        build.onResolve({ filter: /\.md$/ }, (args) => {
+            if (args.resolveDir === "")
+                return;
+            return {
+                path: path.isAbsolute(args.path)
+                    ? args.path
+                    : path.join(args.resolveDir, args.path),
+                namespace: "feature-markdown",
+            };
+        });
+        build.onLoad({ filter: /.*/, namespace: "feature-markdown" }, async (args) => {
+            // const markdownContent = new TextDecoder().decode(
+            //   await fs.readFileSync(args.path)
+            // );
+            // markdownHTML = marked(markdownContent, options?.markedOptions);
+            return {
+                contents: `file://${args.path}`,
+                loader: "text",
+                // contents: JSON.stringify({ path: args.path }),
+                // loader: "json",
+                // contents: JSON.stringify({
+                //   // html: markdownHTML,
+                //   raw: markdownContent,
+                //   filename: args.path, //path.basename(args.path),
+                // }),
+                // loader: "json",
+            };
+        });
+    },
+};

package/dist/module/src/esbuildConfigs/inputFilesPlugin.js

@@ -1,74 +1,72 @@
 import fs from "fs";
 import path from "path";
+const otherInputs = {};
+const register = (entrypoint, sources) => {
+    console.log("register", entrypoint, sources);
+    if (!otherInputs[entrypoint]) {
+        otherInputs[entrypoint] = new Set();
+    }
+    sources.forEach((s) => otherInputs[entrypoint].add(s));
+};
+function tree(meta, key) {
+    return [
+        key,
+        ...meta.inputs[key].imports
+            .filter((x) => x.external !== true)
+            .filter((x) => x.path.split("/")[0] !== "node_modules")
+            .map((f) => f.path),
+    ];
+}
 export default (platform, entryPoints) => {
     return {
-        name: "metafileWriter",
-        setup(build) {
-            build.onEnd((result) => {
-                if (result.errors.length === 0) {
-                    entryPoints.forEach((entryPoint) => {
-                        const filePath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `inputFiles.json`);
-                        const promptPath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `prompt.txt`);
-                        const testPaths = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `tests.json`);
-                        const dirName = path.dirname(filePath);
-                        if (!fs.existsSync(dirName)) {
-                            fs.mkdirSync(dirName, { recursive: true });
-                        }
-                        const j = Object.keys(Object.keys(result.metafile.outputs)
-                            .filter((s) => {
-                            if (!result.metafile.outputs[s].entryPoint) {
-                                return false;
+        register,
+        inputFilesPluginFactory: {
+            name: "metafileWriter",
+            setup(build) {
+                build.onEnd((result) => {
+                    fs.writeFileSync(`docs/${platform}/metafile.json`, JSON.stringify(result, null, 2));
+                    if (result.errors.length === 0) {
+                        entryPoints.forEach((entryPoint) => {
+                            const filePath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `inputFiles.json`);
+                            const dirName = path.dirname(filePath);
+                            if (!fs.existsSync(dirName)) {
+                                fs.mkdirSync(dirName, { recursive: true });
                             }
-                            return (path.resolve(result.metafile.outputs[s].entryPoint) ===
-                                path.resolve(entryPoint));
-                        })
-                            .reduce((mm, el) => {
-                            mm.push(result.metafile.outputs[el].inputs);
-                            return mm;
-                        }, [])[0]).filter((f) => {
-                            const regex = /^src\/.*/g;
-                            const matches = f.match(regex);
-                            const passes = (matches === null || matches === void 0 ? void 0 : matches.length) === 1;
-                            return passes;
-                        });
-                        // .filter((f: string) => {
-                        //   const regex = /.*\.test\..*/g;
-                        //   const matches = f.match(regex);
-                        //   const passes = matches?.length === 1;
-                        //   return !passes;
-                        // })
-                        const jsonContent = JSON.stringify(j);
-                        fs.writeFileSync(filePath, jsonContent);
-                        fs.writeFileSync(promptPath, `
-${j
-                            .map((x) => {
-                            return `/add ${x}`;
-                        })
-                            .join("\n")}
+                            const promptPath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `prompt.txt`);
+                            const testPaths = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `tests.json`);
+                            const featuresPath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `featurePrompt.txt`); // /read ${featuresPath}
+                            if (result.metafile) {
+                                const addableFiles = tree(result.metafile, entryPoint.split("/").slice(1).join("/"))
+                                    .map((y) => {
+                                    if (otherInputs[y]) {
+                                        return Array.from(otherInputs[y]);
+                                    }
+                                    return y;
+                                })
+                                    .flat();
+                                fs.writeFileSync(promptPath, `
+${[...addableFiles]
+                                    .map((x) => {
+                                    return `/add ${x}`;
+                                })
+                                    .join("\n")}
+${[...addableFiles]
+                                    .map((x) => {
+                                    const f = `docs/ts/${x}.type_errors.txt`;
+                                    if (fs.existsSync(f)) {
+                                        return `/read ${f}`;
+                                    }
+                                })
+                                    .join("\n")}
 /read ${testPaths}
-  
-/code fix the failing tests described in ${filePath}.
+/load ${featuresPath}
+/code Fix the failing tests described in ${testPaths}. Correct any type signature errors. Implement any method which throws "Function not implemented."
 `);
-                        //             fs.writeFileSync(
-                        //               promptPath,
-                        //               `
-                        // from aider.coders import Coder
-                        // from aider.models import Model
-                        // import os
-                        // model = Model("deepseek")
-                        // coder = Coder.create(main_model=model)
-                        // coder.run("/read-only", "${testPaths}")
-                        // ${j
-                        //   .map((x) => {
-                        //     return `coder.run("/add", "${x}")`;
-                        //   })
-                        //   .join("\n")}
-                        // coder.run("fix the failing tests described in ${filePath}.")
-                        // `
-                        //             );
-                    });
-                }
-            });
+                            }
+                        });
+                    }
+                });
+            },
         },
     };
 };

package/dist/module/src/esbuildConfigs/node.js

@@ -1,6 +1,10 @@
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
+import featuresPlugin from "./featuresPlugin";
 export default (config, entryPoints) => {
+    const { inputFilesPluginFactory, register } = inputFilesPlugin("node", entryPoints);
+    // const inputFilesPluginFactory = inputFilesPlugin("node", entryPoints);
+    // const register = (x) => x;
     return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: config.outdir + "/node", 
         // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
         metafile: true, supported: {
@@ -12,13 +16,16 @@ export default (config, entryPoints) => {
         }, platform: "node", external: [
             // "testeranto.json",
             // "features.test.js",
-            // "react",
+            "react",
             // "events",
             // "ganache"
             ...config.externals,
         ], entryPoints: [...entryPoints], plugins: [
-            ...(config.nodePlugins || []),
-            inputFilesPlugin("node", entryPoints),
+            featuresPlugin,
+            // markdownPlugin({}),
+            ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
+            inputFilesPluginFactory,
+            // inputFilesPlugin("node", entryPoints),
             {
                 name: "rebuild-notify",
                 setup(build) {

package/dist/module/src/esbuildConfigs/web.js

@@ -1,7 +1,9 @@
 import path from "path";
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
+import featuresPlugin from "./featuresPlugin.js";
 export default (config, entryPoints) => {
+    const { inputFilesPluginFactory, register } = inputFilesPlugin("web", entryPoints);
     return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { 
         // inject: ["./node_modules/testeranto/dist/cjs-shim.js"],
         // banner: {
@@ -33,8 +35,10 @@ export default (config, entryPoints) => {
             "process",
             "dns",
         ], platform: "browser", entryPoints: [...entryPoints], plugins: [
-            ...(config.webPlugins || []),
-            inputFilesPlugin("web", entryPoints),
+            featuresPlugin,
+            // markdownPlugin({}),
+            ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
+            inputFilesPluginFactory,
             {
                 name: "rebuild-notify",
                 setup(build) {