testeranto 0.200.0 → 0.202.0

package/dist/types/design-editor/DesignEditor.d.ts

@@ -1,18 +1 @@
-import React from 'react';
-interface DesignObject {
-    type: string;
-    [key: string]: any;
-}
-interface Design {
-    version: string;
-    background: string;
-    objects: DesignObject[];
-}
-export interface DesignEditorRef {
-    loadDesign: (design: Design) => void;
-    saveDesign: () => Design | null;
-}
-export declare const DesignEditor: React.ForwardRefExoticComponent<{
-    projectId: string;
-} & React.RefAttributes<DesignEditorRef>>;
-export {};
+export declare const DesignEditor: () => JSX.Element;

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

@@ -1 +1,19 @@
+interface WebSocketContextType {
+    ws: WebSocket | null;
+    isConnected: boolean;
+}
+interface TutorialModeContextType {
+    tutorialMode: boolean;
+    setTutorialMode: (mode: boolean) => void;
+}
+interface AuthContextType {
+    isAuthenticated: boolean;
+    user: any;
+    login: () => void;
+    logout: () => void;
+}
+export declare const useWebSocket: () => WebSocketContextType;
+export declare const useTutorialMode: () => TutorialModeContextType;
+export declare const useAuth: () => AuthContextType;
 export declare const App: () => JSX.Element;
+export {};

package/dist/types/src/PM/PM_WithBuild.d.ts

@@ -0,0 +1,13 @@
+import { IBuiltConfig } from "../Types.js";
+import { PM_WithWebSocket } from "./PM_WithWebSocket.js";
+export declare abstract class PM_WithBuild extends PM_WithWebSocket {
+    configs: IBuiltConfig;
+    name: string;
+    mode: "once" | "dev";
+    currentBuildResolve: (() => void) | null;
+    currentBuildReject: ((error: any) => void) | null;
+    constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev");
+    startBuildProcesses(): Promise<void>;
+    private startBuildProcess;
+    abstract onBuildDone(): void;
+}

package/dist/types/src/PM/PM_WithEslintAndTsc.d.ts

@@ -1,8 +1,6 @@
 import { IBuiltConfig, IRunTime, ISummary } from "../Types.js";
