testeranto 0.114.1 → 0.125.0

package/src/build.ts

@@ -1,51 +1,46 @@
+import ansiC from "ansi-colors";
 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 esbuildImportConfiger from "./esbuildConfigs/pure.js";
 import webHtmlFrame from "./web.html.js";
+
+import { getRunnables } from "./utils.js";
 import {
-  ITestTypes,
-  IRunnables,
-  IBaseConfig,
-  IRunTime,
+  ITestconfig,
   IBuiltConfig,
-} from "./lib/index.js";
+  IProject,
+  IRunTime,
+  ITestTypes,
+} from "./Types.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(".")}`
-      );
-    }
+let testName = process.argv[2];
 
-    if (cv[3].length) {
-      getRunnables(cv[3], payload);
-    }
+let mode = process.argv[3] as "once" | "dev";
+if (mode !== "once" && mode !== "dev") {
+  console.error(`The 4th argument should be 'dev' or 'once', not '${mode}'.`);
+  process.exit(-1);
+}
 
-    return pt;
-  }, payload as IRunnables);
-};
+console.log("testeranto is building", testName, mode);
 
-import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
-  const rawConfig: IBaseConfig = module.default;
+import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
+  const bigConfig: IProject = module.default;
+
+  const project = bigConfig.projects[testName];
+  if (!project) {
+    console.error("no project found for", testName, "in testeranto.config.ts");
+    process.exit(-1);
+  }
+
+  const rawConfig: ITestconfig = bigConfig.projects[testName];
 
   const getSecondaryEndpointsPoints = (runtime?: IRunTime): string[] => {
     const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
@@ -64,16 +59,36 @@ import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
 
   const config: IBuiltConfig = {
     ...rawConfig,
-    buildDir: process.cwd() + "/" + rawConfig.outdir,
+    buildDir: process.cwd() + "/testeranto/bundles/" + testName,
   };
 
+  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 = "once";
+      onDone();
+    } else if (key.name === "x") {
+      console.log("Testeranto-Build is shutting down forcefully...");
+      process.exit(-1);
+    } else {
+      console.log(
+        `Press 'q' to shutdown gracefully. Press 'x' to shutdown forcefully.`
+      );
+    }
+  });
   let nodeDone: boolean = false;
   let webDone: boolean = false;
-  let mode = config.devMode ? "DEV" : "PROD";
+  let importDone: boolean = false;
+
   let status: "build" | "built" = "build";
-  // let pm: PM_Main | undefined = new PM_Main(config);
-  // const fileHashes = {};
-  const { nodeEntryPoints, webEntryPoints } = getRunnables(config.tests);
+
+  const { nodeEntryPoints, webEntryPoints, importEntryPoints } = getRunnables(
+    config.tests,
+    testName
+  );
 
   const onNodeDone = () => {
     nodeDone = true;
@@ -85,89 +100,90 @@ import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
     onDone();
   };
 
+  const onImportDone = () => {
+    importDone = true;
+    onDone();
+  };
+
   const onDone = async () => {
-    if (nodeDone && webDone) {
+    if (nodeDone && webDone && importDone) {
       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!");
+    if (nodeDone && webDone && importDone && mode === "once") {
+      console.log(ansiC.inverse(`${testName} has been built. 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.`
+  if (!fs.existsSync(`testeranto/reports/${testName}`)) {
+    fs.mkdirSync(`testeranto/reports/${testName}`);
+  }
+
+  fs.writeFileSync(
+    `${process.cwd()}/testeranto/reports/${testName}/index.html`,
+    `
+    <!DOCTYPE html>
+    <html lang="en">
+  
+    <head>
+      <meta name="description" content="Webpage description goes here" />
+      <meta charset="utf-8" />
+      <title>kokomoBay - testeranto</title>
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <meta name="author" content="" />
+  
+      <link rel="stylesheet" href="/kokomoBay/testeranto/ReportClient.css" />
+      <script type="module" src="/kokomoBay/testeranto/ReportClient.js"></script>
+  
+    </head>
+  
+    <body>
+      <div id="root">
+        react is loading
+      </div>
+    </body>
+  
+    </html>
+        `
   );
-  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`,
+    `testeranto/reports/${testName}/config.json`,
     JSON.stringify(config, null, 2)
   );
 
+  fs.writeFileSync(
+    `${process.cwd()}/testeranto/index.html`,
+    `
+  <!DOCTYPE html>
+  <html lang="en">
+
+  <head>
+    <meta name="description" content="Webpage description goes here" />
+    <meta charset="utf-8" />
+    <title>kokomoBay - testeranto</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="author" content="" />
+
+    <script type="application/json" id="bigConfig">
+      ${JSON.stringify(Object.keys(bigConfig.projects))}
+    </script>
+
+    <link rel="stylesheet" href="/kokomoBay/testeranto/Project.css" />
+    <script type="module" src="/kokomoBay/testeranto/Project.js"></script>
+
+  </head>
+
+  <body>
+    <div id="root">
+      react is loading
+    </div>
+  </body>
+
+  </html>
+      `
+  );
+
   Promise.resolve(
     Promise.all(
       [...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
@@ -180,7 +196,7 @@ import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
           .join(".");
 
         const htmlFilePath = path.normalize(
-          `${process.cwd()}/${config.outdir}/web/${sourceDir.join(
+          `${process.cwd()}/testeranto/bundles/web/${testName}/${sourceDir.join(
             "/"
           )}/${sourceFileNameMinusJs}.html`
         );
@@ -198,43 +214,37 @@ import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
     )
   );
 
-  glob(`./${config.outdir}/chunk-*.mjs`, {
-    ignore: "node_modules/**",
-  }).then((chunks) => {
-    chunks.forEach((chunk) => {
-      fs.unlinkSync(chunk);
-    });
-  });
+  // glob(`${process.cwd()}/testeranto/bundles/${testName}/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;
-      }),
+    ...(
+      [
+        [esbuildImportConfiger, importEntryPoints, onImportDone],
+        [esbuildNodeConfiger, nodeEntryPoints, onNodeDone],
+        [esbuildWebConfiger, webEntryPoints, onWebDone],
+      ] as [(a, b, c) => any, Record<string, string>, () => void][]
+    ).map(([configer, entryPoints, done]) => {
+      esbuild
+        .context(configer(config, Object.keys(entryPoints), testName))
+        .then(async (ctx) => {
+          if (mode === "dev") {
+            await ctx.watch().then((v) => {
+              done();
+            });
+          } else {
+            ctx.rebuild().then((v) => {
+              done();
+            });
+          }
+
+          return ctx;
+        });
+    }),
   ]);
 });

