@tanstack/cli 0.60.1 → 0.62.0

package/src/command-line.ts

@@ -1,473 +0,0 @@
-import { resolve } from 'node:path'
-import fs from 'node:fs'
-
-import {
-  DEFAULT_PACKAGE_MANAGER,
-  finalizeAddOns,
-  getFrameworkById,
-  getPackageManager,
-  getRawRegistry,
-  loadStarter,
-  populateAddOnOptionsDefaults,
-} from '@tanstack/create'
-
-import {
-  getCurrentDirectoryName,
-  sanitizePackageName,
-  validateProjectName,
-} from './utils.js'
-import type { Options } from '@tanstack/create'
-
-import type { CliOptions } from './types.js'
-
-const SUPPORTED_LEGACY_TEMPLATES = new Set([
-  'file-router',
-  'typescript',
-  'tsx',
-])
-
-const LEGACY_TEMPLATE_ALIASES = new Set(['javascript', 'js', 'jsx'])
-
-function getLegacyTemplateValue(templateValue?: string) {
-  if (!templateValue) {
-    return undefined
-  }
-
-  const normalized = templateValue.toLowerCase().trim()
-  if (
-    SUPPORTED_LEGACY_TEMPLATES.has(normalized) ||
-    LEGACY_TEMPLATE_ALIASES.has(normalized)
-  ) {
-    return normalized
-  }
-
-  return undefined
-}
-
-function slugifyStarterName(value: string) {
-  return value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-}
-
-function isLikelyStarterUrlOrPath(value: string) {
-  return (
-    /^https?:\/\//i.test(value) ||
-    /^file:\/\//i.test(value) ||
-    value.startsWith('./') ||
-    value.startsWith('../') ||
-    value.startsWith('/') ||
-    /^[a-zA-Z]:[\\/]/.test(value)
-  )
-}
-
-function getStarterIdsFromUrl(starterUrl: string) {
-  const ids = new Set<string>()
-
-  try {
-    const pathname = new URL(starterUrl).pathname
-    const parts = pathname.split('/').filter(Boolean)
-    const lastPart = parts.at(-1)?.toLowerCase()
-
-    if (lastPart) {
-      ids.add(lastPart.replace(/\.json$/i, ''))
-    }
-
-    if (
-      (lastPart === 'starter.json' || lastPart === 'template.json') &&
-      parts.length >= 2
-    ) {
-      ids.add(parts.at(-2)!.toLowerCase())
-    }
-  } catch {
-    // Ignore URL parse errors and rely on other id heuristics.
-  }
-
-  return ids
-}
-
-function resolveMonorepoStarterById(starterId: string) {
-  const normalized = starterId.toLowerCase().trim()
-  const idVariants = Array.from(
-    new Set([
-      normalized,
-      normalized.replace(/-template$/i, ''),
-      normalized.replace(/-starter$/i, ''),
-    ]),
-  ).filter(Boolean)
-
-  const cwd = process.cwd()
-  const rootCandidates = [
-    cwd,
-    resolve(cwd, '..'),
-    resolve(cwd, '../..'),
-    resolve(cwd, '../../..'),
-  ]
-
-  for (const root of rootCandidates) {
-    for (const framework of ['react', 'solid']) {
-      for (const id of idVariants) {
-        const templatePath = resolve(root, 'examples', framework, id, 'template.json')
-        if (fs.existsSync(templatePath)) {
-          return templatePath
-        }
-
-        const starterPath = resolve(root, 'examples', framework, id, 'starter.json')
-        if (fs.existsSync(starterPath)) {
-          return starterPath
-        }
-      }
-    }
-  }
-
-  return undefined
-}
-
-async function resolveStarterSpecifier(starterSpecifier: string) {
-  const normalized = starterSpecifier.trim()
-
-  if (!normalized || isLikelyStarterUrlOrPath(normalized)) {
-    return normalized
-  }
-
-  const registry = await getRawRegistry()
-  if (registry && registry.starters?.length) {
-    const lookup = normalized.toLowerCase()
-    const match = registry.starters.find((starter) => {
-      const candidateIds = new Set<string>()
-      candidateIds.add(starter.name.toLowerCase())
-      candidateIds.add(slugifyStarterName(starter.name))
-
-      for (const id of getStarterIdsFromUrl(starter.url)) {
-        candidateIds.add(id)
-      }
-
-      return candidateIds.has(lookup)
-    })
-
-    if (match) {
-      return match.url
-    }
-  }
-
-  const monorepoStarterPath = resolveMonorepoStarterById(normalized)
-  if (monorepoStarterPath) {
-    return monorepoStarterPath
-  }
-
-  if (!registry || !registry.starters?.length) {
-    throw new Error(
-      `Could not resolve template id "${normalized}" because no template registry is configured. Pass a template URL (or set CTA_REGISTRY).`,
-    )
-  }
-
-  const availableIds = Array.from(
-    new Set(
-      registry.starters.flatMap((starter) => {
-        const ids = [slugifyStarterName(starter.name)]
-        ids.push(...Array.from(getStarterIdsFromUrl(starter.url)))
-        return ids
-      }),
-    ),
-  )
-    .filter(Boolean)
-    .sort()
-
-  throw new Error(
-    `Unknown template id "${normalized}". Available built-in templates: ${availableIds.join(', ')}`,
-  )
-}
-
-export function validateLegacyCreateFlags(cliOptions: CliOptions): {
-  warnings: Array<string>
-  error?: string
-} {
-  const warnings: Array<string> = []
-  const legacyTemplate = getLegacyTemplateValue(cliOptions.template)
-
-  if (cliOptions.starter) {
-    warnings.push(
-      'The --starter flag is deprecated; prefer --template instead. Backward compatibility remains for now.',
-    )
-  }
-
-  if (cliOptions.starter && cliOptions.template && !legacyTemplate) {
-    warnings.push(
-      'Both --starter and --template were provided. --template takes precedence.',
-    )
-  }
-
-  if (cliOptions.routerOnly) {
-    warnings.push(
-      'The --router-only flag enables router-only compatibility mode. Start-dependent add-ons, deployment adapters, and templates are disabled; only the base template and optional toolchain are supported.',
-    )
-  }
-
-  if (cliOptions.routerOnly && cliOptions.addOns) {
-    warnings.push(
-      'Ignoring --add-ons in router-only compatibility mode.',
-    )
-  }
-
-  if (cliOptions.routerOnly && cliOptions.deployment) {
-    warnings.push(
-      'Ignoring --deployment in router-only compatibility mode.',
-    )
-  }
-
-  if (cliOptions.routerOnly && cliOptions.starter) {
-    warnings.push('Ignoring --starter/--template in router-only compatibility mode.')
-  }
-
-  if (cliOptions.routerOnly && cliOptions.templateId) {
-    warnings.push('Ignoring --template-id in router-only compatibility mode.')
-  }
-
-  if (cliOptions.tailwind === true) {
-    warnings.push(
-      'The --tailwind flag is deprecated and ignored. Tailwind is always enabled in TanStack Start scaffolds.',
-    )
-  }
-
-  if (cliOptions.tailwind === false) {
-    warnings.push(
-      'The --no-tailwind flag is deprecated and ignored. Tailwind opt-out is intentionally unsupported to keep add-on permutations maintainable; remove Tailwind after scaffolding if needed.',
-    )
-  }
-
-  if (!legacyTemplate) {
-    return { warnings }
-  }
-
-  const template = legacyTemplate
-
-  if (template === 'javascript' || template === 'js' || template === 'jsx') {
-    return {
-      warnings,
-      error:
-        'JavaScript/JSX templates are not supported. TanStack Start file-router templates are TypeScript-only.',
-    }
-  }
-
-  if (!SUPPORTED_LEGACY_TEMPLATES.has(template)) {
-    return {
-      warnings,
-      error: `Invalid --template value: ${cliOptions.template}. Supported values are: file-router, typescript, tsx.`,
-    }
-  }
-
-  warnings.push('The --template flag is deprecated and mapped for compatibility.')
-
-  return { warnings }
-}
-
-export async function normalizeOptions(
-  cliOptions: CliOptions,
-  forcedAddOns?: Array<string>,
-  opts?: {
-    disableNameCheck?: boolean
-    forcedDeployment?: string
-  },
-): Promise<Options | undefined> {
-  let projectName = (cliOptions.projectName ?? '').trim()
-  let targetDir: string
-
-  // Handle "." as project name - use current directory
-  if (projectName === '.') {
-    projectName = sanitizePackageName(getCurrentDirectoryName())
-    targetDir = resolve(process.cwd())
-  } else {
-    targetDir = resolve(process.cwd(), projectName)
-  }
-
-  if (!projectName && !opts?.disableNameCheck) {
-    return undefined
-  }
-
-  if (projectName) {
-    const { valid, error } = validateProjectName(projectName)
-    if (!valid) {
-      console.error(error)
-      process.exit(1)
-    }
-  }
-
-  // Mode is always file-router (TanStack Start)
-  let mode = 'file-router'
-  let routerOnly = !!cliOptions.routerOnly
-
-  const legacyTemplate = getLegacyTemplateValue(cliOptions.template)
-
-  if (!cliOptions.starter) {
-    if (cliOptions.template && !legacyTemplate) {
-      cliOptions.starter = cliOptions.template
-    } else if (cliOptions.templateId) {
-      cliOptions.starter = cliOptions.templateId
-    }
-  }
-
-  const template = legacyTemplate
-  if (template && template !== 'file-router') {
-    routerOnly = true
-  }
-
-  if (!cliOptions.starter && cliOptions.templateId) {
-    cliOptions.starter = cliOptions.templateId
-  }
-
-  const starter = !routerOnly && cliOptions.starter
-    ? await loadStarter(await resolveStarterSpecifier(cliOptions.starter))
-    : undefined
-
-  // TypeScript and Tailwind are always enabled with TanStack Start
-  const typescript = true
-  const tailwind = true
-
-  if (starter) {
-    cliOptions.framework = starter.framework
-    mode = starter.mode
-  }
-
-  const framework = getFrameworkById(cliOptions.framework || 'react')!
-
-  async function selectAddOns() {
-    // Edge case for Windows Powershell
-    if (Array.isArray(cliOptions.addOns) && cliOptions.addOns.length === 1) {
-      const parseSeparatedArgs = cliOptions.addOns[0].split(' ')
-      if (parseSeparatedArgs.length > 1) {
-        cliOptions.addOns = parseSeparatedArgs
-      }
-    }
-
-    if (
-      Array.isArray(cliOptions.addOns) ||
-      starter?.dependsOn ||
-      forcedAddOns ||
-      cliOptions.toolchain ||
-      cliOptions.deployment
-    ) {
-      const selectedAddOns = new Set<string>([
-        ...(routerOnly ? [] : (starter?.dependsOn || [])),
-        ...(routerOnly ? [] : (forcedAddOns || [])),
-      ])
-      if (!routerOnly && cliOptions.addOns && Array.isArray(cliOptions.addOns)) {
-        for (const a of cliOptions.addOns) {
-          if (a.toLowerCase() === 'start') {
-            continue
-          }
-          selectedAddOns.add(a)
-        }
-      }
-      if (cliOptions.toolchain) {
-        selectedAddOns.add(cliOptions.toolchain)
-      }
-      if (!routerOnly && cliOptions.deployment) {
-        selectedAddOns.add(cliOptions.deployment)
-      }
-
-      if (!routerOnly && !cliOptions.deployment && opts?.forcedDeployment) {
-        selectedAddOns.add(opts.forcedDeployment)
-      }
-
-      return await finalizeAddOns(framework, mode, Array.from(selectedAddOns))
-    }
-
-    return []
-  }
-
-  const includeExamples = cliOptions.examples ?? !routerOnly
-  const chosenAddOnsRaw = await selectAddOns()
-  const chosenAddOns = includeExamples
-    ? chosenAddOnsRaw
-    : chosenAddOnsRaw.filter((addOn) => addOn.type !== 'example')
-
-  // Handle add-on configuration option
-  let addOnOptionsFromCLI = {}
-  if (cliOptions.addOnConfig) {
-    try {
-      addOnOptionsFromCLI = JSON.parse(cliOptions.addOnConfig)
-    } catch (error) {
-      console.error('Error parsing add-on config:', error)
-      process.exit(1)
-    }
-  }
-
-  const normalized = {
-    projectName: projectName,
-    targetDir,
-    framework,
-    mode,
-    typescript,
-    tailwind,
-    packageManager:
-      cliOptions.packageManager ||
-      getPackageManager() ||
-      DEFAULT_PACKAGE_MANAGER,
-    git: cliOptions.git ?? true,
-    install: cliOptions.install,
-    chosenAddOns,
-    addOnOptions: {
-      ...populateAddOnOptionsDefaults(chosenAddOns),
-      ...addOnOptionsFromCLI,
-    },
-    starter: starter,
-  }
-
-  ;(normalized as Options & { includeExamples?: boolean }).includeExamples =
-    includeExamples
-  ;(normalized as Options & { envVarValues?: Record<string, string> }).envVarValues =
-    {}
-
-  return normalized
-}
-
-export function validateDevWatchOptions(cliOptions: CliOptions): {
-  valid: boolean
-  error?: string
-} {
-  if (!cliOptions.devWatch) {
-    return { valid: true }
-  }
-
-  // Validate watch path exists
-  const watchPath = resolve(process.cwd(), cliOptions.devWatch)
-  if (!fs.existsSync(watchPath)) {
-    return {
-      valid: false,
-      error: `Watch path does not exist: ${watchPath}`,
-    }
-  }
-
-  // Validate it's a directory
-  const stats = fs.statSync(watchPath)
-  if (!stats.isDirectory()) {
-    return {
-      valid: false,
-      error: `Watch path is not a directory: ${watchPath}`,
-    }
-  }
-
-  // Ensure target directory is specified
-  if (!cliOptions.projectName && !cliOptions.targetDir) {
-    return {
-      valid: false,
-      error: 'Project name or target directory is required for dev watch mode',
-    }
-  }
-
-  // Check for framework structure
-  const hasAddOns = fs.existsSync(resolve(watchPath, 'add-ons'))
-  const hasAssets = fs.existsSync(resolve(watchPath, 'assets'))
-  const hasFrameworkJson = fs.existsSync(resolve(watchPath, 'framework.json'))
-
-  if (!hasAddOns && !hasAssets && !hasFrameworkJson) {
-    return {
-      valid: false,
-      error: `Watch path does not appear to be a valid framework directory: ${watchPath}`,
-    }
-  }
-
-  return { valid: true }
-}