-import { PM_Base } from "./base.js";
-export declare abstract class PM_WithEslintAndTsc extends PM_Base {
-    name: string;
-    mode: "once" | "dev";
+import { PM_WithBuild } from "./PM_WithBuild.js";
+export declare abstract class PM_WithEslintAndTsc extends PM_WithBuild {
     summary: ISummary;
     constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev");
     tscCheck: ({ entrypoint, addableFiles, platform, }: {

package/dist/types/src/PM/PM_WithGit.d.ts

@@ -0,0 +1,27 @@
+import http from "http";
+import { IBuiltConfig } from "../Types.js";
+import { PM_WithEslintAndTsc } from "./PM_WithEslintAndTsc.js";
+export declare abstract class PM_WithGit extends PM_WithEslintAndTsc {
+    gitWatchTimeout: NodeJS.Timeout | null;
+    gitWatcher: any;
+    constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev");
+    requestHandler(req: http.IncomingMessage, res: http.ServerResponse): void;
+    private handleGitApi;
+    private handleGitChanges;
+    private handleGitFileStatus;
+    private handleGitCommit;
+    private handleGitPush;
+    private handleGitPull;
+    private handleGitBranch;
+    private handleGitHubTokenExchange;
+    private handleGitRemoteStatus;
+    private getGitFileStatus;
+    private executeGitCommit;
+    private executeGitPush;
+    private executeGitPull;
+    onBuildDone(): void;
+    startGitWatcher(): Promise<void>;
+    private getGitChanges;
+    private getGitRemoteStatus;
+    private getCurrentGitBranch;
+}

package/dist/types/src/PM/PM_WithProcesses.d.ts

@@ -0,0 +1,29 @@
+import fs from "fs";
+import { IBuiltConfig, IRunTime } from "../Types.js";
+import { createLogStreams } from "./utils.js";
+import { PM_WithGit } from "./PM_WithGit.js";
+export declare abstract class PM_WithProcesses extends PM_WithGit {
+    webMetafileWatcher: fs.FSWatcher;
+    nodeMetafileWatcher: fs.FSWatcher;
+    importMetafileWatcher: fs.FSWatcher;
+    pitonoMetafileWatcher: fs.FSWatcher;
+    ports: Record<number, string>;
+    queue: string[];
+    logStreams: Record<string, ReturnType<typeof createLogStreams>>;
+    launchers: Record<string, () => void>;
+    abstract launchNode(src: string, dest: string): any;
+    abstract launchWeb(src: string, dest: string): any;
+    abstract launchPure(src: string, dest: string): any;
+    abstract launchPython(src: string, dest: string): any;
+    abstract launchGolang(src: string, dest: string): any;
+    constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev");
+    metafileOutputs(platform: IRunTime): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    receiveFeaturesV2: (reportDest: string, srcTest: string, platform: IRunTime) => void;
+    findIndexHtml(): string | null;
+    addToQueue(src: string, runtime: IRunTime): void;
+    checkQueue(): void;
+    onBuildDone(): void;
+    checkForShutdown: () => void;
+}

package/dist/types/src/PM/PM_WithWebSocket.d.ts

@@ -0,0 +1,108 @@
+import { ChildProcess } from "node:child_process";
+import http from "http";
+import { WebSocketServer } from "ws";
+import { PM_Base } from "./base.js";
+export declare abstract class PM_WithWebSocket extends PM_Base {
+    wss: WebSocketServer;
+    clients: Set<any>;
+    httpServer: http.Server;
+    runningProcesses: Map<string, ChildProcess | Promise<any>>;
+    allProcesses: Map<string, {
+        child?: ChildProcess;
+        promise?: Promise<any>;
+        status: "running" | "exited" | "error" | "completed";
+        exitCode?: number;
+        error?: string;
+        command: string;
+        pid?: number;
+        timestamp: string;
+        type: "process" | "promise";
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName?: string;
+        platform?: "node" | "web" | "pure" | "python" | "golang";
+    }>;
+    processLogs: Map<string, string[]>;
+    constructor(configs: any);
+    requestHandler(req: http.IncomingMessage, res: http.ServerResponse): void;
+    findIndexHtml(): string | null;
+    addPromiseProcess(processId: string, promise: Promise<any>, command: string, category?: "aider" | "bdd-test" | "build-time" | "other", testName?: string, platform?: "node" | "web" | "pure" | "python" | "golang", onResolve?: (result: any) => void, onReject?: (error: any) => void): string;
+    broadcast(message: any): void;
+    getProcessesByCategory(category: "aider" | "bdd-test" | "build-time" | "other"): {
+        processId: string;
+        command: string;
+        pid: number | undefined;
+        status: "error" | "running" | "exited" | "completed";
+        exitCode: number | undefined;
+        error: string | undefined;
+        timestamp: string;
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName: string | undefined;
+        platform: "node" | "web" | "pure" | "golang" | "python" | undefined;
+        logs: string[];
+    }[];
+    getBDDTestProcesses(): {
+        processId: string;
+        command: string;
+        pid: number | undefined;
+        status: "error" | "running" | "exited" | "completed";
+        exitCode: number | undefined;
+        error: string | undefined;
+        timestamp: string;
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName: string | undefined;
+        platform: "node" | "web" | "pure" | "golang" | "python" | undefined;
+        logs: string[];
+    }[];
+    getBuildTimeProcesses(): {
+        processId: string;
+        command: string;
+        pid: number | undefined;
+        status: "error" | "running" | "exited" | "completed";
+        exitCode: number | undefined;
+        error: string | undefined;
+        timestamp: string;
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName: string | undefined;
+        platform: "node" | "web" | "pure" | "golang" | "python" | undefined;
+        logs: string[];
+    }[];
+    getAiderProcesses(): {
+        processId: string;
+        command: string;
+        pid: number | undefined;
+        status: "error" | "running" | "exited" | "completed";
+        exitCode: number | undefined;
+        error: string | undefined;
+        timestamp: string;
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName: string | undefined;
+        platform: "node" | "web" | "pure" | "golang" | "python" | undefined;
+        logs: string[];
+    }[];
+    getProcessesByTestName(testName: string): {
+        processId: string;
+        command: string;
+        pid: number | undefined;
+        status: "error" | "running" | "exited" | "completed";
+        exitCode: number | undefined;
+        error: string | undefined;
+        timestamp: string;
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName: string | undefined;
+        platform: "node" | "web" | "pure" | "golang" | "python" | undefined;
+        logs: string[];
+    }[];
+    getProcessesByPlatform(platform: "node" | "web" | "pure" | "pitono" | "golang"): {
+        processId: string;
+        command: string;
+        pid: number | undefined;
+        status: "error" | "running" | "exited" | "completed";
+        exitCode: number | undefined;
+        error: string | undefined;
+        timestamp: string;
+        category: "aider" | "bdd-test" | "build-time" | "other";
+        testName: string | undefined;
+        platform: "node" | "web" | "pure" | "golang" | "python" | undefined;
+        logs: string[];
+    }[];
+}

package/dist/types/src/PM/base.d.ts

@@ -6,7 +6,7 @@ export declare abstract class PM_Base {
     browser: Browser;
     configs: IBuiltConfig;
     constructor(configs: IBuiltConfig);
-    abstract launchSideCar(n: number, testName: string, projectName: string): any;
+    mapping(): [string, (...a: any[]) => any][];
     customclose(): void;
     waitForSelector(p: string, s: string): any;
     closePage(p: any): any;

package/dist/types/src/PM/index.d.ts

@@ -32,6 +32,4 @@ export declare abstract class PM {
     abstract waitForSelector(p: any, sel: string): any;
     abstract write(uid: number, contents: string): Promise<boolean>;
     abstract writeFileSync(f: string, c: string): Promise<boolean>;
-    abstract launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]>;
-    abstract stopSideCar(n: number): Promise<any>;
 }

package/dist/types/src/PM/main.d.ts

@@ -1,79 +1,8 @@
-import { ChildProcess } from "node:child_process";
-import { Page } from "puppeteer-core/lib/esm/puppeteer";
-import fs from "fs";
-import { WebSocketServer } from "ws";
-import http from "http";
-import { IRunnables, ITTestResourceConfiguration } from "../lib/index.js";
-import { IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
-import { Sidecar } from "../lib/Sidecar.js";
-import { PM_WithEslintAndTsc } from "./PM_WithEslintAndTsc.js";
-type LogStreams = {
-    closeAll: () => void;
-    writeExitCode: (code: number, error?: Error) => void;
-    stdout?: fs.WriteStream;
-    stderr?: fs.WriteStream;
-    info?: fs.WriteStream;
-    warn?: fs.WriteStream;
-    error?: fs.WriteStream;
-    debug?: fs.WriteStream;
-    exit: fs.WriteStream;
-};
-declare function createLogStreams(reportDest: string, runtime: IRunTime): LogStreams;
-export declare class PM_Main extends PM_WithEslintAndTsc {
-    ports: Record<number, string>;
-    queue: string[];
-    logStreams: Record<string, ReturnType<typeof createLogStreams>>;
-    webMetafileWatcher: fs.FSWatcher;
-    nodeMetafileWatcher: fs.FSWatcher;
-    importMetafileWatcher: fs.FSWatcher;
-    pitonoMetafileWatcher: fs.FSWatcher;
-    pureSidecars: Record<number, Sidecar>;
-    nodeSidecars: Record<number, ChildProcess>;
-    webSidecars: Record<number, Page>;
-    sidecars: Record<number, any>;
-    launchers: Record<string, () => void>;
-    wss: WebSocketServer;
-    clients: Set<any>;
-    httpServer: http.Server;
-    runningProcesses: Map<string, ChildProcess>;
-    allProcesses: Map<string, {
-        child?: ChildProcess;
-        status: "running" | "exited" | "error";
-        exitCode?: number;
-        error?: string;
-        command: string;
-        pid?: number;
-        timestamp: string;
-    }>;
-    processLogs: Map<string, string[]>;
-    constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev");
-    stopSideCar(uid: number): Promise<any>;
-    launchSideCar(n: number, name: string): Promise<[number, ITTestResourceConfiguration]>;
-    mapping(): [string, (...a: any[]) => any][];
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    getRunnables: (tests: ITestTypes[], testName: string, payload?: {
-        nodeEntryPoints: {};
-        nodeEntryPointSidecars: {};
-        webEntryPoints: {};
-        webEntryPointSidecars: {};
-        pureEntryPoints: {};
-        pureEntryPointSidecars: {};
-    }) => IRunnables;
-    metafileOutputs(platform: IRunTime): Promise<void>;
-    launchPure: (src: string, dest: string) => Promise<(string | number)[] | undefined>;
-    launchNode: (src: string, dest: string) => Promise<any[] | undefined>;
-    launchWebSideCar: (testConfig: ITestTypes) => Promise<[number, Page]>;
-    launchNodeSideCar: (sidecar: ITestTypes) => Promise<[number, ITTestResourceConfiguration]>;
-    stopPureSideCar: (uid: number) => Promise<void>;
-    launchPureSideCar: (sidecar: ITestTypes) => Promise<[number, ITTestResourceConfiguration]>;
-    launchPitono: (src: string, dest: string) => Promise<void>;
+import { PM_WithProcesses } from "./PM_WithProcesses.js";
+export declare class PM_Main extends PM_WithProcesses {
+    launchPure: (src: string, dest: string) => Promise<void>;
+    launchNode: (src: string, dest: string) => Promise<void>;
     launchWeb: (src: string, dest: string) => Promise<void>;
-    receiveFeaturesV2: (reportDest: string, srcTest: string, platform: IRunTime) => void;
-    requestHandler(req: http.IncomingMessage, res: http.ServerResponse): void;
-    findIndexHtml(): string | null;
-    broadcast(message: any): void;
-    checkQueue(): void;
-    checkForShutdown: () => void;
+    launchPython: (src: string, dest: string) => Promise<void>;
+    launchGolang: (src: string, dest: string) => Promise<void>;
 }
-export {};

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

@@ -10,8 +10,6 @@ export declare class PM_Node extends PM {
     start(): Promise<void>;
     stop(): Promise<void>;
     send<I>(command: string, ...argz: any[]): Promise<I>;
-    launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]>;
-    stopSideCar(n: number): Promise<any>;
     pages(): Promise<string[]>;
     waitForSelector(p: string, s: string): any;
     closePage(p: any): Promise<unknown>;

package/dist/types/src/PM/pure.d.ts

@@ -5,7 +5,6 @@ import { PM } from ".";
 type PuppetMasterServer = Record<string, Promise<any>>;
 export declare class PM_Pure extends PM {
     getInnerHtml(selector: string, page: string): Promise<string>;
-    stopSideCar(uid: number): Promise<any>;
     server: PuppetMasterServer;
     testResourceConfiguration: ITTestResourceConfiguration;
     constructor(t: ITTestResourceConfiguration);
@@ -13,7 +12,6 @@ export declare class PM_Pure extends PM {
     start(): Promise<void>;
     stop(): Promise<void>;
     createWriteStream(filepath: string, testName: string): Promise<string>;
-    launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]>;
     pages(): any;
     waitForSelector(p: string, s: string): any;
     closePage(p: any): string;

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

@@ -0,0 +1,118 @@
+export type ProcessStatus = "running" | "exited" | "error" | "completed";
+export type ProcessType = "process" | "promise";
+export type ProcessCategory = "aider" | "bdd-test" | "build-time" | "other";
+export type ProcessPlatform = "node" | "web" | "pure" | "pitono" | "golang";
+export interface ProcessInfo {
+    child?: any;
+    promise?: Promise<any>;
+    status: ProcessStatus;
+    exitCode?: number;
+    error?: string;
+    command: string;
+    pid?: number;
+    timestamp: string;
+    type: ProcessType;
+    category: ProcessCategory;
+    testName?: string;
+    platform?: ProcessPlatform;
+}
+export interface ProcessData {
+    processId: string;
+    command: string;
+    pid?: number;
+    status: ProcessStatus;
+    exitCode?: number;
+    error?: string;
+    timestamp: string;
+    category: ProcessCategory;
+    testName?: string;
+    platform?: ProcessPlatform;
+    logs: string[];
+}
+export interface ProcessManager {
+    allProcesses: Map<string, ProcessInfo>;
+    processLogs: Map<string, string[]>;
+    addPromiseProcess: (processId: string, promise: Promise<any>, command: string, category?: ProcessCategory, testName?: string, platform?: ProcessPlatform, onResolve?: (result: any) => void, onReject?: (error: any) => void) => string;
+    broadcast: (message: any) => void;
+    getProcessesByCategory: (category: ProcessCategory) => any[];
+    getBDDTestProcesses: () => any[];
+    getBuildTimeProcesses: () => any[];
+    getAiderProcesses: () => any[];
+    getProcessesByTestName: (testName: string) => any[];
+    getProcessesByPlatform: (platform: ProcessPlatform) => any[];
+}
+export interface WebSocketMessage {
+    type: string;
+    [key: string]: any;
+}
+export interface ExecuteCommandMessage extends WebSocketMessage {
+    type: "executeCommand";
+    command: string;
+}
+export interface GetRunningProcessesMessage extends WebSocketMessage {
+    type: "getRunningProcesses";
+}
+export interface GetProcessMessage extends WebSocketMessage {
+    type: "getProcess";
+    processId: string;
+}
+export interface StdinMessage extends WebSocketMessage {
+    type: "stdin";
+    processId: string;
+    data: string;
+}
+export interface KillProcessMessage extends WebSocketMessage {
+    type: "killProcess";
+    processId: string;
+}
+export interface ProcessStartedEvent {
+    type: "processStarted";
+    processId: string;
+    command: string;
+    timestamp: string;
+    logs: string[];
+}
+export interface ProcessStdoutEvent {
+    type: "processStdout";
+    processId: string;
+    data: string;
+    timestamp: string;
+}
+export interface ProcessStderrEvent {
+    type: "processStderr";
+    processId: string;
+    data: string;
+    timestamp: string;
+}
+export interface ProcessExitedEvent {
+    type: "processExited";
+    processId: string;
+    exitCode: number;
+    timestamp: string;
+    logs?: string[];
+}
+export interface ProcessErrorEvent {
+    type: "processError";
+    processId: string;
+    error: string;
+    timestamp: string;
+    logs?: string[];
+}
+export interface RunningProcessesEvent {
+    type: "runningProcesses";
+    processes: ProcessData[];
+}
+export interface ProcessDataEvent {
+    type: "processData";
+    processId: string;
+    command: string;
+    pid?: number;
+    status: ProcessStatus;
+    exitCode?: number;
+    error?: string;
+    timestamp: string;
+    category: ProcessCategory;
+    testName?: string;
+    platform?: ProcessPlatform;
+    logs: string[];
+}

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

@@ -0,0 +1,35 @@
+import fs from "fs";
+import { IRunTime } from "../Types";
+export type IOutputs = Record<string, {
+    entryPoint: string;
+    inputs: Record<string, string>;
+}>;
+export type LogStreams = {
+    closeAll: () => void;
+    writeExitCode: (code: number, error?: Error) => void;
+    stdout?: fs.WriteStream;
+    stderr?: fs.WriteStream;
+    info?: fs.WriteStream;
+    warn?: fs.WriteStream;
+    error?: fs.WriteStream;
+    debug?: fs.WriteStream;
+    exit: fs.WriteStream;
+};
+export declare function runtimeLogs(runtime: IRunTime, reportDest: string): Record<string, fs.WriteStream>;
+export declare function createLogStreams(reportDest: string, runtime: IRunTime): LogStreams;
+export declare function fileHash(filePath: any, algorithm?: string): Promise<string>;
+export declare const statusMessagePretty: (failures: number, test: string, runtime: IRunTime) => void;
+export declare function writeFileAndCreateDir(filePath: any, data: any): Promise<void>;
+export declare const filesHash: (files: string[], algorithm?: string) => Promise<string>;
+export declare function isValidUrl(string: any): boolean;
+export declare function pollForFile(path: any, timeout?: number): Promise<void>;
+export declare const puppeteerConfigs: {
+    slowMo: number;
+    waitForInitialPage: boolean;
+    executablePath: string;
+    headless: boolean;
+    defaultViewport: null;
+    dumpio: boolean;
+    devtools: boolean;
+    args: string[];
+};

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

@@ -15,8 +15,6 @@ export declare class PM_Web extends PM {
     stop(): Promise<void>;
     getInnerHtml(selector: string, page: string): void;
     pages(): Promise<string[]>;
-    stopSideCar(n: number): Promise<any>;
-    launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]>;
     waitForSelector(p: string, s: string): any;
     screencast(opts: ScreencastOptions, page: string | Page): Promise<string>;
     screencastStop(recorder: string): any;

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

@@ -3,7 +3,12 @@ import { ITTestResourceRequest } from "./lib/index.js";
 import Tiposkripto from "./lib/Tiposkripto.js";
 export declare class PureTesteranto<I extends Ibdd_in_any, O extends Ibdd_out, M> extends Tiposkripto<I, O, M> {
     constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest, testAdapter: Partial<ITestAdapter<I>>);
-    receiveTestResourceConfig(partialTestResource: string): Promise<import("./lib/index.js").IFinalResults>;
+    receiveTestResourceConfig(partialTestResource: string): Promise<import("./lib/index.js").IFinalResults | {
+        failed: boolean;
+        fails: number;
+        artifacts: never[];
+        features: never[];
+    }>;
 }
 declare const _default: <I extends Ibdd_in_any, O extends Ibdd_out, M>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testAdapter: Partial<ITestAdapter<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<number | Testeranto<I, O, M>>;
 export default _default;

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

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

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

@@ -1 +0,0 @@
-export declare const ReportServerOfPort: (port: number) => void;

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

@@ -7,6 +7,7 @@ import { IGivens, BaseGiven } from "./lib/BaseGiven.js";
 import { BaseThen } from "./lib/BaseThen.js";
 import { BaseWhen } from "./lib/BaseWhen.js";
 export type ISummary = Record<string, {
+    runTimeTests: number | "?" | undefined;
     runTimeErrors: number | "?" | undefined;
     typeErrors: number | "?" | undefined;
     staticErrors: number | "?" | undefined;

package/dist/types/src/components/pure/BuildLogViewer.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface BuildLogViewerProps {
+    logs: any;
+    runtime: string;
+}
+export declare const BuildLogViewer: React.FC<BuildLogViewerProps>;
+export {};

package/dist/types/src/components/pure/DebugEnv.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const DebugEnv: React.FC;

package/dist/types/src/components/pure/FileTree.d.ts

@@ -0,0 +1,6 @@
+export declare const FileTree: ({ data, onSelect, level, selectedSourcePath }: {
+    data: any;
+    onSelect: any;
+    level?: number | undefined;
+    selectedSourcePath: any;
+}) => JSX.Element;

package/dist/types/src/components/pure/FileTreeItem.d.ts

@@ -0,0 +1,8 @@
+export declare const FileTreeItem: ({ name, isFile, level, isSelected, exists, onClick }: {
+    name: string;
+    isFile: boolean;
+    level: number;
+    isSelected: boolean;
+    exists?: boolean;
+    onClick: () => void;
+}) => JSX.Element;

package/dist/types/src/components/pure/GitHubLoginButton.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface GitHubLoginButtonProps {
+    className?: string;
+    variant?: string;
+    size?: 'sm' | 'lg';
+}
+export declare const GitHubLoginButton: React.FC<GitHubLoginButtonProps>;
+export {};

package/dist/types/src/components/pure/GitIntegrationView.d.ts

@@ -0,0 +1 @@
+export declare const GitIntegrationView: () => JSX.Element;

package/dist/types/src/components/pure/Settings.d.ts

@@ -0,0 +1 @@
+export declare const Settings: () => JSX.Element;

package/dist/types/src/components/pure/Settings.test.d.ts

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

package/dist/types/src/components/pure/SignIn.d.ts

@@ -0,0 +1 @@
+export declare const SignIn: () => JSX.Element;

package/dist/types/src/components/pure/SingleProcessView.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { Process } from './ProcessManagerView';
+interface SingleProcessViewProps {
+    process: Process | null;
+    onBack: () => void;
+    loading: boolean;
+    onKillProcess?: (processId: string) => void;
+}
+export declare const SingleProcessView: React.FC<SingleProcessViewProps>;
+export {};

package/dist/types/src/components/pure/TestPageView.d.ts

@@ -10,6 +10,7 @@ type TestPageViewProps = {
         typeErrors: number;
         staticErrors: number;
     };
+    isWebSocketConnected: boolean;
 };
-export declare const TestPageView: ({ projectName, testName, decodedTestPath, runtime, testsExist, errorCounts, logs, }: TestPageViewProps) => JSX.Element;
+export declare const TestPageView: ({ projectName, testName, decodedTestPath, runtime, testsExist, errorCounts, logs, isWebSocketConnected, }: TestPageViewProps) => JSX.Element;
 export {};