banhaten 0.1.2 → 0.2.0

package/src/cli/registry-query.js

@@ -0,0 +1,207 @@
+import fs from "node:fs/promises"
+import path from "node:path"
+
+export function listComponents(registry, runtimeOptions) {
+  const components = Object.entries(registry.components).map(([name, component]) => ({
+    name,
+    stability: component.status === "expanded" ? "pattern" : "stable",
+    description: component.description || "",
+    dependencies: Object.keys(component.dependencies || {}),
+    registryDependencies: component.registryDependencies || [],
+  }))
+
+  if (runtimeOptions.json) {
+    writeJson({ components })
+    return
+  }
+
+  if (runtimeOptions.silent) return
+
+  console.log("Available Banhaten design system components:")
+  for (const { name, description, stability } of components) {
+    console.log(`- ${name} [${stability}]: ${description}`)
+  }
+}
+
+export function searchComponents(registry, positionals, runtimeOptions) {
+  const query = positionals.join(" ").trim().toLowerCase()
+  if (!query) {
+    throw new Error("missing search query. Try `banhaten search input`.")
+  }
+
+  const matches = Object.entries(registry.components)
+    .filter(([name, component]) => {
+      const haystack = [
+        name,
+        component.description,
+        ...(component.parts || []),
+        ...getSupportedExportNames(component),
+        ...(component.registryDependencies || []),
+        ...Object.entries(component.props || {}).flatMap(([name, prop]) => [
+          name,
+          prop.type,
+          prop.description,
+        ]),
+      ]
+        .filter(Boolean)
+        .join(" ")
+        .toLowerCase()
+
+      return haystack.includes(query)
+    })
+    .map(([name, component]) => ({
+      name,
+      stability: component.status === "expanded" ? "pattern" : "stable",
+      description: component.description || "",
+      parts: component.parts || [],
+      supportedExports: component.supportedExports || [],
+    }))
+
+  if (runtimeOptions.json) {
+    writeJson({ query, matches })
+    return
+  }
+
+  if (runtimeOptions.silent) return
+
+  if (matches.length === 0) {
+    console.log(`No Banhaten components matched "${query}".`)
+    return
+  }
+
+  console.log(`Banhaten components matching "${query}":`)
+  for (const match of matches) {
+    console.log(`- ${match.name} [${match.stability}]: ${match.description}`)
+  }
+}
+
+export async function showComponentDocs(registry, packageRoot, positionals, runtimeOptions) {
+  const [name] = positionals
+  const component = getComponentOrThrow(registry, name)
+  const docsPath = getComponentDocPath(name)
+  const content = await fs.readFile(path.join(packageRoot, docsPath), "utf8")
+  const result = {
+    name,
+    stability: component.status === "expanded" ? "pattern" : "stable",
+    description: component.description || "",
+    install: `npx banhaten add ${name}`,
+    docsPath,
+    files: component.files || [],
+    examples: component.examples || [],
+    parts: component.parts || [],
+    props: component.props || {},
+    defaults: component.defaults || {},
+    densities: component.densities || [],
+    kinds: component.kinds || [],
+    variants: component.variants || [],
+    sizes: component.sizes || [],
+    states: component.states || [],
+    layouts: component.layouts || [],
+    recommendedFor: component.recommendedFor || [],
+    avoidWhen: component.avoidWhen || [],
+    recipes: component.recipes || [],
+    supportedExports: component.supportedExports || [],
+    tokens: component.tokens || [],
+    rtl: component.rtl || null,
+    content,
+  }
+
+  if (runtimeOptions.json) {
+    writeJson(result)
+    return
+  }
+
+  if (runtimeOptions.silent) return
+
+  console.log(`${name} [${result.stability}]: ${result.description}`)
+  console.log(`Install: ${result.install}`)
+  console.log(`Docs: ${docsPath}`)
+
+  if (result.files.length > 0) {
+    console.log("Files:")
+    for (const file of result.files) {
+      console.log(`- ${file.source} -> ${file.target}`)
+    }
+  }
+
+  if (result.examples.length > 0) {
+    console.log("Examples:")
+    for (const example of result.examples) {
+      console.log(`- ${example}`)
+    }
+  }
+
+  console.log(`\n${content.trim()}`)
+}
+
+export async function viewComponent(registry, registryRoot, positionals, flags, runtimeOptions) {
+  const [name] = positionals
+  const component = getComponentOrThrow(registry, name)
+  const files = component.files || []
+  const requestedFile = typeof flags.file === "string" ? flags.file : null
+  const file =
+    (requestedFile
+      ? files.find((entry) => entry.source === requestedFile)
+      : files.find((entry) => /\.(ts|tsx|css)$/.test(entry.source)) || files[0]) ||
+    null
+
+  if (!file) {
+    throw new Error(`component "${name}" has no viewable registry files.`)
+  }
+
+  const sourcePath = path.join(registryRoot, file.source)
+  const content = await fs.readFile(
+    sourcePath,
+    isTextRegistryFile(file.source) ? "utf8" : undefined
+  )
+
+  if (runtimeOptions.json) {
+    writeJson({
+      name,
+      file,
+      content: Buffer.isBuffer(content) ? content.toString("base64") : content,
+      encoding: Buffer.isBuffer(content) ? "base64" : "utf8",
+    })
+    return
+  }
+
+  if (runtimeOptions.silent) return
+
+  console.log(Buffer.isBuffer(content) ? content.toString("base64") : content)
+}
+
+function getComponentOrThrow(registry, name) {
+  if (!name) {
+    throw new Error("missing component name. Try `banhaten docs button`.")
+  }
+
+  const component = registry.components[name]
+  if (!component) {
+    throw new Error(`unknown component "${name}". Run \`banhaten list\`.`)
+  }
+
+  return component
+}
+
+export function getComponentDocPath(name) {
+  const docAliases = {
+    "onboarding-step": "onboarding-step-list-item",
+  }
+  const docId = docAliases[name] || name
+
+  return `docs/design-system/components/${docId}.md`
+}
+
+function getSupportedExportNames(component) {
+  return (component.supportedExports || []).flatMap(
+    (module) => module.values || []
+  )
+}
+
+function writeJson(value) {
+  console.log(JSON.stringify(value, null, 2))
+}
+
+function isTextRegistryFile(source) {
+  return !/\.(avif|eot|gif|ico|jpe?g|otf|png|ttf|webp|woff2?)$/i.test(source)
+}

