testeranto 0.177.0 → 0.197.0

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

@@ -0,0 +1,18 @@
+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 {};

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

@@ -0,0 +1 @@
+export declare function startDesignEditorServer(wssPort: number, httpPort?: number): void;

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

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

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

@@ -6,7 +6,7 @@ export declare abstract class PM {
     testResourceConfiguration: ITTestResourceConfiguration;
     abstract start(): Promise<void>;
     abstract stop(): Promise<void>;
-    abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): any;
+    abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (promise: Promise<any>) => void): any;
     abstract $(selector: string, page: string): any;
     abstract click(selector: string): any;
     abstract closePage(p: any): any;

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

@@ -1,20 +1,50 @@
 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;
     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]>;
@@ -30,14 +60,18 @@ export declare class PM_Main extends PM_WithEslintAndTsc {
         pureEntryPointSidecars: {};
     }) => IRunnables;
     metafileOutputs(platform: IRunTime): Promise<void>;
-    launchPure: (src: string, dest: string) => Promise<void>;
-    launchNode: (src: string, dest: string) => Promise<void>;
-    launchWebSideCar: (testConfig: ITestTypes) => Promise<[number, ITTestResourceConfiguration]>;
+    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]>;
     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;
 }
+export {};

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

@@ -5,12 +5,14 @@ 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<boolean>;
+    stopSideCar(uid: number): Promise<any>;
     server: PuppetMasterServer;
     testResourceConfiguration: ITTestResourceConfiguration;
     constructor(t: ITTestResourceConfiguration);
+    protected trackCall(method: string, args: any): void;
     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;
@@ -27,14 +29,15 @@ export declare class PM_Pure extends PM {
     click(selector: string): string | undefined;
     screencast(opts: ScreencastOptions, page: string): any;
     screencastStop(p: string): any;
-    customScreenShot(opts: ScreencastOptions, page: string): any;
+    customScreenShot(opts: {
+        path: string;
+    }, page?: string): any;
     existsSync(destFolder: string): Promise<boolean>;
-    mkdirSync(): any;
-    write(uid: number, contents: string): any;
-    writeFileSync(x: any): any;
-    createWriteStream(filepath: string): any;
+    mkdirSync(): boolean;
+    write(uid: number, contents: string): Promise<boolean>;
+    writeFileSync(): Promise<boolean>;
     end(uid: number): any;
     customclose(): void;
-    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): void;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (promise: Promise<any>) => void): (fPath: string, value: string | Buffer | any) => void;
 }
 export {};

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

@@ -18,7 +18,7 @@ export declare class PM_Web extends PM {
     stopSideCar(n: number): Promise<any>;
     launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]>;
     waitForSelector(p: string, s: string): any;
-    screencast(o: ScreencastOptions, p: string | Page): Promise<string>;
+    screencast(opts: ScreencastOptions, page: string | Page): Promise<string>;
     screencastStop(recorder: string): any;
     closePage(p: any): string;
     goto(p: any, url: string): any;

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

@@ -4,20 +4,32 @@ type I = Ibdd_in<null, // No initial input needed
 IPM, // Test subject is IPM
 {
     pm: IPM;
+    artifacts?: any[];
+    testJobs?: any[];
+    specs?: any[];
+    largePayload?: boolean;
 }, // Store contains PM instance
 {
     pm: IPM;
 }, // Selection is same as store
