@tui-sandbox/library 11.11.2 → 12.0.0

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

@@ -1,352 +0,0 @@
-import assert from "assert"
-import path from "path"
-import { describe, expect, it } from "vitest"
-import { createDefaultConfig } from "../config.js"
-import type { NeovimIntegrationDefaultAppName, TestServerConfig } from "../updateTestdirectorySchemaFile.js"
-import { Lazy } from "../utilities/Lazy.js"
-import { buildSchemaForDirectoryTree, getDirectoryTree } from "./index.js"
-
-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
-
-    assert(result)
-    expect(result.length).toBeGreaterThan(1)
-    assert(result[0])
-    expect(result[0].relativePath).toBeTruthy()
-  })
-
-  it("should be able to build a typescript type for the tree", async () => {
-    const config: TestServerConfig = {
-      ...createDefaultConfig("/my/root/path", {}),
-      integrations: {
-        neovim: {
-          NVIM_APPNAMEs: ["nvim" satisfies NeovimIntegrationDefaultAppName, "nvim_alt"],
-        },
-      },
-    }
-    const result = await buildSchemaForDirectoryTree(output.get(), "MyDirectoryTree", config)
-
-    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 * as z from "zod"
-
-      export const MyDirectoryTreeSchema = z.object({
-        name: z.literal("test-environment/"),
-        type: z.literal("directory"),
-        contents: z.object({
-          ".bashrc": z.object({ name: z.literal(".bashrc"), type: z.literal("file") }),
-          ".config": z.object({
-            name: z.literal(".config/"),
-            type: z.literal("directory"),
-            contents: z.object({
-              ".gitkeep": z.object({ name: z.literal(".gitkeep"), type: z.literal("file") }),
-              nvim: z.object({
-                name: z.literal("nvim/"),
-                type: z.literal("directory"),
-                contents: z.object({
-                  "init.lua": z.object({ name: z.literal("init.lua"), type: z.literal("file") }),
-                  "prepare.lua": z.object({ name: z.literal("prepare.lua"), type: z.literal("file") }),
-                }),
-              }),
-              nvim_alt: z.object({
-                name: z.literal("nvim_alt/"),
-                type: z.literal("directory"),
-                contents: z.object({
-                  "init.lua": z.object({ name: z.literal("init.lua"), type: z.literal("file") }),
-                  "prepare.lua": z.object({ name: z.literal("prepare.lua"), type: z.literal("file") }),
-                }),
-              }),
-            }),
-          }),
-          "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"),
-              }),
-              "add_command_to_update_buffer_after_timeout.lua": z.object({
-                name: z.literal("add_command_to_update_buffer_after_timeout.lua"),
-                type: z.literal("file"),
-              }),
-              "don't_crash_when_modification_contains_unescaped_characters\\".lua": z.object({
-                name: z.literal("don't_crash_when_modification_contains_unescaped_characters\\".lua"),
-                type: z.literal("file"),
-              }),
-              subdir: z.object({
-                name: z.literal("subdir/"),
-                type: z.literal("directory"),
-                contents: z.object({
-                  "subdir-modification.lua": z.object({
-                    name: z.literal("subdir-modification.lua"),
-                    type: z.literal("file"),
-                  }),
-                }),
-              }),
-            }),
-          }),
-          "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") }),
-              "file2.txt": z.object({ name: z.literal("file2.txt"), type: z.literal("file") }),
-            }),
-          }),
-          "file.txt": z.object({ name: z.literal("file.txt"), type: z.literal("file") }),
-          "initial-file.txt": z.object({ name: z.literal("initial-file.txt"), type: z.literal("file") }),
-          "lua-project": z.object({
-            name: z.literal("lua-project/"),
-            type: z.literal("directory"),
-            contents: z.object({
-              ".luarc.json": z.object({ name: z.literal(".luarc.json"), type: z.literal("file") }),
-              "config.lua": z.object({ name: z.literal("config.lua"), type: z.literal("file") }),
-              "init.lua": z.object({ name: z.literal("init.lua"), type: z.literal("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") }),
-            }),
-          }),
-          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") }),
-                  "route.tsx": z.object({ name: z.literal("route.tsx"), type: z.literal("file") }),
-                  "should-be-excluded-file.txt": z.object({
-                    name: z.literal("should-be-excluded-file.txt"),
-                    type: z.literal("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") }),
-            }),
-          }),
-          "symlink-target.txt": z.object({
-            name: z.literal("symlink-target.txt"),
-            type: z.literal("file-symlink"),
-            target: z.literal("symlink-test/symlink-target.txt"),
-          }),
-          "symlink-test": z.object({
-            name: z.literal("symlink-test/"),
-            type: z.literal("directory"),
-            contents: z.object({
-              "symlink-target.txt": z.object({ name: z.literal("symlink-target.txt"), type: z.literal("file") }),
-            }),
-          }),
-        }),
-      })
-
-      export const MyDirectoryTreeContentsSchema = MyDirectoryTreeSchema.shape.contents
-      export type MyDirectoryTreeContentsSchemaType = z.infer<typeof MyDirectoryTreeSchema>
-
-      export type MyDirectoryTree = MyDirectoryTreeContentsSchemaType["contents"]
-
-      export const testDirectoryFiles = z.enum([
-        ".bashrc",
-        ".config/.gitkeep",
-        ".config/nvim/init.lua",
-        ".config/nvim/prepare.lua",
-        ".config/nvim",
-        ".config/nvim_alt/init.lua",
-        ".config/nvim_alt/prepare.lua",
-        ".config/nvim_alt",
-        ".config",
-        "config-modifications/add_command_to_count_open_buffers.lua",
-        "config-modifications/add_command_to_update_buffer_after_timeout.lua",
-        "config-modifications/don't_crash_when_modification_contains_unescaped_characters\\".lua",
-        "config-modifications/subdir/subdir-modification.lua",
-        "config-modifications/subdir",
-        "config-modifications",
-        "dir with spaces/file1.txt",
-        "dir with spaces/file2.txt",
-        "dir with spaces",
-        "file.txt",
-        "initial-file.txt",
-        "lua-project/.luarc.json",
-        "lua-project/config.lua",
-        "lua-project/init.lua",
-        "lua-project",
-        "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",
-        "symlink-target.txt",
-        "symlink-test/symlink-target.txt",
-        "symlink-test",
-        "."
-      ])
-      export type MyTestDirectoryFile = z.infer<typeof testDirectoryFiles>
-      export type MyNeovimAppName = "nvim" | "nvim_alt""
-    `)
-  })
-
-  it("creates an empty schema when the directory cannot be read", async () => {
-    const config: TestServerConfig = createDefaultConfig("/my/root/path", {})
-    const tree = getDirectoryTree("nonexistent")
-    const result = await buildSchemaForDirectoryTree(tree, "MyDirectoryTree", config)
-    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 * as z from "zod"
-
-      export const MyDirectoryTreeSchema = z.object({
-        type: z.literal("directory"),
-        name: z.literal("root"),
-        contents: z.object({}),
-      })
-
-      export const MyDirectoryTreeContentsSchema = MyDirectoryTreeSchema.shape.contents
-      export type MyDirectoryTreeContentsSchemaType = z.infer<typeof MyDirectoryTreeSchema>
-
-      export type MyDirectoryTree = MyDirectoryTreeContentsSchemaType["contents"]
-
-      export const testDirectoryFiles = z.enum([])
-      export type MyTestDirectoryFile = z.infer<typeof testDirectoryFiles>
-      export type MyNeovimAppName = "nvim""
-    `)
-  })
-
-  describe("provides type-safe access to NVIM_APPNAMEs", () => {
-    // the user can configure the NVIM_APPNAMEs they are using in their
-    // configuration. These should be available for them in a type-safe manner so
-    // that they have the least possible friction when coding.
-    //
-    const smallDirectory = path.resolve(__dirname, "../../../../integration-tests/test-environment/other-subdirectory/")
-
-    it("when there is a single name", async () => {
-      const config: TestServerConfig = createDefaultConfig("/my/root/path", {})
-      assert(config.integrations.neovim.NVIM_APPNAMEs.length === 1)
-      const tinytree = getDirectoryTree(smallDirectory)
-      const result = await buildSchemaForDirectoryTree(tinytree, "MyDirectoryTree", config)
-
-      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 * as z from "zod"
-
-        export const MyDirectoryTreeSchema = 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") }),
-          }),
-        })
-
-        export const MyDirectoryTreeContentsSchema = MyDirectoryTreeSchema.shape.contents
-        export type MyDirectoryTreeContentsSchemaType = z.infer<typeof MyDirectoryTreeSchema>
-
-        export type MyDirectoryTree = MyDirectoryTreeContentsSchemaType["contents"]
-
-        export const testDirectoryFiles = z.enum([
-          "other-sub-file.txt",
-          "."
-        ])
-        export type MyTestDirectoryFile = z.infer<typeof testDirectoryFiles>
-        export type MyNeovimAppName = "nvim""
-      `)
-      //                               👆🏻 from the default config
-    })
-
-    it("when there are multiple names", async () => {
-      const config: TestServerConfig = {
-        ...createDefaultConfig("/my/root/path", {}),
-        integrations: {
-          neovim: {
-            NVIM_APPNAMEs: ["nvim" satisfies NeovimIntegrationDefaultAppName, "nvim_alt"],
-          },
-        },
-      }
-      const tinytree = getDirectoryTree(smallDirectory)
-      const result = await buildSchemaForDirectoryTree(tinytree, "MyDirectoryTree", config)
-
-      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 * as z from "zod"
-
-        export const MyDirectoryTreeSchema = 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") }),
-          }),
-        })
-
-        export const MyDirectoryTreeContentsSchema = MyDirectoryTreeSchema.shape.contents
-        export type MyDirectoryTreeContentsSchemaType = z.infer<typeof MyDirectoryTreeSchema>
-
-        export type MyDirectoryTree = MyDirectoryTreeContentsSchemaType["contents"]
-
-        export const testDirectoryFiles = z.enum([
-          "other-sub-file.txt",
-          "."
-        ])
-        export type MyTestDirectoryFile = z.infer<typeof testDirectoryFiles>
-        export type MyNeovimAppName = "nvim" | "nvim_alt""
-      `)
-    })
-  })
-})