package/src/cli/reporting.js

@@ -0,0 +1,55 @@
+import path from "node:path"
+import process from "node:process"
+
+import { inspectPackageManagerContext } from "./package-manager.js"
+
+export function printResult(
+  title,
+  writes,
+  dryRun,
+  runtimeOptions,
+  install = { command: null, cwd: null, required: false }
+) {
+  if (runtimeOptions.json) {
+    console.log(JSON.stringify({ dryRun, title, writes, install }, null, 2))
+    return
+  }
+
+  if (runtimeOptions.silent) return
+
+  console.log(`${dryRun ? "Dry run: " : ""}${title}`)
+  for (const write of writes) {
+    console.log(write.startsWith("--- ") ? write : `- ${write}`)
+  }
+}
+
+export function printInstallHint(install, dryRun, runtimeOptions) {
+  if (dryRun || runtimeOptions.json || runtimeOptions.silent) return
+
+  if (install.required) {
+    const location = path.resolve(process.cwd()) === install.cwd
+      ? ""
+      : ` in ${install.cwd}`
+    console.log(`\nNext: run ${install.command}${location} to install the dependency changes.`)
+  }
+}
+
+export async function resolveInstallAction(cwd, required) {
+  if (!required) {
+    return {
+      evidence: [],
+      install: { command: null, cwd: null, required: false },
+    }
+  }
+
+  const managerState = await inspectPackageManagerContext(cwd)
+  const { context } = managerState
+  return {
+    evidence: managerState.evidence,
+    install: {
+      command: `${context.manager} install`,
+      cwd: context.root,
+      required: true,
+    },
+  }
+}

package/src/cli/schema-validation.js

@@ -0,0 +1,19 @@
+import Ajv2020 from "ajv/dist/2020.js"
+
+const ajv = new Ajv2020({ allErrors: true, allowUnionTypes: true, strict: true })
+const validators = new WeakMap()
+
+export function assertSchema(data, schema, label) {
+  let validate = validators.get(schema)
+  if (!validate) {
+    validate = ajv.compile(schema)
+    validators.set(schema, validate)
+  }
+
+  if (validate(data)) return
+
+  const details = (validate.errors || [])
+    .map((error) => `${error.instancePath || "/"} ${error.message}`)
+    .join("; ")
+  throw new Error(`${label} failed schema validation: ${details}`)
+}