testeranto 0.202.0 → 0.205.0

package/dist/types/src/app/frontend/testPage/ITestPageViewProps.d.ts

@@ -0,0 +1,14 @@
+export type ITestPageViewProps = {
+    projectName: string;
+    testName: string;
+    decodedTestPath: string;
+    runtime: string;
+    logs: Record<string, string>;
+    testsExist: boolean;
+    errorCounts: {
+        runTimeErrors: number;
+        typeErrors: number;
+        staticErrors: number;
+    };
+    isWebSocketConnected: boolean;
+};

package/dist/types/src/app/frontend/testPage/ProjectsTree.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+interface ProjectsTreeProps {
+    projects: string[];
+    currentProjectName: string;
+    currentTestName: string;
+    setExpandedSections: any;
+    expandedSections: any;
+    logs: any;
+    setActiveTab: any;
+    setSelectedFile: any;
+    runtime: any;
+    selectedSourcePath: any;
+    activeTab: any;
+    setSelectedSourcePath: any;
+}
+export declare const ProjectsTree: React.FC<ProjectsTreeProps>;
+export {};

package/dist/types/src/app/frontend/testPage/TestPageLeftContent.d.ts

@@ -0,0 +1,14 @@
+export declare const TestPageLeftContent: ({ projects, setExpandedSections, expandedSections, logs, setActiveTab, setSelectedFile, runtime, selectedSourcePath, activeTab, setSelectedSourcePath, projectName, testName, }: {
+    projects: any;
+    setExpandedSections: any;
+    expandedSections: any;
+    logs: any;
+    setActiveTab: any;
+    setSelectedFile: any;
+    runtime: any;
+    selectedSourcePath: any;
+    activeTab: any;
+    setSelectedSourcePath: any;
+    projectName: any;
+    testName: any;
+}) => JSX.Element;

package/dist/types/src/app/frontend/testPage/TestPageMainContent.d.ts

@@ -0,0 +1,7 @@
+export declare const TestPageMainContent: ({ selectedFile, buildErrors, projectName, testName, runtime, }: {
+    selectedFile: any;
+    buildErrors: any;
+    projectName: any;
+    testName: any;
+    runtime: any;
+}) => JSX.Element;

package/dist/types/src/app/frontend/testPage/TestPageNavbar.d.ts

@@ -0,0 +1,7 @@
+export declare const TestPageNavbar: ({ decodedTestPath, projectName, runtime, setShowAiderModal, isWebSocketConnected }: {
+    decodedTestPath: any;
+    projectName: any;
+    runtime: any;
+    setShowAiderModal: any;
+    isWebSocketConnected: any;
+}) => JSX.Element;

package/dist/types/src/app/frontend/testPage/TestPageView.d.ts

@@ -0,0 +1,2 @@
+import { ITestPageViewProps } from "./ITestPageViewProps";
+export declare const TestPageView: ({ projectName, testName, decodedTestPath, runtime, testsExist, errorCounts, logs, isWebSocketConnected, }: ITestPageViewProps) => JSX.Element;

package/dist/types/src/app/frontend/testPage/TestPageView.test/implementation.d.ts

@@ -0,0 +1,13 @@
+import { ITestImplementation } from "../../../../CoreTypes";
+import { ITTestResourceConfiguration } from "../../../../lib";
+import { IPM } from "../../../../lib/types";
+import { IInput, ISelection, IStore, ISubject, O } from "./types";
+export declare const implementation: ITestImplementation<{
+    iinput: IInput;
+    isubject: ISubject;
+    istore: IStore;
+    iselection: ISelection;
+    given: (props: IInput) => ISelection;
+    when: (sel: ISelection, tr: ITTestResourceConfiguration, utils: IPM) => Promise<(sel: ISelection) => ISelection>;
+    then: (sel: ISelection, tr: ITTestResourceConfiguration, utils: IPM) => Promise<(sel: ISelection) => ISelection>;
+}, O>;

package/dist/types/src/app/frontend/testPage/TestPageView.test/index.d.ts

