chore: fixup a lot of small issues

Author: jherr

packages/cta-cli/src/cli.ts

@@ -20,12 +20,7 @@ import { normalizeOptions, promptForOptions } from './options.js'
 
 import { createUIEnvironment } from './ui-environment.js'
 
-import type {
-  Mode,
-  PackageManager,
-  TemplateOptions,
-  ToolChain,
-} from '@tanstack/cta-core'
+import type { Mode, PackageManager, TemplateOptions } from '@tanstack/cta-core'
 
 import type { CliOptions } from './types.js'
 
@@ -164,18 +159,18 @@ export function cli({
         return value as PackageManager
       },
     )
-    .option<ToolChain>(
+    .option<string>(
       `--toolchain <${Array.from(toolchains).join('|')}>`,
       `Explicitly tell the CLI to use this toolchain`,
       (value) => {
-        if (!toolchains.has(value as ToolChain)) {
+        if (!toolchains.has(value)) {
           throw new InvalidArgumentError(
             `Invalid toolchain: ${value}. The following are allowed: ${Array.from(
               toolchains,
             ).join(', ')}`,
           )
         }
-        return value as ToolChain
+        return value
       },
     )
     .option('--tailwind', 'add Tailwind CSS', false)

packages/cta-core/package.json

@@ -32,14 +32,14 @@
     "ejs": "^3.1.10",
     "execa": "^9.5.2",
     "memfs": "^4.17.0",
-    "prettier": "^3.5.0",
-    "vitest": "^3.1.1"
+    "prettier": "^3.5.0"
   },
   "devDependencies": {
     "@tanstack/config": "^0.16.2",
     "@types/ejs": "^3.1.5",
     "@types/node": "^22.13.4",
     "eslint": "^9.20.0",
-    "typescript": "^5.6.3"
+    "typescript": "^5.6.3",
+    "vitest": "^3.1.1"
   }
 }

packages/cta-core/src/environment.ts

@@ -6,7 +6,7 @@ import {
   unlink,
   writeFile,
 } from 'node:fs/promises'
-import { existsSync, readdirSync, statSync } from 'node:fs'
+import { existsSync } from 'node:fs'
 import { dirname } from 'node:path'
 import { execa } from 'execa'
 import { memfs } from 'memfs'
@@ -49,14 +49,7 @@ export function createDefaultEnvironment(): Environment {
       await unlink(path)
     },
 
-    readFile: (path: string, encoding?: BufferEncoding) =>
-      readFile(path, { encoding: encoding || 'utf8' }),
     exists: (path: string) => existsSync(path),
-    readdir: (path) => readdirSync(path),
-    isDirectory: (path) => {
-      const stat = statSync(path)
-      return stat.isDirectory()
-    },
 
     intro: () => {},
     outro: () => {},
@@ -112,12 +105,6 @@ export function createMemoryEnvironment() {
     })
     return Promise.resolve()
   }
-  environment.readFile = async (path: string, encoding?: BufferEncoding) => {
-    if (isTemplatePath(path)) {
-      return (await readFile(path, encoding)).toString()
-    }
-    return fs.readFileSync(path, 'utf8').toString()
-  }
   environment.writeFile = async (path: string, contents: string) => {
     fs.mkdirSync(dirname(path), { recursive: true })
     await fs.writeFileSync(path, contents)
@@ -131,19 +118,6 @@ export function createMemoryEnvironment() {
     }
     return fs.existsSync(path)
   }
-  environment.readdir = (path: string) => {
-    if (isTemplatePath(path)) {
-      return readdirSync(path)
-    }
-    return fs.readdirSync(path).map((file) => file.toString())
-  }
-  environment.isDirectory = (path) => {
-    if (isTemplatePath(path)) {
-      const stat = statSync(path)
-      return stat.isDirectory()
-    }
-    return fs.statSync(path).isDirectory()
-  }
   environment.finishRun = () => {
     output.files = vol.toJSON() as Record<string, string>
   }

packages/cta-core/src/file-helper.ts

@@ -0,0 +1,73 @@
+import { readFileSync, readdirSync, statSync } from 'node:fs'
+import { basename, extname, resolve } from 'node:path'
+
+const BINARY_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico']
+
+export function readFileHelper(path: string): string {
+  if (BINARY_EXTENSIONS.includes(extname(path))) {
+    return `base64::${readFileSync(path).toString('base64')}`
+  } else {
+    return readFileSync(path, 'utf-8').toString()
+  }
+}
+
+export function getBinaryFile(content: string): string | null {
+  if (content.startsWith('base64::')) {
+    const binaryContent = Buffer.from(content.replace('base64::', ''), 'base64')
+    return binaryContent as unknown as string
+  }
+  return null
+}
+
+export function relativePath(from: string, to: string) {
+  const cleanedFrom = from.startsWith('./') ? from.slice(2) : from
+  const cleanedTo = to.startsWith('./') ? to.slice(2) : to
+
+  const fromSegments = cleanedFrom.split('/')
+  const toSegments = cleanedTo.split('/')
+
+  fromSegments.pop()
+  toSegments.pop()
+
+  let commonIndex = 0
+  while (
+    commonIndex < fromSegments.length &&
+    commonIndex < toSegments.length &&
+    fromSegments[commonIndex] === toSegments[commonIndex]
+  ) {
+    commonIndex++
+  }
+
+  const upLevels = fromSegments.length - commonIndex
+  const downLevels = toSegments.slice(commonIndex)
+
+  if (upLevels === 0 && downLevels.length === 0) {
+    return `./${basename(to)}`
+  } else if (upLevels === 0 && downLevels.length > 0) {
+    return `./${downLevels.join('/')}/${basename(to)}`
+  } else {
+    const relativePath = [...Array(upLevels).fill('..'), ...downLevels].join(
+      '/',
+    )
+    return `${relativePath}/${basename(to)}`
+  }
+}
+
+export function isDirectory(path: string): boolean {
+  return statSync(path).isDirectory()
+}
+
+export function findFilesRecursively(
+  path: string,
+  files: Record<string, string>,
+) {
+  const dirFiles = readdirSync(path)
+  for (const file of dirFiles) {
+    const filePath = resolve(path, file)
+    if (isDirectory(filePath)) {
+      findFilesRecursively(filePath, files)
+    } else {
+      files[filePath] = readFileHelper(filePath)
+    }
+  }
+}

