testeranto 0.197.0 → 0.199.0

package/dist/module/design-editor/DesignEditor.js

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import React, { useState, useEffect, useRef } from 'react';
-import { Canvas, Rect, Circle, Text } from 'fabric';
 import { toPng } from 'html-to-image';
 export const DesignEditor = React.forwardRef(({ projectId }, ref) => {
     const canvasRef = useRef(null);
@@ -13,7 +12,8 @@ export const DesignEditor = React.forwardRef(({ projectId }, ref) => {
     const wsRef = useRef(null);
     // Initialize canvas and WebSocket connection
     useEffect(() => {
-        const canvas = new Canvas('design-canvas', {
+        // @ts-ignore
+        const canvas = new fabric.Canvas('design-canvas', {
             width: 800,
             height: 600
         });
@@ -47,7 +47,8 @@ export const DesignEditor = React.forwardRef(({ projectId }, ref) => {
         let object;
         switch (shape) {
             case 'rectangle':
-                object = new Rect({
+                // @ts-ignore
+                object = new fabric.Rect({
                     width: 100,
                     height: 100,
                     fill: 'red',
@@ -56,7 +57,8 @@ export const DesignEditor = React.forwardRef(({ projectId }, ref) => {
                 });
                 break;
             case 'circle':
-                object = new Circle({
+                // @ts-ignore
+                object = new fabric.Circle({
                     radius: 50,
                     fill: 'blue',
                     left: 200,
@@ -64,7 +66,8 @@ export const DesignEditor = React.forwardRef(({ projectId }, ref) => {
                 });
                 break;
             case 'text':
-                object = new Text('Double click to edit', {
+                // @ts-ignore
+                object = new fabric.Text('Double click to edit', {
                     fontFamily: 'Arial',
                     fontSize: 20,
                     left: 100,

package/dist/module/src/App.js

@@ -29,18 +29,42 @@ 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/dist/module/src/Node.js

@@ -1,8 +1,9 @@
-import Testeranto from "./lib/core.js";
+// import Testeranto from "./lib/core.js";
 import { defaultTestResourceRequirement, } from "./lib/index.js";
 import { PM_Node } from "./PM/node.js";
+import Tiposkripto from "./lib/Tiposkripto.js";
 let ipcfile;
-export class NodeTesteranto extends Testeranto {
+export class NodeTesteranto extends Tiposkripto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
         super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, () => {
             // no-op

package/dist/module/src/PM/main.js

@@ -318,7 +318,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
                 logs.writeExitCode(-1, e3);
                 console.log(ansiC.red(ansiC.inverse(`${src} 1 errored with: ${e3}. Check logs for more info`)));
                 logs.exit.write(e3.stack);
-                logs.exit.write(-1);
+                logs.exit.write("-1");
                 this.bddTestIsNowDone(src, -1);
                 statusMessagePretty(-1, src, "pure");
             }

package/dist/module/src/Pure.js

@@ -1,7 +1,7 @@
-import Testeranto from "./lib/core.js";
 import { defaultTestResourceRequirement, } from "./lib/index.js";
+import Tiposkripto from "./lib/Tiposkripto.js";
 import { PM_Pure } from "./PM/pure.js";
-export class PureTesteranto extends Testeranto {
+export class PureTesteranto extends Tiposkripto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
         super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, () => {
             // no-op

package/dist/module/src/Web.js

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { PM_Web } from "./PM/web";
-import Testeranto from "./lib/core.js";
+import Tiposkripto from "./lib/Tiposkripto";
 import { defaultTestResourceRequirement, } from "./lib/index.js";
 // let errorCallback = (e: any) => {};
 // let unhandledrejectionCallback = (event: PromiseRejectionEvent) => {
@@ -10,7 +10,7 @@ import { defaultTestResourceRequirement, } from "./lib/index.js";
 //     JSON.stringify(event)
 //   );
 // };
-export class WebTesteranto extends Testeranto {
+export class WebTesteranto extends Tiposkripto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
         super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, (cb) => {
             // window.removeEventListener("error", errorCallback);

package/dist/module/src/components/DesignEditorPage.js

@@ -23,16 +23,45 @@ export const DesignEditorPage = () => {
             if (designEditorRef.current) {
                 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.showSaveFilePicker) {
+                try {
+                    newHandle = await window.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();
             await writable.write(jsonData);
@@ -60,15 +89,22 @@ export const DesignEditorPage = () => {
                 throw new Error('File System Access API not supported in this browser');
             }
             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/dist/module/src/lib/BaseGiven.js

@@ -0,0 +1,95 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { afterEachProxy, beforeEachProxy } from "./pmProxy.js";
+export class BaseGiven {
+    addArtifact(path) {
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
+    }
+    constructor(name, features, whens, thens, givenCB, initialValues) {
+        this.artifacts = [];
+        this.name = name;
+        this.features = features || [];
+        this.whens = whens || [];
+        this.thens = thens || [];
+        this.givenCB = givenCB;
+        this.initialValues = initialValues;
+    }
+    beforeAll(store) {
+        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 || [],
+        };
+    }
+    async afterEach(store, key, artifactory, pm) {
+        return store;
+    }
+    async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm, suiteNdx) {
+        this.key = key;
+        tLog(`\n ${this.key}`);
+        tLog(`\n Given: ${this.name}`);
+        const givenArtifactory = (fPath, value) => 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/dist/module/src/lib/BaseSuite.test/mock.js

@@ -1,7 +1,9 @@
 /* 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";
 export class MockGiven extends BaseGiven {
     constructor(name, features, whens, thens) {
         super(name, features, whens, thens, async () => ({ testStore: true }), // givenCB
@@ -42,7 +44,9 @@ export class MockSuite extends BaseSuite {
         }
         const suiteName = name || "testSuite";
         super(suiteName, index, {
-            testGiven: new MockGiven("testGiven", ["testFeature"], [new MockWhen("testWhen", async () => Promise.resolve({ testSelection: true }))], [
+            testGiven: new MockGiven("testGiven", ["testFeature"], [
+                new MockWhen("testWhen", async () => Promise.resolve({ testSelection: true })),
+            ], [
                 new MockThen("testThen", async () => Promise.resolve(new BaseSuite("temp", 0, {}))),
             ]),
         });

package/dist/module/src/lib/BaseThen.js

@@ -0,0 +1,60 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { butThenProxy } from "./pmProxy.js";
+export class BaseThen {
+    constructor(name, thenCB) {
+        this.artifacts = [];
+        this.name = name;
+        this.thenCB = thenCB;
+        this.error = false;
+        this.artifacts = [];
+    }
+    addArtifact(path) {
+        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;
+    }
+    async test(store, testResourceConfiguration, tLog, pm, filepath) {
+        // 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) => {
+            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;
+        });
+    }
+}

package/dist/module/src/lib/BaseWhen.js

@@ -0,0 +1,41 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { andWhenProxy } from "./pmProxy.js";
+export class BaseWhen {
+    addArtifact(path) {
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
+    }
+    constructor(name, whenCB) {
+        this.artifacts = [];
+        this.name = name;
+        this.whenCB = whenCB;
+    }
+    toObj() {
+        const obj = {
+            name: this.name,
+            error: this.error
+                ? `${this.error.name}: ${this.error.message}\n${this.error.stack}`
+                : null,
+            artifacts: this.artifacts || [],
+        };
+        console.log(`[TOOBJ] Serializing ${this.constructor.name} with artifacts:`, obj.artifacts);
+        return obj;
+    }
+    async test(store, testResourceConfiguration, tLog, pm, filepath) {
+        try {
+            // tLog(" When:", this.name);
+            // Ensure addArtifact is properly bound to 'this'
+            const addArtifact = this.addArtifact.bind(this);
+            const proxiedPm = andWhenProxy(pm, filepath, addArtifact);
+            // (proxiedPm as any).currentStep = this;
+            const result = await this.andWhen(store, this.whenCB, testResourceConfiguration, proxiedPm);
+            return result;
+        }
+        catch (e) {
+            console.error("[ERROR] When step failed:", this.name.toString(), e.toString());
+            this.error = e;
+            throw e;
+        }
+    }
+}

package/dist/module/src/lib/Tiposkripto.js

@@ -0,0 +1,146 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { defaultTestResourceRequirement, DefaultAdapter, } from "./index.js";
+import { BaseGiven } from "./BaseGiven";
+import { BaseWhen } from "./BaseWhen.js";
+import { BaseThen } from "./BaseThen.js";
+import { BaseSuite } from "./BaseSuite";
+export default class Tiposkripto {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testAdapter = {}, uberCatcher = (cb) => cb()) {
+        this.artifacts = [];
+        const fullAdapter = DefaultAdapter(testAdapter);
+        // Create classy implementations
+        const classySuites = Object.entries(testImplementation.suites).reduce((a, [key], index) => {
+            a[key] = (somestring, givens) => {
+                return new (class extends BaseSuite {
+                    afterAll(store, artifactory, pm) {
+                        return fullAdapter.afterAll(store, pm);
+                    }
+                    assertThat(t) {
+                        return fullAdapter.assertThis(t);
+                    }
+                    async setup(s, artifactory, tr, pm) {
+                        var _a, _b;
+                        return ((_b = (_a = fullAdapter.beforeAll) === null || _a === void 0 ? void 0 : _a.call(fullAdapter, s, tr, pm)) !== null && _b !== void 0 ? _b : s);
+                    }
+                })(somestring, index, givens);
+            };
+            return a;
+        }, {});
+        const classyGivens = Object.entries(testImplementation.givens).reduce((a, [key, g]) => {
+            a[key] = (name, features, whens, thens, gcb, initialValues) => {
+                return new (class extends BaseGiven {
+                    constructor() {
+                        super(...arguments);
+                        this.uberCatcher = uberCatcher;
+                    }
+                    async givenThat(subject, testResource, artifactory, initializer, initialValues, pm) {
+                        return fullAdapter.beforeEach(subject, initializer, testResource, initialValues, pm);
+                    }
+                    afterEach(store, key, artifactory, pm) {
+                        return Promise.resolve(fullAdapter.afterEach(store, key, pm));
+                    }
+                })(name, features, whens, thens, testImplementation.givens[key], initialValues);
+            };
+            return a;
+        }, {});
+        const classyWhens = Object.entries(testImplementation.whens).reduce((a, [key, whEn]) => {
+            a[key] = (...payload) => {
+                return new (class extends BaseWhen {
+                    async andWhen(store, whenCB, testResource, pm) {
+                        return await fullAdapter.andWhen(store, whenCB, testResource, pm);
+                    }
+                })(`${key}: ${payload && payload.toString()}`, whEn(...payload));
+            };
+            return a;
+        }, {});
+        const classyThens = Object.entries(testImplementation.thens).reduce((a, [key, thEn]) => {
+            a[key] = (...args) => {
+                return new (class extends BaseThen {
+                    async butThen(store, thenCB, testResource, pm) {
+                        return await fullAdapter.butThen(store, thenCB, testResource, pm);
+                    }
+                })(`${key}: ${args && args.toString()}`, thEn(...args));
+            };
+            return a;
+        }, {});
+        // Set up the overrides
+        this.suitesOverrides = classySuites;
+        this.givenOverides = classyGivens;
+        this.whenOverides = classyWhens;
+        this.thenOverides = classyThens;
+        this.testResourceRequirement = testResourceRequirement;
+        this.testSpecification = testSpecification;
+        // Generate specs
+        this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then());
+        // Create test jobs
+        this.testJobs = this.specs.map((suite) => {
+            const suiteRunner = (suite) => async (puppetMaster, tLog) => {
+                try {
+                    const x = await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
+                        this.artifacts.push(p);
+                    })(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value), tLog, puppetMaster);
+                    return x;
+                }
+                catch (e) {
+                    console.error(e.stack);
+                    throw e;
+                }
+            };
+            const runner = suiteRunner(suite);
+            return {
+                test: suite,
+                toObj: () => {
+                    return suite.toObj();
+                },
+                runner,
+                receiveTestResourceConfig: async function (puppetMaster) {
+                    const tLog = async (...l) => {
+                        //
+                    };
+                    try {
+                        const suiteDone = await runner(puppetMaster, tLog);
+                        const fails = suiteDone.fails;
+                        await puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2), "test");
+                        return {
+                            failed: fails > 0,
+                            fails,
+                            artifacts: this.artifacts || [],
+                            features: suiteDone.features(),
+                        };
+                    }
+                    catch (e) {
+                        console.error(e.stack);
+                        return {
+                            failed: true,
+                            fails: -1,
+                            artifacts: this.artifacts || [],
+                            features: [],
+                        };
+                    }
+                },
+            };
+        });
+    }
+    Specs() {
+        return this.specs;
+    }
+    Suites() {
+        return this.suitesOverrides;
+    }
+    Given() {
+        return this.givenOverides;
+    }
+    When() {
+        return this.whenOverides;
+    }
+    Then() {
+        return this.thenOverides;
+    }
+    // Add a method to access test jobs which can be used by receiveTestResourceConfig
+    getTestJobs() {
+        return this.testJobs;
+    }
+}

package/dist/module/src/lib/{core.test/MockCore.js → Tiposkripto.test/MockTiposkripto.js}

@@ -1,10 +1,10 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import TesterantoCore from "../core";
+import Tiposkripto from "../Tiposkripto";
 /**
- * Concrete implementation of Testeranto for testing purposes
+ * Concrete implementation of Tiposkripto for testing purposes
  */
-export class MockCore extends TesterantoCore {
+export class MockTiposkripto extends Tiposkripto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: [] }, testAdapter, uberCatcher = (cb) => cb()) {
         // Validate required implementation methods
         const requiredMethods = ["suites", "givens", "whens", "thens"];
@@ -13,8 +13,6 @@ export class MockCore extends TesterantoCore {
                 throw new Error(`Missing required implementation method: ${method}`);
             }
         });
-        // this.testResourceRequirement = testResourceRequirement;
-        // this.testAdapter = testAdapter;
         super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, uberCatcher);
         this.specs = [];
         this.testJobs = [];
@@ -25,7 +23,6 @@ export class MockCore extends TesterantoCore {
             failed: false,
             fails: 0,
             artifacts: [],
-            // logPromise: Promise.resolve(),
             features: [],
         };
     }