@@ -0,0 +1,13 @@
+import "./../../../App.scss";
+declare const _default: Promise<import("../../../../Web").WebTesteranto<import("testeranto-react/src/react-dom/jsx/dynamic").I, import("./types").O, {
+    whens: import("../../../../Types").TestWhenImplementation<{
+        iinput: import("./types").IInput;
+        isubject: import("./types").ISubject;
+        istore: import("./types").IStore;
+        iselection: import("./types").ISelection;
+        given: (props: import("./types").IInput) => import("./types").ISelection;
+        when: (sel: import("./types").ISelection, tr: import("../../../../lib").ITTestResourceConfiguration, utils: import("../../../../lib/types").IPM) => Promise<(sel: import("./types").ISelection) => import("./types").ISelection>;
+        then: (sel: import("./types").ISelection, tr: import("../../../../lib").ITTestResourceConfiguration, utils: import("../../../../lib/types").IPM) => Promise<(sel: import("./types").ISelection) => import("./types").ISelection>;
+    }, import("./types").O>;
+}>>;
+export default _default;

package/dist/types/src/app/frontend/testPage/TestPageView.test/specification.d.ts

@@ -0,0 +1,11 @@
+import { ITestSpecification } from "../../../../CoreTypes";
+import { ISelection, O } from "./types";
+export declare const specification: ITestSpecification<{
+    iinput: any;
+    isubject: any;
+    istore: ISelection;
+    iselection: ISelection;
+    given: any;
+    when: any;
+    then: any;
+}, O>;

package/dist/types/src/app/frontend/testPage/TestPageView.test/types.d.ts

@@ -0,0 +1,65 @@
+import ReactDom from "react-dom/client";
+import { Ibdd_in, Ibdd_out } from "../../../../CoreTypes";
+import { IProjectPageViewProps } from "../../components/pure/ProjectPageView";
+export type IInput = IProjectPageViewProps;
+export type ISelection = {
+    htmlElement: HTMLElement;
+    reactElement: React.ReactElement;
+    domRoot: ReactDom.Root;
+};
+export type IStore = ISelection;
+export type ISubject = {
+    htmlElement: HTMLElement;
+    domRoot: ReactDom.Root;
+};
+export type I = Ibdd_in<IInput, ISubject, ISelection, IStore, (s: IStore) => IStore, (s: IStore) => IStore, {
+    hasContainerFluid: () => (s: IStore) => IStore;
+    hasNavBar: () => (s: IStore) => IStore;
+    hasNavBarTitle: () => (s: IStore) => IStore;
+    hasTestTable: () => (s: IStore) => IStore;
+    rendersTestSuite1: () => (s: IStore) => IStore;
+    rendersTestSuite2: () => (s: IStore) => IStore;
+    unhappyPath: () => (s: IStore) => IStore;
+    takeScreenshot: (name: string) => (s: IStore, pm: any) => Promise<IStore>;
+}>;
+export type O = Ibdd_out<{
+    Default: [string];
+    Navigation: [string];
+    ErrorStates: [string];
+}, {
+    Default: [];
+    WithError: [];
+    Navigation: [];
+    WithErrors: [];
+    WithLogs: [];
+}, {
+    SwitchToTab: [string];
+    ClickAiderButton: [];
+}, {
+    RendersNavBar: [];
+    ShowsErrorCounts: [];
+    ShowsTestResults: [];
+    ShowsActiveTab: [string];
+    ShowsLogs: [];
+    AiderButtonCopiesCommand: [];
+    takeScreenshot: [string];
+    ShowsTypeErrors: [];
+    ShowsLintErrors: [];
+}>;
+export type M = {
+    givens: {
+        [K in keyof O["givens"]]: (...args: any[]) => IProjectPageViewProps;
+    };
+    whens: {
+        [K in keyof O["whens"]]: (...args: any[]) => (props: IProjectPageViewProps, utils: any) => IProjectPageViewProps & {
+            container?: HTMLElement;
+        };
+    };
+    thens: {
+        [K in keyof O["thens"]]: (...args: any[]) => (state: IProjectPageViewProps & {
+            container?: HTMLElement;
+        }) => IProjectPageViewProps & {
+            container?: HTMLElement;
+        };
+    };
+};

