testeranto 0.197.0 → 0.199.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testeranto",
   "description": "the AI powered BDD test framework for typescript projects",
-  "version": "0.197.0",
+  "version": "0.199.0",
   "engines": {
     "node": "18.18.0"
   },
@@ -152,18 +152,19 @@
   "devDependencies": {
     "@eslint/js": "^9.23.0",
     "@swc/core": "^1.3.26",
-    "@types/express": "^5.0.0",
     "@types/express-session": "^1.18.1",
+    "@types/express": "^5.0.0",
     "@types/node": "^24.1.0",
-    "@types/react": "18.2.0",
     "@types/react-dom": "18.2.0",
     "@types/react-test-renderer": "19.0.0",
+    "@types/react": "18.2.0",
     "@types/uuid": "^10.0.0",
     "@types/ws": "^8.18.1",
     "@typescript-eslint/eslint-plugin": "^5.46.0",
     "@typescript-eslint/parser": "^5.46.0",
     "self-import": "*",
-    "testeranto-react": "0.0.8",
+    "testeranto-react": "0.0.9",
+    "testeranto-stilo": "0.0.7",
     "ts-node": "^10.9.1",
     "typescript": "^5.8.2"
   },
@@ -184,22 +185,22 @@
     "ansi-colors": "^4.1.3",
     "axios": "^1.11.0",
     "babel-loader": "^8.2.5",
-    "bootstrap": "^5.3.7",
     "bootstrap-icons": "^1.13.1",
+    "bootstrap": "^5.3.7",
     "chai": "^5.2.0",
     "chromium": "^3.0.3",
     "dynamic-base": "^1.1.2",
-    "esbuild": "0.17.5",
     "esbuild-plugin-external-package": "^1.0.0",
     "esbuild-plugin-import-map": "^2.1.0",
     "esbuild-plugin-markdown": "^0.0.3",
     "esbuild-plugin-polyfill-node": "^0.3.0",
     "esbuild-sass-plugin": "^3.3.1",
-    "eslint": "^9.23.0",
+    "esbuild": "0.17.5",
     "eslint-formatter-compact": "^8.40.0",
     "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-react": "^7.31.11",
     "eslint-plugin-react-hooks": "^5.1.0",
+    "eslint-plugin-react": "^7.31.11",
+    "eslint": "^9.23.0",
     "express": "^4.21.2",
     "fabric": "6.7.1",
     "fast-xml-parser": "^5.2.5",
@@ -209,25 +210,24 @@
     "get-audio-duration": "^4.0.1",
     "html-to-image": "^1.11.13",
     "license-checker": "^25.0.1",
-    "mermaid": "^11.8.1",
     "mermaid-isomorphic": "^3.0.4",
-    "micromark": "^4.0.2",
+    "mermaid": "^11.8.1",
     "micromark-extension-gfm-table": "^2.1.1",
+    "micromark": "^4.0.2",
     "monaco-editor": "^0.45.0",
     "node-static": "^0.7.11",
     "octokit": "^5.0.3",
     "openai": "^5.12.2",
-    "puppeteer": "^24.4.0",
     "puppeteer-core": "24.4.0",
-    "react": "18.2.0",
+    "puppeteer": "^24.4.0",
     "react-bootstrap": "^2.10.9",
     "react-dom": "18.2.0",
     "react-draggable": "^4.5.0",
     "react-resizable": "^3.0.5",
     "react-router-dom": "^7.7.0",
+    "react": "18.2.0",
     "sass": "^1.90.0",
     "ssml-check": "^0.4.6",
-    "testeranto-stilo": "0.0.7",
     "tsc-prog": "^2.3.0",
     "tsx": "^4.19.3",
     "type-fest": "^4.41.0",
@@ -237,8 +237,8 @@
     "validate-with-xmllint": "^1.2.1",
     "ws": "^8.18.3",
     "xmldom": "^0.6.0",
-    "xterm": "^5.3.0",
     "xterm-addon-fit": "^0.8.0",
