@tui-sandbox/library 1.0.0 → 1.0.2

package/dist/src/client/validateMouseEvent.d.ts

@@ -0,0 +1 @@
+export declare function validateMouseEvent(data: string): string | undefined;

package/dist/src/client/validateMouseEvent.js

@@ -0,0 +1,13 @@
+// Function to parse mouse events
+// https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Button-event-tracking
+export function validateMouseEvent(data) {
+    const match = /\x1b\[<(\d+);(\d+);(\d+)([mM])/.exec(data);
+    if (match) {
+        const buttonCode = parseInt(match[1], 10);
+        const column = parseInt(match[2], 10);
+        const row = parseInt(match[3], 10);
+        const isRelease = match[4] === "m";
+        console.log(`Mouse event: buttonCode=${buttonCode}, column=${column}, row=${row}, isRelease=${isRelease}`);
+        return data;
+    }
+}

package/dist/src/client/websocket-client.d.ts

@@ -0,0 +1,25 @@
+import { Terminal } from "@xterm/xterm";
+import "@xterm/xterm/css/xterm.css";
+import type { StartNeovimGenericArguments } from "../server/neovim/NeovimApplication.ts";
+import type { TestDirectory } from "../server/types.ts";
+import type { TabId } from "../server/utilities/tabId.ts";
+import "./style.css";
+export type StartTerminalOptions = {
+    onMouseEvent: (data: string) => void;
+    onKeyPress: (event: {
+        key: string;
+        domEvent: KeyboardEvent;
+    }) => void;
+};
+export declare function startTerminal(app: HTMLElement, options: StartTerminalOptions): Terminal;
+/** An identifier unique to a browser tab, so that each tab can have its own
+ * unique session that persists across page reloads. */
+export declare function getTabId(): TabId;
+export declare class NeovimClient {
+    private readonly ready;
+    private readonly tabId;
+    private readonly terminal;
+    private readonly trpc;
+    constructor(app: HTMLElement);
+    startNeovim(args: StartNeovimGenericArguments): Promise<TestDirectory>;
+}

package/dist/src/client/websocket-client.js

@@ -0,0 +1,127 @@
+import { flavors } from "@catppuccin/palette";
+import { createTRPCClient, createWSClient, wsLink } from "@trpc/client";
+import { FitAddon } from "@xterm/addon-fit";
+import { Terminal } from "@xterm/xterm";
+import "@xterm/xterm/css/xterm.css";
+import z from "zod";
+import "./style.css";
+import { validateMouseEvent } from "./validateMouseEvent";
+export function startTerminal(app, options) {
+    const terminal = new Terminal({
+        cursorBlink: false,
+        convertEol: true,
+        fontSize: 13,
+    });
+    const colors = flavors.macchiato.colors;
+    terminal.options.theme = {
+        background: colors.base.hex,
+        black: colors.crust.hex,
+        brightBlack: colors.surface2.hex,
+        blue: colors.blue.hex,
+        brightBlue: colors.blue.hex,
+        brightCyan: colors.sky.hex,
+        brightRed: colors.maroon.hex,
+        brightYellow: colors.yellow.hex,
+        cursor: colors.text.hex,
+        cyan: colors.sky.hex,
+        foreground: colors.text.hex,
+        green: colors.green.hex,
+        magenta: colors.lavender.hex,
+        red: colors.red.hex,
+        white: colors.text.hex,
+        yellow: colors.yellow.hex,
+    };
+    // The FitAddon makes the terminal fit the size of the container, the entire
+    // page in this case
+    const fitAddon = new FitAddon();
+    terminal.loadAddon(fitAddon);
+    terminal.open(app);
+    fitAddon.fit();
+    window.addEventListener("resize", () => {
+        fitAddon.fit();
+    });
+    terminal.onData(data => {
+        data;
+        // Send mouse clicks to the terminal application
+        //
+        // this gets called for mouse events. However, some mouse events seem to
+        // confuse Neovim, so for now let's just send click events
+        if (typeof data !== "string") {
+            throw new Error(`unexpected onData message type: '${JSON.stringify(data)}'`);
+        }
+        const mouseEvent = validateMouseEvent(data);
+        if (mouseEvent) {
+            options.onMouseEvent(mouseEvent);
+        }
+    });
+    terminal.onKey(event => {
+        options.onKeyPress(event);
+    });
+    return terminal;
+}
+/** An identifier unique to a browser tab, so that each tab can have its own
+ * unique session that persists across page reloads. */
+export function getTabId() {
+    // Other tabs will have a different id because sessionStorage is unique to
+    // each tab.
+    let tabId = z.string().safeParse(sessionStorage.getItem("tabId")).data;
+    if (!tabId) {
+        tabId = Math.random().toString(36);
+        sessionStorage.setItem("tabId", tabId);
+    }
+    return { tabId };
+}
+export class NeovimClient {
+    ready;
+    tabId;
+    terminal;
+    trpc;
+    constructor(app) {
+        const wsClient = createWSClient({ url: `ws://localhost:3000`, WebSocket });
+        const trpc = createTRPCClient({
+            links: [wsLink({ client: wsClient })],
+        });
+        this.trpc = trpc;
+        this.tabId = getTabId();
+        const tabId = this.tabId;
+        const terminal = startTerminal(app, {
+            onMouseEvent(data) {
+                void trpc.neovim.sendStdin.mutate({ tabId, data }).catch((error) => {
+                    console.error(`Error sending mouse event`, error);
+                });
+            },
+            onKeyPress(event) {
+                void trpc.neovim.sendStdin.mutate({ tabId, data: event.key });
+            },
+        });
+        this.terminal = terminal;
+        // start listening to Neovim stdout - this will take some (short) amount of
+        // time to complete
+        this.ready = new Promise(resolve => {
+            console.log("Subscribing to Neovim stdout");
+            trpc.neovim.onStdout.subscribe({ client: tabId }, {
+                onStarted() {
+                    resolve();
+                },
+                onData(data) {
+                    terminal.write(data);
+                },
+                onError(err) {
+                    console.error(`Error from Neovim`, err);
+                },
+            });
+        });
+    }
+    async startNeovim(args) {
+        await this.ready;
+        const neovim = await this.trpc.neovim.start.mutate({
+            startNeovimArguments: args,
+            tabId: this.tabId,
+            terminalDimensions: {
+                cols: this.terminal.cols,
+                rows: this.terminal.rows,
+            },
+        });
+        return neovim;
+    }
+}

package/dist/src/server/connection/trpc.d.ts

@@ -0,0 +1,44 @@
+import type { CreateWSSContextFnOptions } from "@trpc/server/adapters/ws";
+import type { Socket } from "net";
+import type { WebSocket } from "ws";
+export type Connection = {
+    clientId: WebSocket;
+    socket: Socket;
+};
+export declare function createContext(opts: CreateWSSContextFnOptions): Connection;
+export declare const trpc: {
+    _config: import("@trpc/server/unstable-core-do-not-import").RootConfig<{
+        ctx: Connection;
+        meta: object;
+        errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+        transformer: false;
+    }>;
+    procedure: import("@trpc/server/unstable-core-do-not-import").ProcedureBuilder<Connection, object, object, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, false>;
+    middleware: <$ContextOverrides>(fn: import("@trpc/server/unstable-core-do-not-import").MiddlewareFunction<Connection, object, object, $ContextOverrides, unknown>) => import("@trpc/server/unstable-core-do-not-import").MiddlewareBuilder<Connection, object, $ContextOverrides, unknown>;
+    router: {
+        <TInput extends import("@trpc/server").RouterRecord>(input: TInput): import("@trpc/server/unstable-core-do-not-import").BuiltRouter<{
+            ctx: Connection;
+            meta: object;
+            errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+            transformer: false;
+        }, TInput>;
+        <TInput extends import("@trpc/server/unstable-core-do-not-import").CreateRouterOptions>(input: TInput): import("@trpc/server/unstable-core-do-not-import").BuiltRouter<{
+            ctx: Connection;
+            meta: object;
+            errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+            transformer: false;
+        }, import("@trpc/server/unstable-core-do-not-import").DecorateCreateRouterOptions<TInput>>;
+    };
+    mergeRouters: typeof import("@trpc/server/unstable-core-do-not-import").mergeRouters;
+    createCallerFactory: <TRecord extends import("@trpc/server").RouterRecord>(router: Pick<import("@trpc/server/unstable-core-do-not-import").Router<{
+        ctx: Connection;
+        meta: object;
+        errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+        transformer: false;
+    }, TRecord>, "_def">) => import("@trpc/server/unstable-core-do-not-import").RouterCaller<{
+        ctx: Connection;
+        meta: object;
+        errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+        transformer: false;
+    }, TRecord>;
+};

package/dist/src/server/connection/trpc.js

@@ -0,0 +1,5 @@
+import { initTRPC } from "@trpc/server";
+export function createContext(opts) {
+    return { clientId: opts.res, socket: opts.req.socket };
+}
+export const trpc = initTRPC.context().create();

package/dist/src/server/dirtree/index.d.ts

@@ -0,0 +1,25 @@
+import type { Dree } from "dree";
+import { Type } from "dree";
+type TreeResult = {
+    dree: Dree;
+    allFiles: Dree[];
+};
+/** Convert a directory tree to a TypeScript type. This is useful for testing
+ * as the initial state of the test directory is fully known in tests. */
+export declare function getDirectoryTree(path: string): TreeResult;
+type FileNode = {
+    type: Type.FILE;
+    name: string;
+    extension: string | undefined;
+    stem: string;
+};
+type DirectoryNode = {
+    type: Type.DIRECTORY;
+    name: string;
+    contents: Record<string, TreeNode>;
+};
+type TreeNode = FileNode | DirectoryNode;
+export declare function convertDree(root: Dree): TreeNode;
+export declare function buildSchemaForDirectoryTree(result: TreeResult, name: string): Promise<string>;
+export declare function buildTestDirectorySchema(testDirectoryPath: string): Promise<string>;
+export {};

package/dist/src/server/dirtree/index.js

@@ -0,0 +1,80 @@
+import assert from "assert";
+import { scan, Type } from "dree";
+import { format, resolveConfig } from "prettier";
+import { fileURLToPath } from "url";
+import { jsonToZod } from "./json-to-zod";
+/** Convert a directory tree to a TypeScript type. This is useful for testing
+ * as the initial state of the test directory is fully known in tests. */
+export function getDirectoryTree(path) {
+    const allFiles = [];
+    const result = scan(path, {
+        exclude: [/.repro/, /testdirs/],
+        hash: false,
+        size: false,
+        sizeInBytes: false,
+    }, file => {
+        allFiles.push(file);
+    }, dir => {
+        allFiles.push(dir);
+    });
+    return { dree: result, allFiles };
+}
+export function convertDree(root) {
+    if (root.type === Type.FILE) {
+        return {
+            name: root.name,
+            type: root.type,
+            extension: root.extension,
+            stem: root.extension ? root.name.slice(0, -root.extension.length) : root.name,
+        };
+    }
+    assert(root.children);
+    const node = {
+        name: root.name,
+        type: root.type,
+        contents: {},
+    };
+    for (const child of root.children) {
+        node.contents[child.name] = convertDree(child);
+    }
+    return node;
+}
+export async function buildSchemaForDirectoryTree(result, name) {
+    const root = result.dree;
+    assert(root.type === Type.DIRECTORY);
+    const node = convertDree(root);
+    const schema = (await jsonToZod(node, `${name}Schema`)).split("\n");
+    const lines = `
+// Note: This file is autogenerated. Do not edit it directly.
+//
+// Describes the contents of the test directory, which is a blueprint for
+// files and directories. Tests can create a unique, safe environment for
+// interacting with the contents of such a directory.
+//
+// Having strong typing for the test directory contents ensures that tests can
+// be written with confidence that the files and directories they expect are
+// actually found. Otherwise the tests are brittle and can break easily.
+`.split("\n");
+    const allFilePaths = result.allFiles.map(f => f.relativePath);
+    const ContentsSchema = `${name}ContentsSchema`;
+    const ContentsSchemaType = `${name}ContentsSchemaType`;
+    return [
+        ...lines,
+        ...schema,
+        `export const ${ContentsSchema} = ${name}Schema.shape.contents`,
+        `export type ${ContentsSchemaType} = z.infer<typeof ${name}Schema>`,
+        "",
+        `export type ${name} = ${ContentsSchemaType}["contents"]`,
+        "",
+        `export const testDirectoryFiles = z.enum(${JSON.stringify(allFilePaths, null, 2)})`,
+        `export type MyTestDirectoryFile = z.infer<typeof testDirectoryFiles>`,
+    ].join("\n");
+}
+const __filename = fileURLToPath(import.meta.url);
+export async function buildTestDirectorySchema(testDirectoryPath) {
+    const dree = getDirectoryTree(testDirectoryPath);
+    let text = await buildSchemaForDirectoryTree(dree, "MyTestDirectory");
+    const options = await resolveConfig(__filename);
+    text = await format(text, { ...options, parser: "typescript" });
+    return text;
+}

package/dist/src/server/dirtree/index.test.d.ts

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

package/dist/src/server/dirtree/index.test.js

@@ -0,0 +1,172 @@
+import path from "path";
+import { describe, expect, it } from "vitest";
+import { buildSchemaForDirectoryTree, getDirectoryTree } from ".";
+import { Lazy } from "../utilities/Lazy";
+describe("dirtree", () => {
+    const output = new Lazy(() => getDirectoryTree(path.join(__dirname, "..", "..", "..", "..", "integration-tests", "test-environment")));
+    it("can get a list of all the files", () => {
+        const result = output.get().allFiles;
+        expect(result.length).toBeGreaterThan(1);
+        expect(result[0].relativePath).toBeTruthy();
+    });
+    it("should be able to build a typescript type for the tree", async () => {
+        const result = await buildSchemaForDirectoryTree(output.get(), "MyDirectoryTree");
+        expect(result).toMatchInlineSnapshot(`
+      "
+      // Note: This file is autogenerated. Do not edit it directly.
+      //
+      // Describes the contents of the test directory, which is a blueprint for
+      // files and directories. Tests can create a unique, safe environment for
+      // interacting with the contents of such a directory.
+      //
+      // Having strong typing for the test directory contents ensures that tests can
+      // be written with confidence that the files and directories they expect are
+      // actually found. Otherwise the tests are brittle and can break easily.
+
+      import { z } from "zod"
+
+      export const MyDirectoryTreeSchema = z.object({
+        name: z.literal("test-environment"),
+        type: z.literal("directory"),
+        contents: z.object({
+          "config-modifications": z.object({
+            name: z.literal("config-modifications"),
+            type: z.literal("directory"),
+            contents: z.object({
+              "add_command_to_count_open_buffers.lua": z.object({
+                name: z.literal("add_command_to_count_open_buffers.lua"),
+                type: z.literal("file"),
+                extension: z.literal("lua"),
+                stem: z.literal("add_command_to_count_open_buffers."),
+              }),
+              "use_light_neovim_colorscheme.lua": z.object({
+                name: z.literal("use_light_neovim_colorscheme.lua"),
+                type: z.literal("file"),
+                extension: z.literal("lua"),
+                stem: z.literal("use_light_neovim_colorscheme."),
+              }),
+            }),
+          }),
+          "dir with spaces": z.object({
+            name: z.literal("dir with spaces"),
+            type: z.literal("directory"),
+            contents: z.object({
+              "file1.txt": z.object({
+                name: z.literal("file1.txt"),
+                type: z.literal("file"),
+                extension: z.literal("txt"),
+                stem: z.literal("file1."),
+              }),
+              "file2.txt": z.object({
+                name: z.literal("file2.txt"),
+                type: z.literal("file"),
+                extension: z.literal("txt"),
+                stem: z.literal("file2."),
+              }),
+            }),
+          }),
+          "file.txt": z.object({
+            name: z.literal("file.txt"),
+            type: z.literal("file"),
+            extension: z.literal("txt"),
+            stem: z.literal("file."),
+          }),
+          "initial-file.txt": z.object({
+            name: z.literal("initial-file.txt"),
+            type: z.literal("file"),
+            extension: z.literal("txt"),
+            stem: z.literal("initial-file."),
+          }),
+          "other-subdirectory": z.object({
+            name: z.literal("other-subdirectory"),
+            type: z.literal("directory"),
+            contents: z.object({
+              "other-sub-file.txt": z.object({
+                name: z.literal("other-sub-file.txt"),
+                type: z.literal("file"),
+                extension: z.literal("txt"),
+                stem: z.literal("other-sub-file."),
+              }),
+            }),
+          }),
+          routes: z.object({
+            name: z.literal("routes"),
+            type: z.literal("directory"),
+            contents: z.object({
+              "posts.$postId": z.object({
+                name: z.literal("posts.$postId"),
+                type: z.literal("directory"),
+                contents: z.object({
+                  "adjacent-file.txt": z.object({
+                    name: z.literal("adjacent-file.txt"),
+                    type: z.literal("file"),
+                    extension: z.literal("txt"),
+                    stem: z.literal("adjacent-file."),
+                  }),
+                  "route.tsx": z.object({
+                    name: z.literal("route.tsx"),
+                    type: z.literal("file"),
+                    extension: z.literal("tsx"),
+                    stem: z.literal("route."),
+                  }),
+                  "should-be-excluded-file.txt": z.object({
+                    name: z.literal("should-be-excluded-file.txt"),
+                    type: z.literal("file"),
+                    extension: z.literal("txt"),
+                    stem: z.literal("should-be-excluded-file."),
+                  }),
+                }),
+              }),
+            }),
+          }),
+          subdirectory: z.object({
+            name: z.literal("subdirectory"),
+            type: z.literal("directory"),
+            contents: z.object({
+              "subdirectory-file.txt": z.object({
+                name: z.literal("subdirectory-file.txt"),
+                type: z.literal("file"),
+                extension: z.literal("txt"),
+                stem: z.literal("subdirectory-file."),
+              }),
+            }),
+          }),
+          "test-setup.lua": z.object({
+            name: z.literal("test-setup.lua"),
+            type: z.literal("file"),
+            extension: z.literal("lua"),
+            stem: z.literal("test-setup."),
+          }),
+        }),
+      })
+
+      export const MyDirectoryTreeContentsSchema = MyDirectoryTreeSchema.shape.contents
+      export type MyDirectoryTreeContentsSchemaType = z.infer<typeof MyDirectoryTreeSchema>
+
+      export type MyDirectoryTree = MyDirectoryTreeContentsSchemaType["contents"]
+
+      export const testDirectoryFiles = z.enum([
+        "config-modifications/add_command_to_count_open_buffers.lua",
+        "config-modifications/use_light_neovim_colorscheme.lua",
+        "config-modifications",
+        "dir with spaces/file1.txt",
+        "dir with spaces/file2.txt",
+        "dir with spaces",
+        "file.txt",
+        "initial-file.txt",
+        "other-subdirectory/other-sub-file.txt",
+        "other-subdirectory",
+        "routes/posts.$postId/adjacent-file.txt",
+        "routes/posts.$postId/route.tsx",
+        "routes/posts.$postId/should-be-excluded-file.txt",
+        "routes/posts.$postId",
+        "routes",
+        "subdirectory/subdirectory-file.txt",
+        "subdirectory",
+        "test-setup.lua",
+        "."
+      ])
+      export type MyTestDirectoryFile = z.infer<typeof testDirectoryFiles>"
+    `);
+    });
+});

package/dist/src/server/dirtree/json-to-zod.d.ts

@@ -0,0 +1 @@
+export declare function jsonToZod(object: unknown, name?: string): Promise<string>;

package/dist/src/server/dirtree/json-to-zod.js

@@ -0,0 +1,56 @@
+import { format, resolveConfig } from "prettier";
+import babelParser from "prettier/parser-babel";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+export async function jsonToZod(object, name = "schema") {
+    const parse = (o, seen) => {
+        switch (typeof o) {
+            case "string":
+                return `z.literal("${o}")`;
+            case "number":
+                return "z.number()";
+            case "bigint":
+                return "z.number().int()";
+            case "boolean":
+                return "z.boolean()";
+            case "object":
+                if (o === null) {
+                    return "z.null()";
+                }
+                if (seen.find(_obj => Object.is(_obj, o))) {
+                    throw new Error("Circular objects are not supported");
+                }
+                seen.push(o);
+                if (Array.isArray(o)) {
+                    const options = o
+                        .map(obj => parse(obj, seen))
+                        .reduce((acc, curr) => (acc.includes(curr) ? acc : [...acc, curr]), []);
+                    if (options.length === 1) {
+                        return `z.array(${options[0]})`;
+                    }
+                    else if (options.length > 1) {
+                        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                        return `z.array(z.union([${options}]))`;
+                    }
+                    else {
+                        return `z.array(z.unknown())`;
+                    }
+                }
+                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                return `z.object({${Object.entries(o).map(([k, v]) => `'${k}':${parse(v, seen)}`)}})`;
+            case "undefined":
+                return "z.undefined()";
+            case "function":
+                return "z.function()";
+            case "symbol":
+            default:
+                return "z.unknown()";
+        }
+    };
+    const prettierConfig = await resolveConfig(__filename);
+    return format(`import {z} from "zod"\n\nexport const ${name}=${parse(object, [])}`, {
+        ...(prettierConfig || {}),
+        parser: "babel",
+        plugins: [babelParser],
+    });
+}

package/dist/src/server/index.d.ts

@@ -0,0 +1,8 @@
+import type { AnyRouter } from "@trpc/server";
+import "core-js/proposals/async-explicit-resource-management";
+import type { TestServerConfig } from "./updateTestdirectorySchemaFile";
+export declare class TestServer {
+    private readonly port;
+    constructor(port: number);
+    startAndRun<TRouter extends AnyRouter>(appRouter: TRouter, config: TestServerConfig): Promise<void>;
+}

package/dist/src/server/index.js

@@ -0,0 +1,49 @@
+import { applyWSSHandler } from "@trpc/server/adapters/ws";
+import "core-js/proposals/async-explicit-resource-management";
+import { once } from "events";
+import { WebSocketServer } from "ws";
+import { createContext } from "./connection/trpc";
+import { updateTestdirectorySchemaFile } from "./updateTestdirectorySchemaFile";
+export class TestServer {
+    port;
+    constructor(port) {
+        this.port = port;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+    async startAndRun(appRouter, config) {
+        console.log("🚀 Server starting");
+        await updateTestdirectorySchemaFile(config);
+        const wss = new WebSocketServer({ port: this.port });
+        const handler = applyWSSHandler({
+            wss,
+            router: appRouter,
+            createContext,
+            // Enable heartbeat messages to keep connection open (disabled by default)
+            keepAlive: {
+                enabled: true,
+                // server ping message interval in milliseconds
+                pingMs: 30_000,
+                // connection is terminated if pong message is not received in this many milliseconds
+                pongWaitMs: 5000,
+            },
+        });
+        wss.on("connection", socket => {
+            console.log(`➕➕ Connection (${wss.clients.size})`);
+            socket.once("close", () => {
+                console.log(`➖➖ Connection (${wss.clients.size})`);
+            });
+        });
+        console.log(`✅ WebSocket Server listening on ws://localhost:${this.port}`);
+        await Promise.race([once(process, "SIGTERM"), once(process, "SIGINT")]);
+        console.log("Shutting down...");
+        handler.broadcastReconnectNotification();
+        wss.close(error => {
+            if (error) {
+                console.error("Error closing WebSocket server", error);
+                process.exit(1);
+            }
+            console.log("WebSocket server closed");
+            process.exit(0);
+        });
+    }
+}

package/dist/src/server/neovim/NeovimApplication.d.ts

@@ -0,0 +1,25 @@
+import EventEmitter from "events";
+import type { TestDirectory } from "../types";
+import { DisposableSingleApplication } from "../utilities/DisposableSingleApplication";
+export type StdoutMessage = "stdout";
+export type StartNeovimGenericArguments = {
+    terminalDimensions?: {
+        cols: number;
+        rows: number;
+    };
+    filename?: string | {
+        openInVerticalSplits: string[];
+    };
+    startupScriptModifications?: string[];
+};
+export declare class NeovimApplication extends DisposableSingleApplication {
+    private readonly testEnvironmentPath;
+    private testDirectory;
+    readonly events: EventEmitter;
+    constructor(testEnvironmentPath: string);
+    /**
+     * Kill the current application and start a new one with the given arguments.
+     */
+    startNextAndKillCurrent(testDirectory: TestDirectory, startArgs: StartNeovimGenericArguments): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}