package/dist/types/src/app/frontend/testPage/TestPageView_utils.d.ts

@@ -0,0 +1,23 @@
+type TestData = {
+    name: string;
+    givens: {
+        name: string;
+        whens: {
+            name: string;
+            error?: string;
+            features?: string[];
+            artifacts?: string[];
+        }[];
+        thens: {
+            name: string;
+            error?: string;
+            features?: string[];
+            artifacts?: string[];
+        }[];
+        features?: string[];
+        artifacts?: string[];
+    }[];
+};
+export declare const getLanguage: (path: string) => "python" | "json" | "typescript" | "javascript" | "markdown" | "plaintext";
+export declare const renderTestResults: (testData: TestData, buildErrors: any, projectName: any, testName: any, runtime: any) => JSX.Element;
+export {};

package/dist/types/src/app/frontend/useFs.d.ts

@@ -0,0 +1,2 @@
+export declare const FileServiceContext: import("react").Context<any>;
+export declare const useFs: () => any;

package/dist/types/src/app/frontend/useTerminalWebSocket.d.ts

@@ -0,0 +1,4 @@
+import { Process } from "./components/pure/ProcessManagerViewTypes";
+export declare const useTerminalWebSocket: (ws: WebSocket | null, selectedProcess: Process | null) => {
+    processLogs: string[];
+};

package/dist/types/src/app/frontend/useWebSocket.d.ts

@@ -0,0 +1,8 @@
+interface WebSocketContextType {
+    ws: WebSocket | null;
+    isConnected: boolean;
+    sendMessage: (message: any) => void;
+}
+export declare const WebSocketContext: import("react").Context<WebSocketContextType>;
+export declare const useWebSocket: () => WebSocketContextType;
+export {};

package/dist/types/src/app/types.d.ts

@@ -0,0 +1 @@
+export type IMode = "once" | "dev";

package/dist/types/src/builders/golang.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/builders/node.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/builders/python.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/builders/web.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/lib/BaseGiven.d.ts