+    "xterm": "^5.3.0",
     "xterm-react": "^1.0.0"
   }
 }

package/src/App.tsx

@@ -38,18 +38,40 @@ export const App = () => {
 // Export App to global scope
 function initApp() {
   const rootElement = document.getElementById('root');
-  if (rootElement && window.React && window.ReactDOM) {
-    const root = window.ReactDOM.createRoot(rootElement);
-    root.render(window.React.createElement(App));
+  if (rootElement) {
+    try {
+      // Try to use React 18's createRoot if available
+      if (ReactDom.createRoot) {
+        const root = ReactDom.createRoot(rootElement);
+        root.render(React.createElement(App));
+      } else {
+        // Fall back to React 17's render
+        ReactDom.render(React.createElement(App), rootElement);
+      }
+    } catch (err) {
+      console.error('Error rendering app:', err);
+      // Retry if React isn't loaded yet
+      setTimeout(initApp, 100);
+    }
   } else {
-    // Retry if React isn't loaded yet
+    // Retry if root element isn't available yet
     setTimeout(initApp, 100);
   }
 }
 
 // Export App to global scope
-if (typeof window !== 'undefined') {
+if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+  // @ts-ignore
   window.App = App;
+  // @ts-ignore
   window.React = React;
+  // @ts-ignore
   window.ReactDOM = ReactDom;
+  
+  // Initialize the app when the window is ready
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', initApp);
+  } else {
+    initApp();
+  }
 }

package/src/Node.ts

@@ -1,4 +1,4 @@
-import Testeranto from "./lib/core.js";
+// import Testeranto from "./lib/core.js";
 import {
   defaultTestResourceRequirement,
   ITTestResourceRequest,
@@ -12,6 +12,7 @@ import {
   Ibdd_out_any,
   Ibdd_out,
 } from "./CoreTypes.js";
+import Tiposkripto from "./lib/Tiposkripto.js";
 
 let ipcfile;
 
@@ -19,7 +20,7 @@ export class NodeTesteranto<
   I extends Ibdd_in_any,
   O extends Ibdd_out_any,
   M
-> extends Testeranto<I, O, M> {
+> extends Tiposkripto<I, O, M> {
   constructor(
     input: I["iinput"],
     testSpecification: ITestSpecification<I, O>,

package/src/PM/main.ts

@@ -1017,7 +1017,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
       );
 
       logs.exit.write(e3.stack);
-      logs.exit.write(-1);
+      logs.exit.write("-1");
       this.bddTestIsNowDone(src, -1);
       statusMessagePretty(-1, src, "pure");
     }

package/src/Pure.ts

@@ -5,12 +5,13 @@ import {
   ITestAdapter,
   ITestSpecification,
 } from "./CoreTypes.js";
-import Testeranto from "./lib/core.js";
+
 import {
   defaultTestResourceRequirement,
   ITTestResourceConfiguration,
   ITTestResourceRequest,
 } from "./lib/index.js";
+import Tiposkripto from "./lib/Tiposkripto.js";
 
 import { PM_Pure } from "./PM/pure.js";
 
@@ -18,7 +19,7 @@ export class PureTesteranto<
   I extends Ibdd_in_any,
   O extends Ibdd_out,
   M
-> extends Testeranto<I, O, M> {
+> extends Tiposkripto<I, O, M> {
   constructor(
     input: I["iinput"],
     testSpecification: ITestSpecification<I, O>,

package/src/Types.ts

@@ -1,12 +1,14 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Plugin } from "esbuild";
+
 import { ITTestResourceConfiguration } from "./lib/index.js";
 import { PM } from "./PM/index.js";
-
-import { BaseWhen, BaseThen, BaseGiven, IGivens } from "./lib/abstractBase.js";
-
 import { Ibdd_in_any, Ibdd_out_any } from "./CoreTypes.js";
+
 import { BaseSuite } from "./lib/BaseSuite.js";
+import { IGivens, BaseGiven } from "./lib/BaseGiven.js";
+import { BaseThen } from "./lib/BaseThen.js";
+import { BaseWhen } from "./lib/BaseWhen.js";
 
 export type ISummary = Record<
   string,

package/src/Web.ts

@@ -9,8 +9,8 @@ import {
   Ibdd_out,
 } from "./CoreTypes";
 import { PM_Web } from "./PM/web";
+import Tiposkripto from "./lib/Tiposkripto";
 
-import Testeranto from "./lib/core.js";
 import {
   ITTestResourceConfiguration,
   ITTestResourceRequest,
@@ -29,7 +29,7 @@ export class WebTesteranto<
   I extends Ibdd_in_any,
   O extends Ibdd_out,
   M
-> extends Testeranto<I, O, M> {
+> extends Tiposkripto<I, O, M> {
   constructor(
     input: I["iinput"],
     testSpecification: ITestSpecification<I, O>,

package/src/components/DesignEditorPage.tsx

@@ -5,7 +5,7 @@ import { saveAs } from 'file-saver';
 
 export const DesignEditorPage = () => {
   const [projectId, setProjectId] = useState('default-project');
-  const [fileHandle, setFileHandle] = useState<FileSystemFileHandle | null>(null);
+  const [fileHandle, setFileHandle] = useState<any>(null);
 
   const handleSave = async () => {
     try {
@@ -32,16 +32,43 @@ export const DesignEditorPage = () => {
         designEditorRef.current.loadDesign(fullDesign);
       }
 
-      // @ts-ignore - File System Access API
-      const newHandle = await window.showSaveFilePicker({
-        types: [{
-          description: 'Design Files',
-          accept: {
-            'application/json': ['.json'],
-          },
-        }],
-        suggestedName: `${projectId}.json`
-      });
+      let newHandle;
+      if ('showSaveFilePicker' in window && (window as any).showSaveFilePicker) {
+        try {
+          newHandle = await (window as any).showSaveFilePicker({
+            types: [{
+              description: 'Design Files',
+              accept: {
+                'application/json': ['.json'],
+              },
+            }],
+            suggestedName: `${projectId}.json`
+          });
+        } catch (err) {
+          console.warn('Error using showSaveFilePicker:', err);
+          // Fall back to traditional download
+          const jsonData = JSON.stringify(fullDesign, null, 2);
+          const blob = new Blob([jsonData], { type: 'application/json' });
+          const url = URL.createObjectURL(blob);
+          const a = document.createElement('a');
+          a.href = url;
+          a.download = `${projectId}.json`;
+          a.click();
+          URL.revokeObjectURL(url);
+          return;
+        }
+      } else {
+        // Fall back to traditional download
+        const jsonData = JSON.stringify(fullDesign, null, 2);
+        const blob = new Blob([jsonData], { type: 'application/json' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = `${projectId}.json`;
+        a.click();
+        URL.revokeObjectURL(url);
+        return;
+      }
 
       const jsonData = JSON.stringify(fullDesign, null, 2);
       const writable = await newHandle.createWritable();
@@ -61,7 +88,7 @@ export const DesignEditorPage = () => {
     }
   };
 
-  const [design, setDesign] = useState<Design | null>(null);
+  const [design, setDesign] = useState<any>(null);
   const designEditorRef = useRef<DesignEditorRef>(null);
 
   const handleOpen = async () => {
@@ -72,15 +99,21 @@ export const DesignEditorPage = () => {
       }
 
       console.log('Attempting to show file picker...');
-      const [handle] = await window.showOpenFilePicker({
-        types: [{
-          description: 'Design Files',
-          accept: {
-            'application/json': ['.json'],
-          },
-        }],
-        multiple: false
-      });
+      let handle;
+      if ('showOpenFilePicker' in window) {
+        // @ts-ignore
+        [handle] = await window.showOpenFilePicker({
+          types: [{
+            description: 'Design Files',
+            accept: {
+              'application/json': ['.json'],
+            },
+          }],
+          multiple: false
+        });
+      } else {
+        throw new Error('File System Access API not supported');
+      }
 
       if (!handle) {
         throw new Error('No file selected');

package/src/lib/BaseGiven.ts

@@ -0,0 +1,193 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+// Do not add logging to this file as it is used by the pure runtime.
+
+import type { Ibdd_in_any, Ibdd_out_any } from "../CoreTypes";
+
+import { ITestArtifactory, ITLog, ITTestResourceConfiguration } from ".";
+import { IPM } from "./types.js";
+import { afterEachProxy, beforeEachProxy } from "./pmProxy.js";
+import { BaseSuite } from "./BaseSuite";
+
+/**
+ * Represents a collection of Given conditions keyed by their names.
+ * Givens are typically organized as named collections because:
+ * - They set up different initial states for tests
+ * - Tests often need to reference specific Given conditions by name
+ * - This allows for better organization and reuse of setup logic
+ * - The BDD pattern often involves multiple named Given scenarios
+ */
+export type IGivens<I extends Ibdd_in_any> = Record<string, BaseGiven<I>>;
+
+export abstract class BaseGiven<I extends Ibdd_in_any> {
+  name: string;
+  features: string[];
+  whens: any[];
+  thens: any[];
+  error: Error;
+  fail: any;
+  store: I["istore"];
+  recommendedFsPath: string;
+  givenCB: I["given"];
+  initialValues: any;
+  key: string;
+  failed: boolean;
+  artifacts: string[] = [];
+
+  addArtifact(path: string) {
+    const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+    this.artifacts.push(normalizedPath);
+  }
+
+  constructor(
+    name: string,
+    features: string[],
+    whens: any[],
+    thens: any[],
+    givenCB: I["given"],
+    initialValues: any
+  ) {
+    this.name = name;
+    this.features = features || [];
+    this.whens = whens || [];
+    this.thens = thens || [];
+    this.givenCB = givenCB;
+    this.initialValues = initialValues;
+  }
+
+  beforeAll(store: I["istore"]) {
+    return store;
+  }
+
+  toObj() {
+    return {
+      key: this.key,
+      name: this.name,
+      whens: (this.whens || []).map((w) => {
+        if (w && w.toObj) return w.toObj();
+
+        console.error("w is not as expected!", JSON.stringify(w));
+        return {};
+      }),
+      thens: (this.thens || []).map((t) => t && t.toObj ? t.toObj() : {}),
+      error: this.error ? [this.error, this.error.stack] : null,
+      failed: this.failed,
+      features: this.features || [],
+      artifacts: this.artifacts || [],
+    };
+  }
+
+  abstract givenThat(
+    subject: I["isubject"],
+    testResourceConfiguration,
+    artifactory: ITestArtifactory,
+    givenCB: I["given"],
+    initialValues: any,
+    pm: IPM
+  ): Promise<I["istore"]>;
+
+  async afterEach(
+    store: I["istore"],
+    key: string,
+    artifactory: ITestArtifactory,
+    pm: IPM
+  ): Promise<I["istore"]> {
+    return store;
+  }
+
+  abstract uberCatcher(e);
+
+  async give(
+    subject: I["isubject"],
+    key: string,
+    testResourceConfiguration: ITTestResourceConfiguration,
+    tester: (t: Awaited<I["then"]> | undefined) => boolean,
+    artifactory: ITestArtifactory,
+    tLog: ITLog,
+    pm: IPM,
+    suiteNdx: number
+  ) {
+    this.key = key;
+
+    tLog(`\n ${this.key}`);
+    tLog(`\n Given: ${this.name}`);
+
+    const givenArtifactory = (fPath: string, value: unknown) =>
+      artifactory(`given-${key}/${fPath}`, value);
+
+    this.uberCatcher((e) => {
+      console.error(e.toString());
+      this.error = e.error;
+      tLog(e.stack);
+    });
+
+    try {
+      // Ensure addArtifact is properly bound to 'this'
+      const addArtifact = this.addArtifact.bind(this);
+      const proxiedPm = beforeEachProxy(pm, suiteNdx.toString(), addArtifact);
+      this.store = await this.givenThat(
+        subject,
+        testResourceConfiguration,
+        givenArtifactory,
+        this.givenCB,
+        this.initialValues,
+        proxiedPm
+      );
+    } catch (e) {
+      // console.error("Given failure: ", e.stack);
+      this.failed = true;
+      this.error = e.stack;
+      // throw e;
+    }
+
+    try {
+      // tLog(`\n Given this.store`, this.store);
+
+      for (const [whenNdx, whenStep] of this.whens.entries()) {
+        await whenStep.test(
+          this.store,
+          testResourceConfiguration,
+          tLog,
+          pm,
+          `suite-${suiteNdx}/given-${key}/when/${whenNdx}`
+        );
+      }
+
+      for (const [thenNdx, thenStep] of this.thens.entries()) {
+        const t = await thenStep.test(
+          this.store,
+          testResourceConfiguration,
+          tLog,
+          pm,
+          `suite-${suiteNdx}/given-${key}/then-${thenNdx}`
+        );
+        tester(t);
+      }
+    } catch (e) {
+      this.error = e.stack;
+      this.failed = true;
+      // tLog(e.stack);
+      // throw e;
+    } finally {
+      try {
+        // Ensure addArtifact is properly bound to 'this'
+        const addArtifact = this.addArtifact.bind(this);
+        const proxiedPm = afterEachProxy(
+          pm,
+          suiteNdx.toString(),
+          key,
+          addArtifact
+        );
+        // (proxiedPm as any).currentStep = this;
+        await this.afterEach(this.store, this.key, givenArtifactory, proxiedPm);
+      } catch (e) {
+        this.failed = e;
+        throw e;
+        // this.error = e.message;
+      }
+    }
+
+    return this.store;
+  }
+}

package/src/lib/BaseSuite.test/mock.ts

@@ -1,9 +1,12 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { BaseGiven, BaseWhen, BaseThen } from "../abstractBase";
+import { BaseGiven } from "../BaseGiven";
 import { BaseSuite } from "../BaseSuite";
+import { BaseThen } from "../BaseThen";
+import { BaseWhen } from "../BaseWhen";
 import { IPM } from "../types";
+
 import { I, TestStore, TestSelection, O } from "./test";
 
 export class MockGiven extends BaseGiven<I> {
@@ -77,7 +80,11 @@ export class MockSuite extends BaseSuite<I, O> {
       testGiven: new MockGiven(
         "testGiven",
         ["testFeature"],
-        [new MockWhen("testWhen", async () => Promise.resolve({ testSelection: true }))],
+        [
+          new MockWhen("testWhen", async () =>
+            Promise.resolve({ testSelection: true })
+          ),
+        ],
         [
           new MockThen("testThen", async () =>
             Promise.resolve(new BaseSuite("temp", 0, {} as any))

package/src/lib/BaseSuite.ts

@@ -4,10 +4,23 @@
 
 import { ITTestResourceConfiguration, ITestArtifactory } from ".";
 import { Ibdd_in_any, Ibdd_out_any } from "../CoreTypes";
-import { IGivens } from "./abstractBase";
+import { IGivens } from "./BaseGiven";
 import { beforeAllProxy, afterAllProxy } from "./pmProxy";
 import { IPM } from "./types";
 
+/**
+ * Represents a collection of test suites keyed by their names.
+ * Suites are organized as named collections because:
+ * - Tests are typically grouped into logical suites (e.g., by feature, component)
+ * - Suites may have different configurations or setup requirements
+ * - Named suites allow for selective test execution and better reporting
+ * - This supports the hierarchical structure of test organization
+ */
+export type ISuites<I extends Ibdd_in_any, O extends Ibdd_out_any> = Record<
+  string,
+  BaseSuite<I, O>
+>;
+
 export abstract class BaseSuite<I extends Ibdd_in_any, O extends Ibdd_out_any> {
   name: string;
   givens: IGivens<I>;