package/src/server/dirtree/index.ts

@@ -1,144 +0,0 @@
-import assert from "assert"
-import type { Dree } from "dree"
-import { scan, Type } from "dree"
-import { readlinkSync } from "fs"
-import { format, resolveConfig } from "prettier"
-import { fileURLToPath } from "url"
-import { debuglog } from "util"
-import type { TestServerConfig } from "../updateTestdirectorySchemaFile.js"
-import { jsonToZod } from "./json-to-zod.js"
-
-const log = debuglog("tui-sandbox.dirtree")
-type TreeResult = { dree: Dree | undefined; 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 function getDirectoryTree(path: string): TreeResult {
-  const allFiles: Dree[] = []
-  const result = scan(
-    path,
-    {
-      exclude: [/.repro/, /testdirs/],
-      hash: false,
-      size: false,
-      sizeInBytes: false,
-    },
-    file => {
-      allFiles.push(file)
-    },
-    dir => {
-      allFiles.push(dir)
-    }
-  ) as Dree | null // https://github.com/euberdeveloper/dree/pull/51
-
-  return { dree: result ?? undefined, allFiles }
-}
-
-type TreeNode = FileNode | FileSymlinkNode | DirectoryNode
-
-type FileNode = {
-  type: "file"
-  name: string
-}
-type FileSymlinkNode = {
-  type: "file-symlink"
-  name: string
-  /** The target of the symlink, a filepath. */
-  target: string
-}
-type DirectoryNode = {
-  type: "directory"
-  name: string
-  contents: Record<string, TreeNode>
-}
-
-export function convertDree(root: Dree | undefined): TreeNode {
-  if (!root) {
-    return { type: Type.DIRECTORY, name: "root", contents: {} }
-  }
-
-  if (root.type === Type.FILE) {
-    if (root.isSymbolicLink) {
-      const target = readlinkSync(root.path)
-      return {
-        name: root.name,
-        type: "file-symlink",
-        target,
-      } satisfies FileSymlinkNode
-    }
-
-    return {
-      name: root.name,
-      type: root.type,
-    } satisfies FileNode
-  }
-
-  const node: DirectoryNode = {
-    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: TreeResult,
-  name: string,
-  config: TestServerConfig
-): Promise<string> {
-  const root = convertDree(result.dree)
-
-  const schema = (await jsonToZod(root, `${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`
-
-  assert(config.integrations.neovim.NVIM_APPNAMEs.length > 0, "At least one NVIM_APPNAME must be configured")
-  const NVIM_APPNAMEsUnion =
-    config.integrations.neovim.NVIM_APPNAMEs.length > 1
-      ? config.integrations.neovim.NVIM_APPNAMEs.map(a => `"${a}"`).join(" | ")
-      : `"${config.integrations.neovim.NVIM_APPNAMEs[0]}"`
-
-  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>`,
-    `export type MyNeovimAppName = ${NVIM_APPNAMEsUnion}`,
-  ].join("\n")
-}
-
-const __filename = fileURLToPath(import.meta.url)
-
-export async function buildTestDirectorySchema(config: TestServerConfig): Promise<string> {
-  log("Building schema for test directory", config.directories.testEnvironmentPath)
-  const dree = getDirectoryTree(config.directories.testEnvironmentPath)
-  let text = await buildSchemaForDirectoryTree(dree, "MyTestDirectory", config)
-
-  const options = await resolveConfig(__filename)
-  text = await format(text, { ...options, parser: "typescript" })
-
-  return text
-}

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

@@ -1,60 +0,0 @@
-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: unknown, name: string = "schema"): Promise<string> {
-  const parse = (o: unknown, seen: object[]): string => {
-    switch (typeof o) {
-      case "string":
-        return `z.literal("${o.replaceAll('"', `\\"`)}")`
-      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: string[], curr: string) => (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]) => {
-          const key = k.replaceAll("'", "\\'")
-          return `'${key}':${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 * as z from "zod"\n\nexport const ${name}=${parse(object, [])}`, {
-    ...prettierConfig,
-    parser: "babel",
-    plugins: [babelParser],
-  })
-}

package/src/server/index.ts

@@ -1,6 +0,0 @@
-// This is the public server api. Semantic versioning will be applied to this.
-
-export { startTestServer } from "./server.js"
-export { updateTestdirectorySchemaFile } from "./updateTestdirectorySchemaFile.js"
-export type { TestServerConfig } from "./updateTestdirectorySchemaFile.js"
-export { Lazy } from "./utilities/Lazy.js"

package/src/server/server.ts

@@ -1,34 +0,0 @@
-import type { inferRouterInputs } from "@trpc/server"
-import { createNeovimRouter } from "./applications/neovim/neovimRouter.js"
-import { createTerminalRouter } from "./applications/terminal/terminalRouter.js"
-import { trpc } from "./connection/trpc.js"
-import { TestServer } from "./TestServer.js"
-import type { TestServerConfig } from "./updateTestdirectorySchemaFile.js"
-
-/** @private */
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export async function createAppRouter(config: TestServerConfig) {
-  const appRouter = trpc.router({
-    terminal: createTerminalRouter(config),
-    neovim: createNeovimRouter(config),
-  })
-
-  return appRouter
-}
-
-export type AppRouter = Awaited<ReturnType<typeof createAppRouter>>
-export type RouterInput = inferRouterInputs<AppRouter>
-
-export async function startTestServer(config: TestServerConfig): Promise<void> {
-  try {
-    const testServer = new TestServer({
-      port: config.port,
-    })
-    const appRouter = await createAppRouter(config)
-
-    await testServer.startAndRun(appRouter)
-  } catch (err: unknown) {
-    console.error("Error starting test server", err)
-    throw err
-  }
-}