testeranto 0.100.0 → 0.111.0

package/src/build.ts

@@ -0,0 +1,240 @@
+import fs, { watch } from "fs";
+import path from "path";
+import readline from "readline";
+import { glob } from "glob";
+import esbuild from "esbuild";
+
+import esbuildNodeConfiger from "./esbuildConfigs/node.js";
+import esbuildWebConfiger from "./esbuildConfigs/web.js";
+import webHtmlFrame from "./web.html.js";
+import {
+  ITestTypes,
+  IRunnables,
+  IBaseConfig,
+  IRunTime,
+  IBuiltConfig,
+} from "./lib/index.js";
+
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY) process.stdin.setRawMode(true);
+
+const getRunnables = (
+  tests: ITestTypes[],
+  payload = {
+    nodeEntryPoints: {},
+    webEntryPoints: {},
+  }
+): IRunnables => {
+  return tests.reduce((pt, cv, cndx, cry) => {
+    if (cv[1] === "node") {
+      pt.nodeEntryPoints[cv[0]] = path.resolve(
+        `./docs/node/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+      );
+    } else if (cv[1] === "web") {
+      pt.webEntryPoints[cv[0]] = path.resolve(
+        `./docs/web/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+      );
+    }
+
+    if (cv[3].length) {
+      getRunnables(cv[3], payload);
+    }
+
+    return pt;
+  }, payload as IRunnables);
+};
+
+import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
+  const rawConfig: IBaseConfig = module.default;
+
+  const getSecondaryEndpointsPoints = (runtime?: IRunTime): string[] => {
+    const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
+      ts.forEach((t) => {
+        if (t[1] === runtime) {
+          st.add(t[0]);
+        }
+        if (Array.isArray(t[3])) {
+          meta(t[3], st);
+        }
+      });
+      return st;
+    };
+    return Array.from(meta(config.tests, new Set()));
+  };
+
+  const config: IBuiltConfig = {
+    ...rawConfig,
+    buildDir: process.cwd() + "/" + rawConfig.outdir,
+  };
+
+  let nodeDone: boolean = false;
+  let webDone: boolean = false;
+  let mode = config.devMode ? "DEV" : "PROD";
+  let status: "build" | "built" = "build";
+  // let pm: PM_Main | undefined = new PM_Main(config);
+  // const fileHashes = {};
+  const { nodeEntryPoints, webEntryPoints } = getRunnables(config.tests);
+
+  const onNodeDone = () => {
+    nodeDone = true;
+    onDone();
+  };
+
+  const onWebDone = () => {
+    webDone = true;
+    onDone();
+  };
+
+  const onDone = async () => {
+    if (nodeDone && webDone) {
+      status = "built";
+    }
+    if (nodeDone && webDone && status === "built") {
+      // Object.entries(nodeEntryPoints).forEach(([k, outputFile]) => {
+      //   console.log("watching", outputFile);
+      //   try {
+      //     watch(outputFile, async (filename) => {
+      //       const hash = await fileHash(outputFile);
+      //       if (fileHashes[k] !== hash) {
+      //         fileHashes[k] = hash;
+      //         console.log(`< ${filename} `);
+      //         pm.launchNode(k, outputFile);
+      //       }
+      //     });
+      //   } catch (e) {
+      //     console.error(e);
+      //   }
+      // });
+      // Object.entries(webEntryPoints).forEach(([k, outputFile]) => {
+      //   console.log("watching", outputFile);
+      //   watch(outputFile, async (filename) => {
+      //     const hash = await fileHash(outputFile);
+      //     console.log(`< ${filename} ${hash}`);
+      //     if (fileHashes[k] !== hash) {
+      //       fileHashes[k] = hash;
+      //       pm.launchWeb(k, outputFile);
+      //     }
+      //   });
+      // });
+    }
+
+    if (nodeDone && webDone && mode === "PROD") {
+      console.log("Testeranto-EsBuild is all done. Goodbye!");
+      process.exit();
+    } else {
+      if (mode === "PROD") {
+        console.log("waiting for tests to finish");
+        console.log(
+          JSON.stringify(
+            {
+              nodeDone: nodeDone,
+              webDone: webDone,
+              mode: mode,
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        console.log("waiting for tests to change");
+      }
+
+      if (config.devMode) {
+        console.log("ready and watching for changes...");
+      } else {
+        // pm.shutDown();
+      }
+      ////////////////////////////////////////////////////////////////////////////////
+    }
+  };
+
+  console.log(
+    `Press 'q' to shutdown gracefully. Press 'x' to shutdown forcefully.`
+  );
+  process.stdin.on("keypress", (str, key) => {
+    if (key.name === "q") {
+      console.log("Testeranto-Build is shutting down...");
+      mode = "PROD";
+      onDone();
+    }
+    if (key.name === "x") {
+      console.log("Testeranto-Build is shutting down forcefully...");
+      process.exit(-1);
+    }
+  });
+
+  fs.writeFileSync(
+    `${config.outdir}/testeranto.json`,
+    JSON.stringify(config, null, 2)
+  );
+
+  Promise.resolve(
+    Promise.all(
+      [...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
+        const sourceFileSplit = sourceFilePath.split("/");
+        const sourceDir = sourceFileSplit.slice(0, -1);
+        const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
+        const sourceFileNameMinusJs = sourceFileName
+          .split(".")
+          .slice(0, -1)
+          .join(".");
+
+        const htmlFilePath = path.normalize(
+          `${process.cwd()}/${config.outdir}/web/${sourceDir.join(
+            "/"
+          )}/${sourceFileNameMinusJs}.html`
+        );
+        const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
+
+        return fs.promises
+          .mkdir(path.dirname(htmlFilePath), { recursive: true })
+          .then((x) =>
+            fs.writeFileSync(
+              htmlFilePath,
+              webHtmlFrame(jsfilePath, htmlFilePath)
+            )
+          );
+      })
+    )
+  );
+
+  glob(`./${config.outdir}/chunk-*.mjs`, {
+    ignore: "node_modules/**",
+  }).then((chunks) => {
+    chunks.forEach((chunk) => {
+      fs.unlinkSync(chunk);
+    });
+  });
+
+  await Promise.all([
+    esbuild
+      .context(esbuildNodeConfiger(config, Object.keys(nodeEntryPoints)))
+      .then(async (nodeContext) => {
+        if (config.devMode) {
+          await nodeContext.watch().then((v) => {
+            onNodeDone();
+          });
+        } else {
+          nodeContext.rebuild().then((v) => {
+            onNodeDone();
+          });
+        }
+
+        return nodeContext;
+      }),
+    esbuild
+      .context(esbuildWebConfiger(config, Object.keys(webEntryPoints)))
+      .then(async (webContext) => {
+        if (config.devMode) {
+          await webContext.watch().then((v) => {
+            onWebDone();
+          });
+        } else {
+          webContext.rebuild().then((v) => {
+            onWebDone();
+          });
+        }
+        return webContext;
+      }),
+  ]);
+});

