testeranto 0.81.3 → 0.84.0

package/src/PM/web.ts

@@ -1,8 +1,9 @@
 import { PassThrough } from "stream";
-import puppeteer from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js";
 
 import { ITLog, ITTestResourceConfiguration } from "../lib";
+
 import { PM } from "./index.js";
+import { ScreenshotOptions } from "puppeteer-core";
 
 type PuppetMasterServer = Record<string, Promise<any>>;
 
@@ -15,8 +16,48 @@ export class PM_Web extends PM {
     this.testResourceConfiguration = t;
   }
 
-  customScreenShot(opts: object) {
-    window["customScreenShot"](opts);
+  $(selector: string): boolean {
+    return window["$"](selector);
+  }
+  screencast(opts: object) {
+    throw new Error("Method not implemented.");
+  }
+
+  isDisabled(selector: string): boolean {
+    return window["isDisabled"](selector);
+  }
+
+  getAttribute(selector: string, attribute: string) {
+    return window["getValue"](selector, attribute);
+  }
+
+  getValue(selector: string) {
+    return window["getValue"](selector);
+  }
+
+  focusOn(selector: string) {
+    return window["focusOn"](selector);
+  }
+  typeInto(value: string) {
+    return window["typeInto"](value);
+  }
+
+  page(): string | undefined {
+    return window["page"]();
+  }
+
+  click(selector: string): any {
+    return window["click"](selector);
+  }
+
+  customScreenShot(opts: ScreenshotOptions) {
+    return window["customScreenShot"](
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path,
+      },
+      this.testResourceConfiguration.name
+    );
   }
 
   existsSync(destFolder: string): boolean {
@@ -108,59 +149,68 @@ export class PM_Web extends PM {
     };
   }
 
-  startPuppeteer(options, destFolder: string): Promise<any> {
-    const name = this.testResourceConfiguration.name;
-
-    return fetch(`http://localhost:3234/json/version`)
-      .then((v) => {
-        return v.json();
-      })
-      .then((json) => {
-        return puppeteer
-          .connect({
-            browserWSEndpoint: json.webSocketDebuggerUrl,
-          })
-          .then((b) => {
-            this.browser = b;
-            const handler2 = {
-              get(target, prop, receiver) {
-                if (prop === "screenshot") {
-                  return async (x) => {
-                    return await window["custom-screenshot"](
-                      {
-                        ...x,
-                        // path: destFolder + "/" + x.path,
-                        path: x.path,
-                      },
-                      name
-                    );
-                  };
-                } else if (prop === "mainFrame") {
-                  return () => target[prop](...arguments);
-                } else {
-                  return Reflect.get(...arguments);
-                }
-              },
-            };
-            const handler1 = {
-              get(target, prop, receiver) {
-                if (prop === "pages") {
-                  return async () => {
-                    return target.pages().then((pages) => {
-                      return pages.map((p) => {
-                        return new Proxy(p, handler2);
-                      });
-                    });
-                  };
-                }
-
-                return Reflect.get(...arguments);
-              },
-            };
-
-            const proxy3 = new Proxy(this.browser, handler1);
-            this.browser = proxy3;
-          });
-      });
-  }
+  // startPuppeteer(options, destFolder: string): Promise<any> {
+  //   const name = this.testResourceConfiguration.name;
+
+  //   return fetch(`http://localhost:3234/json/version`)
+  //     .then((v) => {
+  //       return v.json();
+  //     })
+  //     .then((json) => {
+  //       console.log(json);
+
+  //       return puppeteer
+  //         .connect({
+  //           // "ws://localhost:3234/devtools/browser/01cc60a5-dad6-4b65-a848-09d77764a3fa"
+  //           // browserWSEndpoint: json.webSocketDebuggerUrl,
+  //           browserURL: "http://localhost:3234/json/version",
+  //         })
+  //         .then(async (b) => {
+  //           this.browser = b;
+
+  //           // const t = this.browser.targets()[2];
+  //           // const s = this.browser.defaultBrowserContext().
+  //           console.log(this.browser);
+  //           console.log(this.browser.browserContexts());
+  //           // const handler2 = {
+  //           //   get(target, prop, receiver) {
+  //           //     if (prop === "screenshot") {
+  //           //       return async (x) => {
+  //           //         return await window["custom-screenshot"](
+  //           //           {
+  //           //             ...x,
+  //           //             // path: destFolder + "/" + x.path,
+  //           //             path: x.path,
+  //           //           },
+  //           //           name
+  //           //         );
+  //           //       };
+  //           //     } else if (prop === "mainFrame") {
+  //           //       return () => target[prop](...arguments);
+  //           //     } else {
+  //           //       return Reflect.get(...arguments);
+  //           //     }
+  //           //   },
+  //           // };
+  //           // const handler1 = {
+  //           //   get(target, prop, receiver) {
+  //           //     if (prop === "pages") {
+  //           //       return async () => {
+  //           //         return target.pages().then((pages) => {
+  //           //           return pages.map((p) => {
+  //           //             return new Proxy(p, handler2);
+  //           //           });
+  //           //         });
+  //           //       };
+  //           //     }
+
+  //           //     return Reflect.get(...arguments);
+  //           //   },
+  //           // };
+
+  //           // const proxy3 = new Proxy(this.browser, handler1);
+  //           // this.browser = proxy3;
+  //         });
+  //     });
+  // }
 }

