Skip to content

armgit / ui

Public Imported from GitHub
0
TypeScript
14.4 KB
Raw Blame
import assert from "node:assert/strict"
import { spawn } from "node:child_process"
import { createHash } from "node:crypto"
import {
  cp,
  mkdtemp,
  readdir,
  readFile,
  rm,
  symlink,
  writeFile,
} from "node:fs/promises"
import { createServer } from "node:http"
import os from "node:os"
import path from "node:path"
import ts from "typescript"

import {
  getRegistryFamily,
  styleRegistryDependencies,
} from "../lib/registry-style.ts"

type Family = "base" | "radix"
type RegistryFile = {
  path: string
  target?: string
  content?: string
  type: string
}
type RegistryItem = {
  name: string
  type: string
  categories?: string[]
  dependencies?: string[]
  registryDependencies?: string[]
  files?: RegistryFile[]
}
const styles = ["nova", "vega", "maia", "lyra", "mira", "luma", "sera", "rhea"]
const iconLibraries = {
  lucide: ["lucide-react"],
  hugeicons: ["@hugeicons/react", "@hugeicons/core-free-icons"],
  tabler: ["@tabler/icons-react"],
  phosphor: ["@phosphor-icons/react"],
  remixicon: ["@remixicon/react"],
}
const appRoot = process.cwd()
const registryRoot = path.join(appRoot, "public/r")
const shadcn = path.join(appRoot, "node_modules/.bin/shadcn")

async function run(
  command: string,
  args: string[],
  cwd: string,
  declineOverwrites = false
) {
  const env = { ...process.env }
  for (const key of [
    "INIT_CWD",
    "npm_config_user_agent",
    "npm_config_workspace_dir",
    "npm_execpath",
    "npm_node_execpath",
  ])
    delete env[key]
  await new Promise<void>((resolve, reject) => {
    const child = spawn(command, args, {
      cwd,
      env,
      stdio: declineOverwrites ? ["pipe", "pipe", "pipe"] : "inherit",
    })
    if (declineOverwrites) {
      const output = (chunk: Buffer, destination: NodeJS.WriteStream) => {
        destination.write(chunk)
        if (chunk.toString().includes("(y/N)")) child.stdin!.write("n\n")
        if (/Skipped \d+ files|Created \d+ files/.test(chunk.toString()))
          child.stdin!.end()
      }
      child.stdout!.on("data", (chunk) => output(chunk, process.stdout))
      child.stderr!.on("data", (chunk) => output(chunk, process.stderr))
    }
    child.on("error", reject)
    child.on("exit", (code) =>
      code === 0
        ? resolve()
        : reject(new Error(`${command} exited with code ${code}`))
    )
  })
}

await run("pnpm", ["registry:build"], appRoot)
const catalog = (
  JSON.parse(await readFile(path.join(appRoot, "registry.json"), "utf8")) as {
    items: RegistryItem[]
  }
).items
const publicItems = catalog
  .filter(
    (item) =>
      item.categories?.includes("documents") && item.name !== "pdf-editor-core"
  )
  .map((item) => item.name)
assert(publicItems.includes("pdf-editor"))
const selectedItems =
  process.env.EXTEND_FIXTURE_ITEMS?.split(",") ?? publicItems
assert(
  selectedItems.every((name) => publicItems.includes(name)),
  "Unknown fixture entry"
)
const readItem = async (family: Family, name: string): Promise<RegistryItem> =>
  JSON.parse(
    await readFile(
      path.join(registryRoot, "bases", family, `${name}.json`),
      "utf8"
    )
  )

async function iconProbe(
  family: Family,
  library: keyof typeof iconLibraries
): Promise<RegistryItem> {
  const files = new Map<string, RegistryFile>()
  const visited = new Set<string>()
  const include = async (name: string) => {
    if (visited.has(name)) return
    visited.add(name)
    const item = await readItem(family, name)
    for (const dependency of item.registryDependencies ?? []) {
      if (dependency.startsWith("@extend/"))
        await include(dependency.slice("@extend/".length))
    }
    for (const file of item.files ?? []) {
      if (
        file.target?.match(/^@components\/(extend|blocks)\//) &&
        file.content?.includes("IconPlaceholder")
      ) {
        files.set(file.target, {
          ...file,
          target: `@components/extend/icon-tests/${library}/${path.basename(file.target)}`,
        })
      }
    }
  }
  for (const name of selectedItems) await include(name)
  assert(files.size > 0)
  return {
    name: `icon-probe-${library}`,
    type: "registry:ui",
    files: [...files.values()],
    dependencies: iconLibraries[library],
  }
}

const server = createServer(async (request, response) => {
  try {
    const match = /^\/r\/styles\/([a-z0-9-]+)\/([a-z0-9-]+)\.json$/.exec(
      new URL(request.url ?? "/", "http://localhost").pathname
    )
    if (!match) {
      response.writeHead(404).end()
      return
    }
    const [, style, name] = match
    const family = getRegistryFamily(style)
    if (!family) {
      response.writeHead(404).end()
      return
    }
    const library = name.replace(
      "icon-probe-",
      ""
    ) as keyof typeof iconLibraries
    const item = name.startsWith("icon-probe-")
      ? await iconProbe(family, library)
      : await readItem(family, name)
    response
      .writeHead(200, { "Content-Type": "application/json" })
      .end(JSON.stringify(styleRegistryDependencies(item, style)))
  } catch (error) {
    response.writeHead(500).end(String(error))
  }
})
await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve))
const address = server.address()
assert(address && typeof address === "object")
const registryUrl = `http://127.0.0.1:${address.port}/r/styles/{style}/{name}.json`
const fixtureRoot = await mkdtemp(path.join(os.tmpdir(), "extend-registry-"))
console.log(`Fixtures: ${fixtureRoot}`)