packages/cta-core/src/file-helpers.ts

@@ -1,8 +1,11 @@
 import { existsSync, readFileSync, readdirSync } from 'node:fs'
 import { resolve } from 'node:path'
 
-import { findFilesRecursively, isDirectory } from './utils.js'
-import { readFileHelper } from './file-helper.js'
+import {
+  findFilesRecursively,
+  isDirectory,
+  readFileHelper,
+} from './file-helpers.js'
 
 import type { AddOn, Framework, FrameworkDefinition } from './types.js'
 

packages/cta-core/src/frameworks.ts

@@ -8,6 +8,9 @@ export {
   DEFAULT_PACKAGE_MANAGER,
   SUPPORTED_PACKAGE_MANAGERS,
   getPackageManager,
+  getPackageManagerInstallCommand,
+  getPackageManagerExecuteCommand,
+  packageManagerInstall,
   packageManagerExecute,
 } from './package-manager.js'
 export {
@@ -16,9 +19,9 @@ export {
   getFrameworkByName,
   getFrameworks,
 } from './frameworks.js'
-export { jsSafeName, relativePath, sortObject } from './utils.js'
+export { formatCommand, jsSafeName, sortObject } from './utils.js'
 export { writeConfigFile, readConfigFile } from './config-file.js'
-export { readFileHelper, getBinaryFile } from './file-helper.js'
+export { readFileHelper, getBinaryFile, relativePath } from './file-helpers.js'
 
 export type {
   AddOn,
@@ -33,4 +36,3 @@ export type {
 } from './types.js'
 export type { PersistedOptions } from './config-file.js'
 export type { PackageManager } from './package-manager.js'
-export type { ToolChain } from './toolchain.js'

packages/cta-core/src/index.ts

@@ -24,23 +24,76 @@ export function getPackageManager(): PackageManager | undefined {
   return packageManager
 }
 
-export function packageManagerExecute(
-  environment: Environment,
+export function getPackageManagerExecuteCommand(
   packagerManager: PackageManager,
   pkg: string,
-  args: Array<string>,
-  cwd: string,
+  args: Array<string> = [],
 ) {
   switch (packagerManager) {
     case 'yarn':
-      return environment.execute('yarn', ['dlx', pkg, ...args], cwd)
+      return { command: 'yarn', args: ['dlx', pkg, ...args] }
     case 'pnpm':
-      return environment.execute('pnpx', [pkg, ...args], cwd)
+      return { command: 'pnpx', args: [pkg, ...args] }
     case 'bun':
-      return environment.execute('bunx', ['--bun', pkg, ...args], cwd)
+      return { command: 'bunx', args: ['--bun', pkg, ...args] }
     case 'deno':
-      return environment.execute('deno', ['run', `npm:${pkg}`, ...args], cwd)
+      return { command: 'deno', args: ['run', `npm:${pkg}`, ...args] }
     default:
-      return environment.execute('npx', [pkg, ...args], cwd)
+      return { command: 'npx', args: [pkg, ...args] }
   }
 }
+
+export function getPackageManagerInstallCommand(
+  packagerManager: PackageManager,
+  pkg?: string,
+  isDev: boolean = false,
+) {
+  if (pkg) {
+    switch (packagerManager) {
+      case 'yarn':
+      case 'pnpm':
+        return {
+          command: packagerManager,
+          args: ['add', pkg, isDev ? '--dev' : ''],
+        }
+      default:
+        return {
+          command: packagerManager,
+          args: ['install', pkg, isDev ? '-D' : ''],
+        }
+    }
+  } else {
+    return {
+      command: packagerManager,
+      args: ['install'],
+    }
+  }
+}
+
+export function packageManagerInstall(
+  environment: Environment,
+  cwd: string,
+  packagerManager: PackageManager,
+  pkg?: string,
+) {
+  const { command, args: commandArgs } = getPackageManagerInstallCommand(
+    packagerManager,
+    pkg,
+  )
+  return environment.execute(command, commandArgs, cwd)
+}
+
+export function packageManagerExecute(
+  environment: Environment,
+  cwd: string,
+  packagerManager: PackageManager,
+  pkg: string,
+  args: Array<string>,
+) {
+  const { command, args: commandArgs } = getPackageManagerExecuteCommand(
+    packagerManager,
+    pkg,
+    args,
+  )
+  return environment.execute(command, commandArgs, cwd)
+}

packages/cta-core/src/package-manager.ts

@@ -108,11 +108,7 @@ type FileEnvironment = {
   writeFile: (path: string, contents: string) => Promise<void>
   execute: (command: string, args: Array<string>, cwd: string) => Promise<void>
   deleteFile: (path: string) => Promise<void>
-
-  readFile: (path: string, encoding?: BufferEncoding) => Promise<string>
   exists: (path: string) => boolean
-  readdir: (path: string) => Array<string>
-  isDirectory: (path: string) => boolean
 }
 
 type UIEnvironment = {