package/src/Project.ts

@@ -9,8 +9,6 @@ import esbuildWebConfiger from "./esbuildConfigs/web.js";
 import webHtmlFrame from "./web.html.js";
 import { ITestTypes, IBaseConfig, IRunTime } from "./lib/types.js";
 
-// var mode: "DEV" | "PROD" = process.argv[2] === "-dev" ? "DEV" : "PROD";
-
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
 
@@ -79,11 +77,6 @@ export class ITProject {
 
     const [nodeEntryPoints, webEntryPoints] = getRunnables(this.config.tests);
 
-    console.log(
-      `this.getSecondaryEndpointsPoints("web")`,
-      this.getSecondaryEndpointsPoints("web")
-    );
-
     glob(`./${this.config.outdir}/chunk-*.mjs`, {
       ignore: "node_modules/**",
     }).then((chunks) => {
@@ -163,7 +156,6 @@ export class ITProject {
   public getSecondaryEndpointsPoints(runtime?: IRunTime): string[] {
     const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
       ts.forEach((t) => {
-        console.log("getSecondaryEndpointsPoints", t);
         if (t[1] === runtime) {
           st.add(t[0]);
         }

package/src/Puppeteer.ts

@@ -4,20 +4,11 @@ import watch from "recursive-watch";
 
 import { PM_Main } from "./PM/main.js";
 import { destinationOfRuntime } from "./utils.js";
-import { timeout } from "puppeteer-core/lib/esm/puppeteer/index.js";
 import { IBaseConfig, IBuiltConfig } from "./lib/types.js";
 
-// var mode: "DEV" | "PROD" = process.argv[2] === "-dev" ? "DEV" : "PROD";
-
-// const node2web: Record<string, string[]> = {};
-// const web2node: Record<string, string[]> = {};
-// const childProcesses: Record<string, "loaded" | "running" | "done"> = {};
-
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
 
-// let shutDownMode = false;
-
 export default async (partialConfig) => {
   const config: IBuiltConfig = {
     ...partialConfig,
@@ -48,10 +39,12 @@ export default async (partialConfig) => {
       headless: true,
       dumpio: true,
       // timeout: 0,
+      devtools: true,
       args: [
-        // "--auto-open-devtools-for-tabs",
+        "--auto-open-devtools-for-tabs",
+        `--remote-debugging-port=3234`,
 
-        "--disable-features=IsolateOrigins,site-per-process",
+        // "--disable-features=IsolateOrigins,site-per-process",
         "--disable-site-isolation-trials",
         "--allow-insecure-localhost",
         "--allow-file-access-from-files",
@@ -75,7 +68,6 @@ export default async (partialConfig) => {
         // "--single-process",
         // "--unsafely-treat-insecure-origin-as-secure",
         // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
-        `--remote-debugging-port=3234`,
 
         // "--disk-cache-dir=/dev/null",
         // "--disk-cache-size=1",
@@ -85,12 +77,18 @@ export default async (partialConfig) => {
     "."
   );
 
-  console.log("\n Puppeteer is running. Press 'q' to quit\n");
+  console.log(
+    "\n Puppeteer is running. Press 'q' to shutdown softly. Press 'x' to shutdown forcefully.\n"
+  );
   process.stdin.on("keypress", (str, key) => {
     if (key.name === "q") {
       pm.shutDown();
       // process.exit();
     }
+    if (key.name === "x") {
+      // pm.shutDown();
+      process.exit(-1);
+    }
   });
 
   config.tests.forEach(([test, runtime, tr, sidecars]) => {
@@ -144,48 +142,4 @@ export default async (partialConfig) => {
   } else {
     pm.shutDown();
   }
-  // pm.browser.close();
-
-  // does not work on linux
-  // fs.watch(
-  //   config.buildDir,
-  //   {
-  //     recursive: true,
-  //   },
-  //   (eventType, changedFile) => {
-  //     if (changedFile) {
-  //       config.tests.forEach(([test, runtime, tr, sidecars]) => {
-  //         if (eventType === "change" || eventType === "rename") {
-  //           if (
-  //             changedFile ===
-  //             test
-  //               .replace("./", "node/")
-  //               .split(".")
-  //               .slice(0, -1)
-  //               .concat("mjs")
-  //               .join(".")
-  //           ) {
-  //             pm.launchNode(test, destinationOfRuntime(test, "node", config));
-  //           }
-
-  //           if (
-  //             changedFile ===
-  //             test
-  //               .replace("./", "web/")
-  //               .split(".")
-  //               .slice(0, -1)
-  //               .concat("mjs")
-  //               .join(".")
-  //           ) {
-  //             pm.launchWeb(
-  //               test,
-  //               destinationOfRuntime(test, "web", config),
-  //               sidecars
-  //             );
-  //           }
-  //         }
-  //       });
-  //     }
-  //   }
-  // );
 };

package/src/SubPackages/react-dom/jsx/web.ts

@@ -1,6 +1,6 @@
 import React, { useEffect, useRef } from "react";
 import { CElement, createElement } from "react";
-import ReactDom from "react-dom/client";
+import ReactDom from "react-dom";
 import { createPortal } from "react-dom";
 
 import Testeranto from "../../../Web.js";
@@ -100,17 +100,22 @@ export default <ITestShape extends IBaseTest>(
         });
       },
       andWhen: function (s: IStore, whenCB, tr, utils): Promise<ISelection> {
-        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: IStore, thenCB): Promise<ISelection> {
+      butThen: async function (
+        s: IStore,
+        thenCB,
+        tr,
+        utils
+      ): Promise<ISelection> {
         return new Promise((resolve, rej) => {
-          resolve(thenCB(s));
+          resolve(thenCB(s, utils));
         });
       },
       afterEach: async function (store: IStore, ndx, artificer) {

package/src/Types.ts

@@ -161,12 +161,15 @@ export type ITestImplementation<
     whens: {
       [K in keyof ITestShape["whens"]]: (
         ...Iw: ITestShape["whens"][K]
-      ) => (zel: ITestShape["iselection"], utils: PM) => ITestShape["when"];
+      ) => (
+        zel: ITestShape["iselection"],
+        utils: PM
+      ) => Promise<ITestShape["when"]>;
     };
     thens: {
       [K in keyof ITestShape["thens"]]: (
         ...It: ITestShape["thens"][K]
-      ) => (ssel: ITestShape["iselection"]) => ITestShape["then"];
+      ) => (ssel: ITestShape["iselection"], utils: PM) => ITestShape["then"];
     };
     checks: {
       [K in keyof ITestShape["checks"]]: (

package/src/Web.ts

@@ -12,7 +12,7 @@ import {
 } from "./lib/index.js";
 import { ITestInterface, IWebTestInterface } from "./lib/types";
 
-class WebTesteranto<
+export class WebTesteranto<
   TestShape extends IBaseTest<
     unknown,
     unknown,
@@ -47,9 +47,13 @@ class WebTesteranto<
   async receiveTestResourceConfig(partialTestResource: any) {
     const t: ITTestResourceConfiguration = partialTestResource; //JSON.parse(partialTestResource);
     const pm = new PM_Web(t);
-    const { failed, artifacts, logPromise } =
+    const { failed, artifacts, logPromise, features } =
       await this.testJobs[0].receiveTestResourceConfig(pm);
     pm.customclose();
+    return new Promise<string[]>((res, rej) => {
+      res(features);
+    });
+    // return features;
     // Promise.all([...artifacts, logPromise]).then(async () => {
     //   console.log("hello world");
     //   pm.customclose();

package/src/esbuildConfigs/featuresPlugin.ts

@@ -0,0 +1,43 @@
+import fs from "fs";
+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/src/esbuildConfigs/inputFilesPlugin.ts

@@ -1,112 +1,119 @@
 import fs from "fs";
 import path from "path";
+import type { ImportKind, Metafile, Plugin } from "esbuild";
+
+const otherInputs: Record<string, Set<string>> = {};
+
+const register = (entrypoint: string, sources: string[]): void => {
+  console.log("register", entrypoint, sources);
+  if (!otherInputs[entrypoint]) {
+    otherInputs[entrypoint] = new Set();
+  }
+  sources.forEach((s) => otherInputs[entrypoint].add(s));
+};
+
+function tree(meta: Metafile, key: string) {
+  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: "web" | "node",
   entryPoints: Set<string> | string[]
-) => {
+): {
+  register: (entrypoint: string, sources: string[]) => void;
+  inputFilesPluginFactory: Plugin;
+} => {
   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`
-            );
+    register,
 
-            const dirName = path.dirname(filePath);
+    inputFilesPluginFactory: {
+      name: "metafileWriter",
+      setup(build) {
+        build.onEnd((result) => {
+          fs.writeFileSync(
+            `docs/${platform}/metafile.json`,
+            JSON.stringify(result, null, 2)
+          );
 
-            if (!fs.existsSync(dirName)) {
-              fs.mkdirSync(dirName, { recursive: true });
-            }
+          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);
 
-            const j = Object.keys(
-              Object.keys(result.metafile.outputs)
-                .filter((s: string) => {
-                  if (!result.metafile.outputs[s].entryPoint) {
-                    return false;
-                  }
-                  return (
-                    path.resolve(result.metafile.outputs[s].entryPoint) ===
-                    path.resolve(entryPoint)
-                  );
-                })
-                .reduce((mm: string[], el) => {
-                  mm.push(result.metafile.outputs[el].inputs);
-                  return mm;
-                }, [])[0]
-            ).filter((f: string) => {
-              const regex = /^src\/.*/g;
-              const matches = f.match(regex);
-              const passes = matches?.length === 1;
-              return passes;
-            });
-            // .filter((f: string) => {
-            //   const regex = /.*\.test\..*/g;
-            //   const matches = f.match(regex);
-            //   const passes = matches?.length === 1;
-            //   return !passes;
-            // })
+              if (!fs.existsSync(dirName)) {
+                fs.mkdirSync(dirName, { recursive: true });
+              }
 
-            const jsonContent = JSON.stringify(j);
+              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}
 
-            fs.writeFileSync(filePath, jsonContent);
+              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,
-              `
-${j
+                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}.")
-            // `
-            //             );
-          });
-        }
-      });
+                );
+              }
+            });
+          }
+        });
+      },
     },
   };
 };