async function configure(directory: string, changes: Record<string, unknown>) {
  const filename = path.join(directory, "components.json")
  const config = JSON.parse(await readFile(filename, "utf8"))
  await writeFile(
    filename,
    JSON.stringify(
      { ...config, ...changes, registries: { "@extend": registryUrl } },
      null,
      2
    )
  )
}
async function checksum(filename: string) {
  return createHash("sha256")
    .update(await readFile(filename))
    .digest("hex")
}
async function primitiveHashes(directory: string) {
  const names = await readdir(path.join(directory, "src/components/ui"))
  return Object.fromEntries(
    await Promise.all(
      names.map(async (name) => [
        name,
        await checksum(path.join(directory, "src/components/ui", name)),
      ])
    )
  )
}

async function checkFamily(family: Family) {
  const items = await Promise.all(
    catalog.map((item) => readItem(family, item.name))
  )
  const byName = new Map(items.map((item) => [item.name, item]))
  for (const entry of publicItems) {
    const closure = new Map<string, RegistryItem>()
    const include = (name: string) => {
      if (closure.has(name)) return
      const item = byName.get(name)
      assert(item, `Missing registry dependency ${name}`)
      closure.set(name, item)
      for (const dependency of item.registryDependencies ?? []) {
        if (dependency.startsWith("@extend/"))
          include(dependency.slice("@extend/".length))
      }
    }
    include(entry)
    for (const support of [
      "document-controls",
      "document-scroll-area",
      "document-color-popover",
      "registry-icon-props",
    ]) {
      assert(!closure.has(support), `${entry} installs an inline support file`)
    }
    const dependencies = new Set(
      [...closure.values()].flatMap((item) => item.registryDependencies ?? [])
    )
    const packages = new Set(
      [...closure.values()]
        .flatMap((item) => item.dependencies ?? [])
        .map((name) => name.match(/^(@[^/]+\/[^@]+|[^@]+)/)![0])
    )
    const files = [...closure.values()].flatMap((item) => item.files ?? [])
    if (entry === "xlsx-viewer") assert.equal(files.length, 1)
    const modules = new Set(
      files.map((file) =>
        file.target
          ?.replace(/^@components\//, "@/components/")
          .replace(/^@lib\//, "@/lib/")
          .replace(/^@hooks\//, "@/hooks/")
          .replace(/\.[jt]sx?$/, "")
      )
    )
    for (const file of files) {
      assert(
        !file.target?.startsWith("@ui/"),
        `${entry} writes a consumer primitive`
      )
      const source = ts.createSourceFile(
        file.path,
        file.content ?? "",
        ts.ScriptTarget.Latest,
        true,
        ts.ScriptKind.TSX
      )
      for (const statement of source.statements) {
        if (
          !ts.isImportDeclaration(statement) ||
          !ts.isStringLiteral(statement.moduleSpecifier)
        )
          continue
        const modulePath = statement.moduleSpecifier.text
        if (modulePath.startsWith("@/components/ui/"))
          assert(
            dependencies.has(modulePath.slice("@/components/ui/".length)),
            `${entry} lacks ${modulePath}`
          )
        else if (modulePath === "@/lib/utils")
          assert(dependencies.has("utils"), `${entry} lacks utils`)
        else if (
          modulePath.startsWith("@/") &&
          modulePath !== "@/components/icon-placeholder"
        )
          assert(modules.has(modulePath), `${entry} lacks ${modulePath}`)
        else if (!modulePath.startsWith(".") && !modulePath.startsWith("@/")) {
          const packageName = modulePath.startsWith("@")
            ? modulePath.split("/").slice(0, 2).join("/")
            : modulePath.split("/")[0]
          assert(
            ["react", "react-dom"].includes(packageName) ||
              packages.has(packageName),
            `${entry} lacks package ${packageName}`
          )
        }
      }
    }
  }
  for (const item of items) {
    for (const file of item.files ?? []) {
      if (!file.target?.match(/^@components\/(extend|blocks)\//)) continue
      assert(
        !file.content?.includes("ui-adapter"),
        `${item.name} must not use a UI adapter`
      )
      if (file.content?.match(/<Button[\s/>]/))
        assert.match(
          file.content,
          /import\s*{[^}]*\bButton\b[^}]*}\s*from\s*["']@\/components\/ui\/button["']/
        )
    }
    for (const style of styles) {
      const styled = styleRegistryDependencies(item, `${family}-${style}`)
      item.registryDependencies?.forEach((dependency, index) => {
        if (!dependency.startsWith("@") && !dependency.startsWith("http"))
          assert.equal(
            styled.registryDependencies?.[index],
            `https://ui.shadcn.com/r/styles/${family}-${style}/${dependency}.json`
          )
      })
    }
  }
  console.log(
    `PASS ${family}: individual dependency closures and direct primitive imports`
  )
  if (process.argv.includes("--artifacts-only")) return
  const primitives = [
    ...new Set(
      items
        .filter(
          (item) =>
            item.categories?.includes("documents") ||
            item.name.startsWith("document-")
        )
        .flatMap((item) => item.registryDependencies ?? [])
        .filter((name) => !name.startsWith("@") && !name.startsWith("http"))
    ),
  ]
  const name = `${family}-maia`
  const directory = path.join(fixtureRoot, name)
  await run(
    shadcn,
    [
      "create",
      "--template",
      "vite",
      "-b",
      family,
      "-p",
      "maia",
      "-n",
      name,
      "--no-monorepo",
      "-y",
    ],
    fixtureRoot
  )
  await configure(directory, {})
  await run(shadcn, ["add", ...primitives, "-y"], directory)
  const buttonPath = path.join(directory, "src/components/ui/button.tsx")
  await writeFile(
    buttonPath,
    `${await readFile(buttonPath, "utf8")}\nexport const consumerCustomization = true\n`
  )
  const before = await primitiveHashes(directory)
  const utilsBefore = await checksum(path.join(directory, "src/lib/utils.ts"))
  await run(
    shadcn,
    ["add", ...selectedItems.map((name) => `@extend/${name}`), "-y"],
    directory,
    true
  )
  assert.deepEqual(
    await primitiveHashes(directory),
    before,
    "Consumer primitives were changed"
  )
  assert.equal(
    await checksum(path.join(directory, "src/lib/utils.ts")),
    utilsBefore,
    "Consumer utils were changed"
  )
  for (const library of Object.keys(iconLibraries)) {
    await configure(directory, { iconLibrary: library })
    await run(shadcn, ["add", `@extend/icon-probe-${library}`, "-y"], directory)
    const iconDirectory = path.join(
      directory,
      "src/components/extend/icon-tests",
      library
    )
    for (const filename of await readdir(iconDirectory))
      assert(
        !(await readFile(path.join(iconDirectory, filename), "utf8")).includes(
          "IconPlaceholder"
        ),
        `Unresolved icon in ${filename}`
      )
  }
  await writeFile(
    path.join(directory, "src/App.tsx"),
    'import { PDFEditor } from "./components/extend/pdf-editor"\nexport default function App() { return <PDFEditor src="/fixture.pdf" className="h-svh" defaultMode="annotate" persistSignatures={false} /> }\n'
  )
  await cp(
    path.join(appRoot, "public/samples/attention.pdf"),
    path.join(directory, "public/fixture.pdf")
  )
  await run("npm", ["run", "build"], directory)
  console.log(
    `PASS ${name}: ${selectedItems.length} public entries, all icon libraries, unchanged consumer primitives, production build`
  )
  if (process.env.EXTEND_SKIP_STYLE_MATRIX === "1") return
  const otherStyles = styles
    .filter((style) => style !== "maia")
    .map((style) => `${family}-${style}`)
  if (family === "radix") otherStyles.push("new-york", "new-york-v4")
  for (const style of otherStyles) {
    const styledDirectory = path.join(fixtureRoot, style)
    await cp(directory, styledDirectory, {
      recursive: true,
      filter: (source) =>
        !["node_modules", "dist", ".git"].includes(path.basename(source)),
    })
    await symlink(
      path.join(directory, "node_modules"),
      path.join(styledDirectory, "node_modules"),
      "dir"
    )
    await rm(path.join(styledDirectory, "src/components/ui"), {
      recursive: true,
    })
    await configure(styledDirectory, { style })
    await run(shadcn, ["add", ...primitives, "-y"], styledDirectory)
    await run("npx", ["tsc", "-b", "--force"], styledDirectory)
    console.log(`PASS ${style}: all public components and icon libraries`)
  }
}

try {
  const families = (["base", "radix"] as const).filter(
    (family) =>
      !process.env.EXTEND_FIXTURE_FAMILY ||
      process.env.EXTEND_FIXTURE_FAMILY === family
  )
  const results = await Promise.allSettled(families.map(checkFamily))
  const failures = results.filter(
    (result): result is PromiseRejectedResult => result.status === "rejected"
  )
  if (failures.length)
    throw new AggregateError(
      failures.map((result) => result.reason),
      "Registry fixture failures"
    )
} finally {
  server.closeAllConnections()
  await new Promise<void>((resolve) => server.close(() => resolve()))
  if (process.env.EXTEND_KEEP_FIXTURES !== "1")
    await rm(fixtureRoot, { recursive: true })
}