@@ -11,7 +11,6 @@ import { IPM } from "./types.js";
  */
 export type IGivens<I extends Ibdd_in_any> = Record<string, BaseGiven<I>>;
 export declare abstract class BaseGiven<I extends Ibdd_in_any> {
-    name: string;
     features: string[];
     whens: any[];
     thens: any[];
@@ -24,18 +23,19 @@ export declare abstract class BaseGiven<I extends Ibdd_in_any> {
     key: string;
     failed: boolean;
     artifacts: string[];
+    status: boolean | undefined;
     addArtifact(path: string): void;
-    constructor(name: string, features: string[], whens: any[], thens: any[], givenCB: I["given"], initialValues: any);
+    constructor(features: string[], whens: any[], thens: any[], givenCB: I["given"], initialValues: any);
     beforeAll(store: I["istore"]): I["istore"];
     toObj(): {
         key: string;
-        name: string;
         whens: any[];
         thens: any[];
         error: (string | Error | undefined)[] | null;
         failed: boolean;
         features: string[];
         artifacts: string[];
+        status: boolean | undefined;
     };
     abstract givenThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: I["given"], initialValues: any, pm: IPM): Promise<I["istore"]>;
     afterEach(store: I["istore"], key: string, artifactory: ITestArtifactory, pm: IPM): Promise<I["istore"]>;

package/dist/types/src/lib/BaseSuite.d.ts

@@ -22,22 +22,23 @@ export declare abstract class BaseSuite<I extends Ibdd_in_any, O extends Ibdd_ou
     artifacts: string[];
     addArtifact(path: string): void;
     constructor(name: string, index: number, givens?: IGivens<I>);
-    features(): string[];
+    features(): any[];
     toObj(): {
         name: string;
         givens: {
             key: string;
-            name: string;
             whens: any[];
             thens: any[];
             error: (string | Error | undefined)[] | null;
             failed: boolean;
             features: string[];
             artifacts: string[];
+            status: boolean | undefined;
         }[];
         fails: number;
         failed: boolean;
-        features: string[];
+        features: any[];
+        artifacts: string[];
     };
     setup(s: I["iinput"], artifactory: ITestArtifactory, tr: ITTestResourceConfiguration, pm: IPM): Promise<I["isubject"]>;
     assertThat(t: Awaited<I["then"]> | undefined): boolean;

package/dist/types/src/lib/BaseSuite.test/pure.test.d.ts

@@ -1,2 +1,3 @@
-declare const _default: Promise<any>;
+import { I, O } from "./test";
+declare const _default: Promise<import("../../Pure").PureTesteranto<I, O, {}>>;
 export default _default;

package/dist/types/src/lib/BaseSuite.test/web.test.d.ts

@@ -1,2 +1,3 @@
-declare const _default: Promise<Testeranto<I, O, M>>;
+import { I, O } from "./test";
+declare const _default: Promise<import("../../Web").WebTesteranto<I, O, {}>>;
 export default _default;

package/dist/types/src/lib/BaseThen.d.ts

@@ -6,12 +6,14 @@ export declare abstract class BaseThen<I extends Ibdd_in_any> {
     thenCB: (storeState: I["iselection"], pm: IPM) => Promise<I["then"]>;
     error: boolean;
     artifacts: string[];
+    status: boolean | undefined;
     constructor(name: string, thenCB: (val: I["iselection"]) => Promise<I["then"]>);
     addArtifact(path: string): void;
     toObj(): {
         name: string;
         error: boolean;
         artifacts: string[];
+        status: boolean | undefined;
     };
     abstract butThen(store: I["istore"], thenCB: (s: I["iselection"]) => Promise<I["isubject"]>, testResourceConfiguration: ITTestResourceConfiguration, pm: IPM): Promise<I["iselection"]>;
     test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: IPM, filepath: string): Promise<I["then"] | undefined>;

package/dist/types/src/lib/BaseWhen.d.ts

@@ -6,11 +6,13 @@ export declare abstract class BaseWhen<I extends Ibdd_in_any> {
     whenCB: (x: I["iselection"]) => I["then"];
     error: Error;
     artifacts: string[];
+    status: boolean | undefined;
     addArtifact(path: string): void;
     constructor(name: string, whenCB: (xyz: I["iselection"]) => I["then"]);
     abstract andWhen(store: I["istore"], whenCB: (x: I["iselection"]) => I["then"], testResource: any, pm: IPM): Promise<any>;
     toObj(): {
         name: string;
+        status: boolean | undefined;
         error: string | null;
         artifacts: string[];
     };

package/dist/types/src/lib/pmProxy.test/mockPMBase.d.ts

@@ -1,6 +1,6 @@
 import { Browser } from "puppeteer-core";
 import { IBuiltConfig, ITLog } from "../index";
-import { PM_Base } from "../../PM/base";
+import { PM_Base } from "../../app/backend/PM_0";
 export declare class MockPMBase implements PM_Base {
     browser: Browser;
     configs: IBuiltConfig;

package/dist/types/src/utils/generateGolingvuMetafile.d.ts

@@ -0,0 +1,2 @@
+import { GolingvuMetafile } from "./golingvuMetafile/types";
+export declare function generateGolingvuMetafile(testName: string, entryPoints: string[]): Promise<GolingvuMetafile>;

package/dist/types/src/utils/golingvuMetafile/fileDiscovery.d.ts

@@ -0,0 +1 @@
+export declare function collectGoDependencies(filePath: string, visited?: Set<string>): string[];

package/dist/types/src/utils/golingvuMetafile/goList.d.ts

@@ -0,0 +1,2 @@
+import { GoListOutput } from "./types";
+export declare function runGoList(pattern: string): GoListOutput[];

package/dist/types/src/utils/golingvuMetafile/helpers.d.ts

@@ -0,0 +1,7 @@
+export declare function findProjectRoot(): string;
+export declare function findAndParseGoMod(startDir: string): {
+    root: string;
+    modulePath: string;
+} | null;
+export declare function calculateImportPath(filePath: string): string | null;
+export declare function normalizeImportPath(importPath: string): string;

package/dist/types/src/utils/golingvuMetafile/importParser.d.ts

@@ -0,0 +1,5 @@
+export declare function parseGoImports(filePath: string): {
+    path: string;
+    kind: string;
+    external?: boolean;
+}[];

package/dist/types/src/utils/golingvuMetafile/types.d.ts

@@ -0,0 +1,66 @@
+export interface GolingvuMetafile {
+    errors: any[];
+    warnings: any[];
+    metafile: {
+        inputs: Record<string, {
+            bytes: number;
+            imports: {
+                path: string;
+                kind: string;
+                external?: boolean;
+            }[];
+            format?: string;
+        }>;
+        outputs: Record<string, {
+            imports: any[];
+            exports: any[];
+            entryPoint: string;
+            inputs: Record<string, {
+                bytesInOutput: number;
+            }>;
+            bytes: number;
+            signature: string;
+        }>;
+    };
+}
+export interface GoListOutput {
+    Dir: string;
+    ImportPath: string;
+    ImportComment?: string;
+    Name: string;
+    Target?: string;
+    Stale?: boolean;
+    StaleReason?: string;
+    Root?: string;
+    GoFiles?: string[];
+    CgoFiles?: string[];
+    IgnoredGoFiles?: string[];
+    CFiles?: string[];
+    CXXFiles?: string[];
+    MFiles?: string[];
+    HFiles?: string[];
+    FFiles?: string[];
+    SFiles?: string[];
+    SwigFiles?: string[];
+    SwigCXXFiles?: string[];
+    SysoFiles?: string[];
+    Imports?: string[];
+    Deps?: string[];
+    TestImports?: string[];
+    XTestImports?: string[];
+    Module?: {
+        Path: string;
+        Version: string;
+        Replace?: {
+            Path: string;
+            Version: string;
+        };
+        Main: boolean;
+        Dir: string;
+        GoMod: string;
+        GoVersion: string;
+    };
+    Match?: string[];
+    DepOnly?: boolean;
+    Standard?: boolean;
+}

package/dist/types/src/utils/golingvuMetafile.d.ts

@@ -1,19 +1,4 @@
-export interface GolingvuBuildResult {
-    errors: any[];
-    warnings: any[];
-    metafile?: {
-        inputs: Record<string, {
-            bytes: number;
-            imports: any[];
-        }>;
-        outputs: Record<string, {
-            bytes: number;
-            inputs: Record<string, {
-                bytesInOutput: number;
-            }>;
-            entryPoint: string;
-        }>;
-    };
-}
-export declare function generateGolangMetafile(testName: string, entryPoints: string[]): Promise<GolingvuBuildResult>;
-export declare function writeGolangMetafile(testName: string, metafile: GolingvuBuildResult): void;
+import { generateGolingvuMetafile as gmf } from "./generateGolingvuMetafile";
+import { writeGolingvuMetafile as wgmf } from "./writeGolingvuMetafile";
+export declare const generateGolingvuMetafile: typeof gmf;
+export declare const writeGolingvuMetafile: typeof wgmf;

package/dist/types/src/utils/golingvuWatcher.d.ts

@@ -0,0 +1,14 @@
+export declare class GolingvuWatcher {
+    private watcher;
+    private testName;
+    private entryPoints;
+    private onChangeCallback;
+    private debounceTimer;
+    constructor(testName: string, entryPoints: string[]);
+    start(): Promise<void>;
+    private handleFileChange;
+    private readAndCheckSignature;
+    regenerateMetafile(): Promise<void>;
+    onMetafileChange(callback: () => void): void;
+    stop(): void;
+}

package/dist/types/src/utils/logFiles.d.ts

@@ -1,4 +1,4 @@
-export type RuntimeName = 'node' | 'web' | 'pure';
+export type RuntimeName = 'node' | 'web' | 'pure' | 'python' | 'golang';
 export declare const LOG_FILES: {
     readonly TESTS: "tests.json";
     readonly TYPE_ERRORS: "type_errors.txt";
@@ -34,6 +34,14 @@ export declare const RUNTIME_SPECIFIC_LOGS: {
         readonly DEBUG: "debug.log";
     };
     readonly pure: {};
+    readonly python: {
+        readonly STDOUT: "stdout.log";
+        readonly STDERR: "stderr.log";
+    };
+    readonly golang: {
+        readonly STDOUT: "stdout.log";
+        readonly STDERR: "stderr.log";
+    };
 };
 export declare const ALL_LOGS: {
     readonly STDOUT: "stdout.log";
@@ -65,6 +73,26 @@ export declare const ALL_LOGS: {
     readonly MESSAGE: "message.txt";
     readonly PROMPT: "prompt.txt";
     readonly BUILD: "build.json";
+} | {
+    readonly STDOUT: "stdout.log";
+    readonly STDERR: "stderr.log";
+    readonly TESTS: "tests.json";
+    readonly TYPE_ERRORS: "type_errors.txt";
+    readonly LINT_ERRORS: "lint_errors.txt";
+    readonly EXIT: "exit.log";
+    readonly MESSAGE: "message.txt";
+    readonly PROMPT: "prompt.txt";
+    readonly BUILD: "build.json";
+} | {
+    readonly STDOUT: "stdout.log";
+    readonly STDERR: "stderr.log";
+    readonly TESTS: "tests.json";
+    readonly TYPE_ERRORS: "type_errors.txt";
+    readonly LINT_ERRORS: "lint_errors.txt";
+    readonly EXIT: "exit.log";
+    readonly MESSAGE: "message.txt";
+    readonly PROMPT: "prompt.txt";
+    readonly BUILD: "build.json";
 };
 export declare const getRuntimeLogs: (runtime: RuntimeName) => {
     standard: ("tests.json" | "type_errors.txt" | "lint_errors.txt" | "prompt.txt" | "exit.log" | "message.txt" | "build.json")[];

package/dist/types/src/utils/pitonoMetafile.d.ts

@@ -1,7 +1,22 @@
 export interface PitonoMetafile {
-    testName: string;
-    entryPoints: string[];
-    timestamp: number;
+    errors: any[];
+    warnings: any[];
+    metafile: {
+        inputs: Record<string, {
+            bytes: number;
+            imports: any[];
+        }>;
+        outputs: Record<string, {
+            imports: any[];
+            exports: any[];
+            entryPoint: string;
+            inputs: Record<string, {
+                bytesInOutput: number;
+            }>;
+            bytes: number;
+            signature: string;
+        }>;
+    };
 }
 export declare function generatePitonoMetafile(testName: string, entryPoints: string[]): Promise<PitonoMetafile>;
 export declare function writePitonoMetafile(testName: string, metafile: PitonoMetafile): void;

package/dist/types/src/utils/pitonoWatcher.d.ts

@@ -0,0 +1,13 @@
+export declare class PitonoWatcher {
+    private watcher;
+    private testName;
+    private entryPoints;
+    private onChangeCallback;
+    constructor(testName: string, entryPoints: string[]);
+    start(): Promise<void>;
+    private handleFileChange;
+    private readAndCheckSignature;
+    regenerateMetafile(): Promise<void>;
+    onMetafileChange(callback: () => void): void;
+    stop(): void;
+}

package/dist/types/src/utils/writeGolingvuMetafile.d.ts

@@ -0,0 +1,2 @@
+import { GolingvuMetafile } from "./golingvuMetafile/types";
+export declare function writeGolingvuMetafile(testName: string, metafile: GolingvuMetafile): void;