-() => IPM, // Given returns IPM
+() => {
+    pm: IPM;
+    config: {};
+    proxies: any;
+}, // Given returns initial state
 (store: {
     pm: IPM;
+    [key: string]: any;
 }) => {
     pm: IPM;
+    [key: string]: any;
 }, // When modifies store
 (store: {
     pm: IPM;
+    [key: string]: any;
 }) => {
     pm: IPM;
+    [key: string]: any;
 }>;
 type O = Ibdd_out<{
     Default: [string];

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

@@ -106,6 +106,7 @@ export type ITestconfig = {
     src: string;
     tests: ITestTypes[];
     webPlugins: IPluginFactory[];
+    webLoaders: Record<string, string>;
 };
 export type IBuiltConfig = {
     buildDir: string;

package/dist/types/src/components/DesignEditorPage.d.ts

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

package/dist/types/src/components/SunriseAnimation.d.ts

@@ -0,0 +1,5 @@
+interface SunriseAnimationProps {
+    active: boolean;
+}
+declare const SunriseAnimation: ({ active }: SunriseAnimationProps) => JSX.Element | null;
+export default SunriseAnimation;

package/dist/types/src/components/SunriseAnimation.test/interface.d.ts

@@ -0,0 +1,11 @@
+import { IInput, ISelection, ISubject } from './types';
+import { ITestInterface } from "../../CoreTypes";
+export declare const interface: ITestInterface<{
+    iinput: IInput;
+    isubject: ISubject;
+    istore: ISelection;
+    iselection: ISelection;
+    given: (props: IInput) => ISelection;
+    when: (sel: ISelection) => ISelection;
+    then: (sel: ISelection) => Promise<ISelection>;
+}>;

package/dist/types/src/components/SunriseAnimation.test/types.d.ts

@@ -0,0 +1,39 @@
+import { Ibdd_out } from "../../CoreTypes";
+import * as React from 'react';
+import * as ReactDom from 'react-dom/client';
+export type IInput = {
+    active: boolean;
+    duration?: number;
+    color?: string;
+};
+export type ISelection = {
+    container: HTMLDivElement;
+    reactElement: React.ReactElement;
+    domRoot: ReactDom.Root;
+    animationElement: HTMLElement | null;
+};
+export type IStore = ISelection;
+export type ISubject = {
+    container: HTMLDivElement;
+    domRoot: ReactDom.Root;
+};
+export type O = Ibdd_out<{
+    Default: [string];
+    AnimationBehavior: [string];
+    Customization: [string];
+}, {
+    Default: [];
+    Active: [];
+    Inactive: [];
+    WithCustomDuration: [number];
+    WithCustomColor: [string];
+}, {
+    ToggleActive: [];
+}, {
+    RendersContainer: [];
+    ShowsWhenActive: [];
+    HidesWhenInactive: [];
+    HasAnimation: [];
+    HasDuration: [number];
+    HasColor: [string];
+}>;

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

@@ -0,0 +1,11 @@
+import React from 'react';
+type AppFrameProps = {
+    children: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    'data-testid'?: string;
+    title?: string;
+    rightContent?: React.ReactNode;
+};
+export declare const AppFrame: ({ children, title, rightContent }: AppFrameProps) => JSX.Element;
+export {};

package/dist/types/src/components/pure/AppFrame.test/implementation.d.ts

@@ -0,0 +1,3 @@
+import { ITestImplementation } from "../../../CoreTypes";
+import { I, O } from "./types";
+export declare const implementation: ITestImplementation<I, O>;

package/dist/types/src/components/pure/AppFrame.test/index.d.ts

@@ -0,0 +1,5 @@
+import "../../../App.scss";
+declare const _default: Promise<import("../../../lib/core").default<import("testeranto-react/src/react-dom/component/dynamic").I, import("./types").O, {
+    whens: import("../../../Types").TestWhenImplementation<import("./types").I, import("./types").O>;
+}>>;
+export default _default;

package/dist/types/src/components/pure/AppFrame.test/specification.d.ts

@@ -0,0 +1,3 @@
+import { ITestSpecification } from "../../../CoreTypes";
+import { I, O } from "./types";
+export declare const specification: ITestSpecification<I, O>;

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

@@ -0,0 +1,33 @@
+import * as React from "react";
+import * as ReactDom from "react-dom/client";
+import { Ibdd_in, Ibdd_out } from "../../../CoreTypes";
+export type IInput = {
+    children: React.ReactNode;
+};
+export type ISelection = {
+    htmlElement: HTMLElement;
+    reactElement: React.ReactElement;
+    domRoot: HTMLElement | null;
+    container?: HTMLElement;
+    testId?: string;
+};
+export type IStore = ISelection;
+export type ISubject = {
+    htmlElement: HTMLElement;
+    domRoot: ReactDom.Root;
+};
+export type O = Ibdd_out<{
+    Default: [string];
+    Layout: [string];
+}, {
+    Default: [];
+    WithChildren: [React.ReactNode];
+}, {}, {
+    RendersContainer: [];
+    HasMainContent: [];
+    HasFooter: [];
+    HasSettingsButton: [];
+    HasTesterantoLink: [];
+    takeScreenshot: [string];
+}>;
+export type I = Ibdd_in<IInput, ISubject, ISelection, IStore, (s: IStore) => IStore, (s: IStore) => IStore, {}>;

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

@@ -0,0 +1,7 @@
+import React from 'react';
+import { TreeNode } from '../../types/features';
+interface FeaturesReporterViewProps {
+    treeData: TreeNode[];
+}
+export declare const FeaturesReporterView: React.FC<FeaturesReporterViewProps>;
+export {};

package/dist/types/src/components/pure/FeaturesReporterView.test/implementation.d.ts

@@ -0,0 +1,3 @@
+import { ITestImplementation } from "../../../CoreTypes";
+import { I, M, O } from "./types";
+export declare const implementation: ITestImplementation<I, O, M>;

package/dist/types/src/components/pure/FeaturesReporterView.test/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Promise<import("../../../lib/core").default<import("testeranto-react/src/react-dom/component/dynamic").I, import("./types").O, import("./types").M>>;
+export default _default;

package/dist/types/src/components/pure/FeaturesReporterView.test/specification.d.ts

@@ -0,0 +1,3 @@
+import { ITestSpecification } from "../../../CoreTypes";
+import { I, O } from "./types";
+export declare const specification: ITestSpecification<I, O>;

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

@@ -0,0 +1,54 @@
+import ReactDom from "react-dom/client";
+import { Ibdd_in, Ibdd_out } from "../../../CoreTypes";
+import { TreeNode } from "../../../types/features";
+export type IInput = {
+    treeData: TreeNode[];
+};
+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, {
+    hasProjectNames: () => (s: IStore) => IStore;
+    hasFilePaths: () => (s: IStore) => IStore;
+    hasTestNames: () => (s: IStore) => IStore;
+    hasStatusBadges: () => (s: IStore) => IStore;
+    showsEmptyMessage: () => (s: IStore) => IStore;
+    takeScreenshot: (name: string) => (s: IStore, pm: any) => Promise<IStore>;
+}>;
+export type O = Ibdd_out<{
+    Default: [string];
+}, {
+    Default: [];
+    WithEmptyData: [];
+}, {}, {
+    hasProjectNames: [];
+    hasFilePaths: [];
+    hasTestNames: [];
+    hasStatusBadges: [];
+    showsEmptyMessage: [];
+    takeScreenshot: [string];
+}>;
+export type M = {
+    givens: {
+        [K in keyof O["givens"]]: (...args: any[]) => IInput;
+    };
+    whens: {
+        [K in keyof O["whens"]]: (...args: any[]) => (props: IInput, utils: any) => IInput & {
+            container?: HTMLElement;
+        };
+    };
+    thens: {
+        [K in keyof O["thens"]]: (...args: any[]) => (state: IInput & {
+            container?: HTMLElement;
+        }) => IInput & {
+            container?: HTMLElement;
+        };
+    };
+};

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

@@ -0,0 +1,7 @@
+import React from "react";
+import "../../App.scss";
+export type IModalContentProps = {
+    theme: string;
+    handleThemeChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+};
+export declare const ModalContent: ({ theme, handleThemeChange, }: IModalContentProps) => JSX.Element;

package/dist/types/src/components/pure/ModalContent.test/implementation.d.ts

@@ -0,0 +1,3 @@
+import { ITestImplementation } from "../../../CoreTypes";
+import { I, M, O } from "./types";
+export declare const implementation: ITestImplementation<I, O, M>;

package/dist/types/src/components/pure/ModalContent.test/index.d.ts

@@ -0,0 +1,3 @@
+import { I, O } from "./types";
+declare const _default: Promise<import("../../../lib/core").default<import("testeranto-react/src/react-dom/component/dynamic").I, I, O>>;
+export default _default;

package/dist/types/src/components/pure/ModalContent.test/specification.d.ts

@@ -0,0 +1,3 @@
+import { ITestSpecification } from "../../../CoreTypes";
+import { I, O } from "./types";
+export declare const specification: ITestSpecification<I, O>;

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

@@ -0,0 +1,45 @@
+import ReactDom from "react-dom/client";
+import { Ibdd_in, Ibdd_out } from "../../../CoreTypes";
+import { IModalContentProps } from "../ModalContent";
+export type IInput = IModalContentProps;
+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, {
+    hasModalHeader: () => (s: IStore) => IStore;
+    hasThemeCards: () => (s: IStore) => IStore;
+    takeScreenshot: (name: string) => (s: IStore, pm: any) => Promise<IStore>;
+}>;
+export type O = Ibdd_out<{
+    Default: [string];
+}, {
+    Default: [];
+}, {}, {
+    hasModalHeader: [];
+    hasThemeCards: [];
+    takeScreenshot: [string];
+}>;
+export type M = {
+    givens: {
+        [K in keyof O["givens"]]: (...args: any[]) => IModalContentProps;
+    };
+    whens: {
+        [K in keyof O["whens"]]: (...args: any[]) => (props: IModalContentProps, utils: any) => IModalContentProps & {
+            container?: HTMLElement;
+        };
+    };
+    thens: {
+        [K in keyof O["thens"]]: (...args: any[]) => (state: IModalContentProps & {
+            container?: HTMLElement;
+        }) => IModalContentProps & {
+            container?: HTMLElement;
+        };
+    };
+};

package/dist/types/src/{NavBar.d.ts → components/pure/NavBar.d.ts}

@@ -8,12 +8,16 @@ type NavItem = {
         variant: string;
         text: string;
     };
+    icon?: React.ReactNode;
 };
 type NavBarProps = {
     title: string;
     backLink?: string;
     navItems?: NavItem[];
     rightContent?: React.ReactNode;
+    showProcessManagerLink?: boolean;
+    onToggleCollapse?: () => void;
+    isCollapsed?: boolean;
 };
 export declare const NavBar: React.FC<NavBarProps>;
 export {};

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

@@ -0,0 +1,8 @@
+import React from 'react';
+interface ProcessManagerProps {
+    show: boolean;
+    onHide: () => void;
+    ws: WebSocket | null;
+}
+export declare const ProcessManager: React.FC<ProcessManagerProps>;
+export {};

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

@@ -0,0 +1,20 @@
+import React from "react";
+export interface Process {
+    processId: string;
+    command: string;
+    pid?: number;
+    status?: "running" | "exited" | "error";
+    exitCode?: number;
+    error?: string;
+    timestamp: string;
+    logs?: string[];
+}
+interface ProcessManagerViewProps {
+    processes: Process[];
+    onRefresh: () => void;
+    onBack: () => void;
+    loading: boolean;
+    onKillProcess?: (processId: string) => void;
+}
+export declare const ProcessManagerView: React.FC<ProcessManagerViewProps>;
+export {};

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

@@ -1,14 +1,14 @@
+import "./../../App.scss";
 export type IProjectPageViewProps = {
     summary: any;
     nodeLogs: any;
     webLogs: any;
     pureLogs: any;
     config: any;
-    loading: any;
-    error: any;
-    projectName: any;
-    route: any;
-    setRoute: any;
-    navigate: any;
+    loading: boolean;
+    error: string | null;
+    projectName: string;
+    activeTab: string;
+    setActiveTab: (tab: string) => void;
 };
-export declare const ProjectPageView: ({ summary, nodeLogs, webLogs, pureLogs, config, loading, error, projectName, route, setRoute, navigate }: IProjectPageViewProps) => JSX.Element;
+export declare const ProjectPageView: ({ summary, nodeLogs, webLogs, pureLogs, config, loading, error, projectName, activeTab, setActiveTab }: IProjectPageViewProps) => JSX.Element;

package/dist/types/src/components/pure/ProjectPageView.test/index.d.ts

@@ -1,3 +1,2 @@
-import { I, O } from "./types";
-declare const _default: Promise<import("../../../lib/core").default<import("testeranto-react/src/react-dom/component/dynamic").I, I, O>>;
+declare const _default: Promise<import("../../../lib/core").default<import("testeranto-react/src/react-dom/component/dynamic").I, import("./types").O, import("./types").M>>;
 export default _default;

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

@@ -1,24 +1,42 @@
+import ReactDom from "react-dom/client";
 import { Ibdd_in, Ibdd_out } from "../../../CoreTypes";
 import { IProjectPageViewProps } from "../ProjectPageView";
-export type I = Ibdd_in<null, IProjectPageViewProps, IProjectPageViewProps & {
-    container?: HTMLElement;
-}, IProjectPageViewProps & {
-    container?: HTMLElement;
-}, (...args: any[]) => IProjectPageViewProps, () => (props: IProjectPageViewProps, utils: any) => IProjectPageViewProps & {
-    container?: HTMLElement;
-}, () => (state: IProjectPageViewProps & {
-    container?: HTMLElement;
-}) => IProjectPageViewProps & {
-    container?: HTMLElement;
+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];
 }, {
     Default: [];
     WithError: [];
+    Navigation: [];
 }, {}, {
-    happyPath: [];
+    hasContainerFluid: [];
+    hasNavBar: [];
+    hasNavBarTitle: [];
+    hasTestTable: [];
+    rendersTestSuite1: [];
+    rendersTestSuite2: [];
     unhappyPath: [];
+    takeScreenshot: [string];
 }>;
 export type M = {
     givens: {

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

@@ -0,0 +1,29 @@
+type Project = {
+    name: string;
+    nodeStatus: string;
+    webStatus: string;
+    pureStatus: string;
+};
+type TestSummary = {
+    [testName: string]: {
+        testsExist?: boolean;
+        runTimeErrors?: number;
+        typeErrors?: number;
+        staticErrors?: number;
+    };
+};
+type ProjectConfig = {
+    [projectName: string]: {
+        tests: [string, string][];
+    };
+};
+type ProjectsPageViewProps = {
+    projects: Project[];
+    summaries: TestSummary;
+    configs: ProjectConfig;
+    loading: boolean;
+    error: string | null;
+    navigate: (path: string) => void;
+};
+export declare const ProjectsPageView: ({ projects, summaries, configs, loading, error, navigate, }: ProjectsPageViewProps) => JSX.Element;
+export {};

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

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