testeranto 0.197.0 → 0.198.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.198.0",
   "engines": {
     "node": "18.18.0"
   },
@@ -163,7 +163,8 @@
     "@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"
   },
@@ -227,7 +228,6 @@
     "react-router-dom": "^7.7.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",
@@ -241,4 +241,4 @@
     "xterm-addon-fit": "^0.8.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>;

package/src/lib/BaseThen.ts

@@ -0,0 +1,108 @@
+/* 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 } from "../CoreTypes";
+
+import { ITLog, ITTestResourceConfiguration } from ".";
+import { IPM } from "./types.js";
+import { butThenProxy } from "./pmProxy.js";
+
+export abstract class BaseThen<I extends Ibdd_in_any> {
+  public name: string;
+  thenCB: (storeState: I["iselection"], pm: IPM) => Promise<I["then"]>;
+  error: boolean;
+  artifacts: string[] = [];
+
+  constructor(
+    name: string,
+    thenCB: (val: I["iselection"]) => Promise<I["then"]>
+  ) {
+    this.name = name;
+    this.thenCB = thenCB;
+    this.error = false;
+    this.artifacts = [];
+  }
+
+  addArtifact(path: string) {
+    const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+    this.artifacts.push(normalizedPath);
+  }
+
+  toObj() {
+    const obj = {
+      name: this.name,
+      error: this.error,
+      artifacts: this.artifacts,
+    };
+    return obj;
+  }
+
+  abstract butThen(
+    store: I["istore"],
+    thenCB: (s: I["iselection"]) => Promise<I["isubject"]>,
+    testResourceConfiguration: ITTestResourceConfiguration,
+    pm: IPM
+  ): Promise<I["iselection"]>;
+
+  async test(
+    store: I["istore"],
+    testResourceConfiguration,
+    tLog: ITLog,
+    pm: IPM,
+    filepath: string
+  ): Promise<I["then"] | undefined> {
+    // Ensure addArtifact is properly bound to 'this'
+    const addArtifact = this.addArtifact.bind(this);
+    const proxiedPm = butThenProxy(pm, filepath, addArtifact);
+    return this.butThen(
+      store,
+      async (s: I["iselection"]) => {
+        try {
+          if (typeof this.thenCB === "function") {
+            // Add debug logging to see what's being passed to thenCB
+
+            // Check if the thenCB is spreading the arguments incorrectly
+            // Wrap the proxy to see what's happening when writeFileSync is called
+            const wrappedPm = new Proxy(proxiedPm, {
+              get: (target, prop, receiver) => {
+                if (prop === "writeFileSync") {
+                  return (...args) => {
+                    console.log(
+                      `[DEBUG] writeFileSync called with args:`,
+                      args
+                    );
+                    return target[prop](...args);
+                  };
+                }
+                return target[prop];
+              },
+            });
+            const result = await this.thenCB(s, wrappedPm);
+
+            return result;
+          } else {
+            return this.thenCB;
+          }
+        } catch (e) {
+          console.error(e.stack);
+        }
+      },
+      testResourceConfiguration,
+      proxiedPm
+    ).catch((e) => {
+      this.error = e.stack;
+      // throw e;
+    });
+  }
+}
+/**
+ * Represents a collection of Then assertions keyed by their names.
+ * Thens are typically part of Given definitions rather than standalone collections,
+ * but this type exists for consistency and potential future use cases where:
+ * - Assertions might need to be reused or composed dynamically
+ * - Custom assertion libraries could benefit from named assertion collections
+ * - Advanced validation patterns require named Then conditions
+ */
+export type IThens<I extends Ibdd_in_any> = Record<string, BaseThen<I>>;