package/src/defaultConfig.ts

@@ -1,6 +1,7 @@
-import { IBaseConfig } from "testeranto/src/lib/types.js";
+import { IBaseConfig } from "./lib";
 
 const config: IBaseConfig = {
+  src: "src",
   outdir: "docs",
   tests: [],
   debugger: true,

package/src/esbuildConfigs/eslint-formatter-testeranto.ts

@@ -0,0 +1,5 @@
+import { LintResult } from "eslint/lib/linter";
+
+export default function (results: LintResult[]) {
+  return JSON.stringify(results, null, 2);
+}

package/src/esbuildConfigs/featuresPlugin.ts

@@ -1,4 +1,3 @@
-import fs from "fs";
 import path from "path";
 
 export default {

package/src/esbuildConfigs/index.ts

@@ -1,6 +1,6 @@
 import { BuildOptions } from "esbuild";
 
-import { IBaseConfig } from "../lib/types";
+import { IBaseConfig } from "../lib";
 
 export default (config: IBaseConfig): BuildOptions => {
   return {

package/src/esbuildConfigs/inputFilesPlugin.ts

@@ -1,7 +1,5 @@
 import fs from "fs";
-import path from "path";
-import type { ImportKind, Metafile, Plugin } from "esbuild";
-import { spawn } from "child_process";
+import type { Plugin } from "esbuild";
 
 const otherInputs: Record<string, Set<string>> = {};
 
@@ -12,21 +10,6 @@ const register = (entrypoint: string, sources: string[]): void => {
   sources.forEach((s) => otherInputs[entrypoint].add(s));
 };
 
-function tree(meta: Metafile, key: string) {
-  const outputKey = Object.keys(meta.outputs).find((k) => {
-    return meta.outputs[k].entryPoint === key;
-  });
-
-  if (!outputKey) {
-    console.error("No outputkey found");
-    process.exit(-1);
-  }
-
-  return Object.keys(meta.outputs[outputKey].inputs).filter((k) =>
-    k.startsWith("src")
-  );
-}
-
 export default (
   platform: "web" | "node",
   entryPoints: Set<string> | string[]
@@ -41,127 +24,11 @@ export default (
       name: "metafileWriter",
       setup(build) {
         build.onEnd((result) => {
+          // console.log("build.onEnd", entryPoints);
           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 });
-              }
-
-              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`
-              );
-
-              const stderrPath = path.join(
-                "./docs/",
-                platform,
-                entryPoint.split(".").slice(0, -1).join("."),
-                `stderr.log`
-              );
-              const stdoutPath = path.join(
-                "./docs/",
-                platform,
-                entryPoint.split(".").slice(0, -1).join("."),
-                `stdout.log`
-              );
-
-              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();
-
-                const typeErrorFiles = addableFiles.map(
-                  (t) => `docs/types/${t}.type_errors.txt`
-                );
-
-                const lintPath = path.join(
-                  "./docs/",
-                  platform,
-                  entryPoint.split(".").slice(0, -1).join("."),
-                  `lint_errors.txt`
-                );
-                fs.writeFileSync(
-                  promptPath,
-                  `
-${addableFiles
-  .map((x) => {
-    return `/add ${x}`;
-  })
-  .join("\n")}
-  
-${typeErrorFiles
-  .map((x) => {
-    return `/read ${x}`;
-  })
-  .join("\n")}
-
-/read ${lintPath}
-/read ${testPaths}
-/read ${stdoutPath}
-/read ${stderrPath}
-
-/load ${featuresPath}
-
-/code Fix the failing tests described in ${testPaths}. Correct any type signature errors described in the files [${typeErrorFiles.join(
-                    ", "
-                  )}]. Implement any method which throws "Function not implemented. Resolve the lint errors described in ${lintPath}"
-`
-                );
-
-                const logContent: string[] = [];
-                const tsc = spawn("eslint", addableFiles);
-
-                tsc.stdout.on("data", (data) => {
-                  const lines = data.toString().split("\n");
-                  logContent.push(...lines);
-                });
-
-                tsc.stderr.on("data", (data) => {
-                  console.error(`stderr: ${data}`);
-                  process.exit(-1);
-                });
-
-                tsc.on("close", (code) => {
-                  fs.writeFileSync(lintPath, logContent.join("\n"));
-                });
-              }
-            });
-          }
         });
       },
     },

package/src/esbuildConfigs/node.ts

@@ -1,6 +1,6 @@
 import { BuildOptions } from "esbuild";
 
-import { IBaseConfig } from "../lib/types";
+import { IBaseConfig } from "../lib/index.js";
 
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
@@ -36,24 +36,13 @@ export default (
     },
     platform: "node",
 
-    external: [
-      // "testeranto.json",
-      // "features.test.js",
-      "react",
-      // "events",
-      // "ganache"
-      ...config.externals,
-    ],
+    external: ["react", ...config.externals],
 
     entryPoints: [...entryPoints],
     plugins: [
       featuresPlugin,
 
-      ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
-
       inputFilesPluginFactory,
-      // inputFilesPlugin("node", entryPoints),
-
       {
         name: "rebuild-notify",
         setup(build) {
@@ -69,6 +58,8 @@ export default (
           });
         },
       },
+
+      ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
     ],
   };
 };

package/src/esbuildConfigs/web.ts

@@ -1,9 +1,7 @@
 import { BuildOptions } from "esbuild";
 import path from "path";
 
-import pkg from "esbuild-plugin-markdown";
-
-import { IBaseConfig } from "../lib/types.js";
+import { IBaseConfig } from "../lib/index.js";
 
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
@@ -21,13 +19,6 @@ export default (
   return {
     ...baseEsBuildConfig(config),
 
-    // inject: ["./node_modules/testeranto/dist/cjs-shim.js"],
-    // banner: {
-    //   js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
-    // },
-
-    // splitting: true,
-
     outdir: config.outdir + "/web",
 
     alias: {
@@ -37,11 +28,6 @@ export default (
     metafile: true,
 
     external: [
-      // "testeranto.json",
-      // "features.test.ts",
-      // "url",
-      // "react",
-
       "path",
       "fs",
       "stream",
@@ -56,7 +42,6 @@ export default (
       "zlib",
       "crypto",
       "https",
-
       "util",
       "process",
       "dns",
@@ -68,9 +53,6 @@ export default (
 
     plugins: [
       featuresPlugin,
-
-      // markdownPlugin({}),
-      ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
       inputFilesPluginFactory,
       {
         name: "rebuild-notify",
@@ -87,6 +69,8 @@ export default (
           });
         },
       },
+
+      ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
     ],
   };
 };

package/src/init-docs.ts

@@ -1,5 +1,6 @@
 import fs from "fs";
-import Init from "../dist/module/src/Init";
+import Init from "./Init";
+
 console.log("Initializing a testeranto project");
 
 if (!process.argv[2]) {