package/src/defaultConfig.ts

@@ -1,18 +1,16 @@
-import { IBaseConfig } from "./lib";
+import { ITestconfig } from "./lib";
 
-const config: IBaseConfig = {
+const config: ITestconfig = {
   src: "src",
-  outdir: "docs",
   tests: [],
   debugger: true,
   clearScreen: false,
-  devMode: true,
   minify: false,
-  outbase: ".",
   ports: ["3001"],
   externals: [],
   nodePlugins: [],
   webPlugins: [],
+  importPlugins: [],
   featureIngestor: function (s: string): Promise<string> {
     throw new Error("Function not implemented.");
   },

package/src/esbuildConfigs/index.ts

@@ -1,15 +1,15 @@
 import { BuildOptions } from "esbuild";
 
-import { IBaseConfig } from "../lib";
+import { ITestconfig } from "../lib";
 
-export default (config: IBaseConfig): BuildOptions => {
+export default (config: ITestconfig): BuildOptions => {
   return {
     // packages: "external",
     target: "esnext",
     format: "esm",
     splitting: true,
     outExtension: { ".js": ".mjs" },
-    outbase: config.outbase,
+    outbase: ".",
     jsx: "transform",
     bundle: true,
     minify: config.minify === true,

package/src/esbuildConfigs/inputFilesPlugin.ts

@@ -1,5 +1,6 @@
 import fs from "fs";
 import type { Plugin } from "esbuild";
+import { IRunTime } from "../lib";
 
 const otherInputs: Record<string, Set<string>> = {};
 
@@ -11,12 +12,17 @@ const register = (entrypoint: string, sources: string[]): void => {
 };
 
 export default (
-  platform: "web" | "node",
-  entryPoints: Set<string> | string[]
+  platform: IRunTime,
+  testName: string
 ): {
   register: (entrypoint: string, sources: string[]) => void;
   inputFilesPluginFactory: Plugin;
 } => {
+  const d = `testeranto/bundles/${platform}/${testName}/`;
+  const f = `testeranto/bundles/${platform}/${testName}/metafile.json`;
+  if (!fs.existsSync(d)) {
+    fs.mkdirSync(d);
+  }
   return {
     register,
 
@@ -24,11 +30,7 @@ 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)
-          );
+          fs.writeFileSync(f, JSON.stringify(result, null, 2));
         });
       },
     },

package/src/esbuildConfigs/node.ts

@@ -1,25 +1,26 @@
 import { BuildOptions } from "esbuild";
 
-import { IBaseConfig } from "../lib/index.js";
+import { ITestconfig } from "../lib/index.js";
 
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
 import featuresPlugin from "./featuresPlugin";
 
 export default (
-  config: IBaseConfig,
-  entryPoints: Set<string> | string[]
+  config: ITestconfig,
+  entryPoints: string[],
+  testName: string
 ): BuildOptions => {
   const { inputFilesPluginFactory, register } = inputFilesPlugin(
     "node",
-    entryPoints
+    testName
   );
   return {
     ...baseEsBuildConfig(config),
 
     splitting: true,
 
-    outdir: config.outdir + "/node",
+    outdir: `testeranto/bundles/node/${testName}/`,
 
     // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
     metafile: true,
@@ -45,7 +46,10 @@ export default (
       inputFilesPluginFactory,
       {
         name: "rebuild-notify",
-        setup(build) {
+        setup: (build) => {
+          build.onStart(() => {
+            console.log(`> node build starting...`);
+          });
           build.onEnd((result) => {
             console.log(
               `> node build ended with ${result.errors.length} errors`

package/src/esbuildConfigs/pure.ts

@@ -0,0 +1,72 @@
+import { BuildOptions } from "esbuild";
+
+import { ITestconfig } from "../lib/index.js";
+
+import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin.js";
+import featuresPlugin from "./featuresPlugin.js";
+
+export default (
+  config: ITestconfig,
+  entryPoints: string[],
+  testName: string
+): BuildOptions => {
+  const { inputFilesPluginFactory, register } = inputFilesPlugin(
+    "pure",
+    testName
+  );
+  return {
+    ...baseEsBuildConfig(config),
+
+    drop: ["console", "debugger"],
+
+    splitting: true,
+
+    outdir: `testeranto/bundles/pure/${testName}/`,
+
+    // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
+    metafile: true,
+    supported: {
+      "dynamic-import": true,
+    },
+
+    define: {
+      "process.env.FLUENTFFMPEG_COV": "0",
+    },
+    absWorkingDir: process.cwd(),
+    banner: {
+      js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
+    },
+    platform: "node",
+
+    external: ["react", ...config.externals],
+
+    entryPoints: [...entryPoints],
+    plugins: [
+      featuresPlugin,
+
+      inputFilesPluginFactory,
+      {
+        name: "rebuild-notify",
+        setup: (build) => {
+          build.onStart(() => {
+            console.log(`> pure build starting...`);
+          });
+          build.onEnd((result) => {
+            console.log(
+              `> pure build ended with ${result.errors.length} errors`
+            );
+            if (result.errors.length > 0) {
+              console.log(result);
+            }
+            // console.log(result);
+            // result.errors.length !== 0 && process.exit(-1);
+          });
+        },
+      },
+
+      ...((config.nodePlugins || []).map((p) => p(register, entryPoints)) ||
+        []),
+    ],
+  };
+};

package/src/esbuildConfigs/web.ts

@@ -1,25 +1,26 @@
 import { BuildOptions } from "esbuild";
 import path from "path";
 
-import { IBaseConfig } from "../lib/index.js";
+import { ITestconfig } from "../lib/index.js";
 
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
 import featuresPlugin from "./featuresPlugin.js";
 
 export default (
-  config: IBaseConfig,
-  entryPoints: Set<string> | string[]
+  config: ITestconfig,
+  entryPoints: string[],
+  testName: string
 ): BuildOptions => {
   const { inputFilesPluginFactory, register } = inputFilesPlugin(
     "web",
-    entryPoints
+    testName
   );
 
   return {
     ...baseEsBuildConfig(config),
 
-    outdir: config.outdir + "/web",
+    outdir: `testeranto/bundles/web/${testName}`,
 
     alias: {
       react: path.resolve("./node_modules/react"),
@@ -56,7 +57,10 @@ export default (
       inputFilesPluginFactory,
       {
         name: "rebuild-notify",
-        setup(build) {
+        setup: (build) => {
+          build.onStart(() => {
+            console.log(`> web build starting...`);
+          });
           build.onEnd((result) => {
             console.log(
               `> web build ended with ${result.errors.length} errors`
@@ -70,7 +74,7 @@ export default (
         },
       },
 
-      ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
+      ...((config.webPlugins || []).map((p) => p(register, entryPoints)) || []),
     ],
   };
 };

package/src/examples/react/component/index.tsx

@@ -0,0 +1,35 @@
+import React from "react";
+
+export type IProps = { foo: string; children: [] };
+export type IState = { count: number };
+
+export class ClassicalComponent extends React.Component<IProps, IState> {
+  constructor(props) {
+    super(props);
+    this.state = {
+      count: 0,
+    };
+  }
+
+  render() {
+    return (
+      <div style={{ border: "3px solid black" }}>
+        <h1 id="theHeader">Hello Marcus</h1>
+        <pre id="theProps">{JSON.stringify(this.props)}</pre>
+        <p>foo: {this.props.foo}</p>
+        <pre id="theStat">{JSON.stringify(this.state)}</pre>
+        <p>count: {this.state.count} times</p>
+        <button
+          id="theButton"
+          onClick={async () => {
+            this.setState({ count: this.state.count + 1 });
+          }}
+        >
+          Click
+        </button>
+      </div>
+    );
+  }
+}
+
+export default ClassicalComponent;