@tanstack/cta-engine 0.10.0-alpha.21 → 0.10.0-alpha.25

package/src/add-to-app.ts

@@ -1,274 +0,0 @@
-import { basename, resolve } from 'node:path'
-
-import { CONFIG_FILE } from './constants.js'
-import { finalizeAddOns } from './add-ons.js'
-import { getFrameworkById } from './frameworks.js'
-import { createMemoryEnvironment } from './environment.js'
-import { createApp } from './create-app.js'
-import {
-  readConfigFileFromEnvironment,
-  writeConfigFileToEnvironment,
-} from './config-file.js'
-import { formatCommand } from './utils.js'
-import { packageManagerInstall } from './package-manager.js'
-import {
-  isBase64,
-  recursivelyGatherFilesFromEnvironment,
-} from './file-helpers.js'
-import { mergePackageJSON } from './package-json.js'
-import { runSpecialSteps } from './special-steps/index.js'
-
-import type { Environment, Mode, Options } from './types.js'
-import type { PersistedOptions } from './config-file.js'
-
-export async function hasPendingGitChanges(
-  environment: Environment,
-  cwd: string,
-) {
-  const { stdout } = await environment.execute(
-    'git',
-    ['status', '--porcelain'],
-    cwd,
-  )
-  return stdout.length > 0
-}
-
-async function createOptions(
-  json: PersistedOptions,
-  addOns: Array<string>,
-  targetDir: string,
-): Promise<Options> {
-  const framework = getFrameworkById(json.framework)
-
-  // TODO: Load the starter
-
-  return {
-    ...json,
-    framework,
-    tailwind: true,
-    addOns: true,
-    chosenAddOns: await finalizeAddOns(framework!, json.mode as Mode, [
-      ...json.existingAddOns,
-      ...addOns,
-    ]),
-    targetDir,
-  } as Options
-}
-
-async function runCreateApp(options: Required<Options>) {
-  const { environment, output } = createMemoryEnvironment(options.targetDir)
-  await createApp(environment, options)
-  return output
-}
-
-export async function getCurrentConfiguration(
-  environment: Environment,
-  cwd: string,
-) {
-  const persistedOptions = await readConfigFileFromEnvironment(environment, cwd)
-  if (!persistedOptions) {
-    environment.error(
-      'There is no .cta.json file in your project.',
-      'This is probably because this was created with an older version of create-tsrouter-app.',
-    )
-    return undefined
-  }
-
-  return persistedOptions
-}
-
-export async function writeFiles(
-  environment: Environment,
-  cwd: string,
-  output: {
-    files: Record<string, string>
-    deletedFiles: Array<string>
-  },
-  forced: boolean,
-) {
-  const currentFiles = await recursivelyGatherFilesFromEnvironment(
-    environment,
-    cwd,
-    false,
-  )
-
-  const overwrittenFiles: Array<string> = []
-  const changedFiles: Array<string> = []
-  for (const file of Object.keys(output.files)) {
-    const relativeFile = file.replace(cwd, '')
-    if (currentFiles[relativeFile]) {
-      if (currentFiles[relativeFile] !== output.files[file]) {
-        overwrittenFiles.push(relativeFile)
-      }
-    } else {
-      changedFiles.push(relativeFile)
-    }
-  }
-
-  if (!forced && overwrittenFiles.length) {
-    environment.warn(
-      'The following will be overwritten',
-      [...overwrittenFiles, ...output.deletedFiles].join('\n'),
-    )
-    const shouldContinue = await environment.confirm('Do you want to continue?')
-    if (!shouldContinue) {
-      throw new Error('User cancelled')
-    }
-  }
-
-  for (const file of output.deletedFiles) {
-    if (environment.exists(resolve(cwd, file))) {
-      await environment.deleteFile(resolve(cwd, file))
-    }
-  }
-
-  environment.startStep({
-    id: 'write-files',
-    type: 'file',
-    message: 'Writing add-on files...',
-  })
-
-  for (const file of [...changedFiles, ...overwrittenFiles]) {
-    const fName = basename(file)
-    const contents = output.files[file]
-    if (fName === 'package.json') {
-      const currentJson = JSON.parse(
-        await environment.readFile(resolve(cwd, file)),
-      )
-      const newJSON = mergePackageJSON(currentJson, JSON.parse(contents))
-      environment.writeFile(
-        resolve(cwd, file),
-        JSON.stringify(newJSON, null, 2),
-      )
-    } else if (fName !== CONFIG_FILE) {
-      if (isBase64(contents)) {
-        await environment.writeFileBase64(resolve(cwd, file), contents)
-      } else {
-        await environment.writeFile(resolve(cwd, file), contents)
-      }
-    }
-  }
-
-  environment.finishStep('write-files', 'Add-on files written')
-}
-
-export async function runNewCommands(
-  environment: Environment,
-  originalOptions: PersistedOptions,
-  cwd: string,
-  output: {
-    commands: Array<{
-      command: string
-      args: Array<string>
-    }>
-  },
-) {
-  const originalOutput = await runCreateApp({
-    ...(await createOptions(originalOptions, [], cwd)),
-  } as Required<Options>)
-
-  const originalCommands = new Set(
-    originalOutput.commands.map((c) => [c.command, ...c.args].join(' ')),
-  )
-
-  for (const command of output.commands) {
-    const commandString = [command.command, ...command.args].join(' ')
-    if (!originalCommands.has(commandString)) {
-      environment.startStep({
-        id: 'run-commands',
-        type: 'command',
-        message: `Running ${formatCommand({ command: command.command, args: command.args })}...`,
-      })
-      await environment.execute(command.command, command.args, cwd)
-      environment.finishStep('run-commands', 'Setup commands complete')
-    }
-  }
-}
-
-export async function addToApp(
-  environment: Environment,
-  addOns: Array<string>,
-  cwd: string,
-  options?: {
-    forced?: boolean
-  },
-) {
-  const persistedOptions = await getCurrentConfiguration(environment, cwd)
-  if (!persistedOptions) {
-    return
-  }
-
-  if (!options?.forced && (await hasPendingGitChanges(environment, cwd))) {
-    environment.error(
-      'You have pending git changes.',
-      'Please commit or stash them before adding add-ons.',
-    )
-    return
-  }
-
-  environment.intro(`Adding ${addOns.join(', ')} to the project...`)
-  environment.startStep({
-    id: 'processing-new-app-setup',
-    type: 'file',
-    message: 'Processing new app setup...',
-  })
-
-  const newOptions = await createOptions(persistedOptions, addOns, cwd)
-
-  const output = await runCreateApp({
-    ...newOptions,
-    targetDir: cwd,
-  } as Required<Options>)
-
-  await writeFiles(environment, cwd, output, !!options?.forced)
-
-  environment.finishStep(
-    'processing-new-app-setup',
-    'Application files written',
-  )
-
-  // Run any special steps for the new add-ons
-
-  const specialSteps = new Set<string>([])
-  for (const addOn of newOptions.chosenAddOns) {
-    for (const step of addOn.addOnSpecialSteps || []) {
-      if (addOns.includes(addOn.id)) {
-        specialSteps.add(step)
-      }
-    }
-  }
-  if (specialSteps.size) {
-    await runSpecialSteps(environment, newOptions, Array.from(specialSteps))
-  }
-
-  // Install dependencies
-
-  environment.startStep({
-    id: 'install-dependencies',
-    type: 'package-manager',
-    message: `Installing dependencies via ${newOptions.packageManager}...`,
-  })
-  const s = environment.spinner()
-  s.start(`Installing dependencies via ${newOptions.packageManager}...`)
-  await packageManagerInstall(
-    environment,
-    newOptions.targetDir,
-    newOptions.packageManager,
-  )
-  s.stop(`Installed dependencies`)
-  environment.finishStep('install-dependencies', 'Dependencies installed')
-
-  // Handle new commands
-
-  await runNewCommands(environment, persistedOptions, cwd, output)
-
-  environment.startStep({
-    id: 'write-config-file',
-    type: 'file',
-    message: 'Writing config file...',
-  })
-  writeConfigFileToEnvironment(environment, newOptions)
-  environment.finishStep('write-config-file', 'Config file written')
-
-  environment.outro('Add-ons added successfully!')
-}

package/src/custom-add-ons/add-on.ts

@@ -1,261 +0,0 @@
-import { readFile } from 'node:fs/promises'
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
-import { basename, dirname, resolve } from 'node:path'
-
-import { AddOnCompiledSchema } from '../types.js'
-import { createIgnore, recursivelyGatherFiles } from '../file-helpers.js'
-import {
-  compareFilesRecursively,
-  createAppOptionsFromPersisted,
-  createPackageAdditions,
-  readCurrentProjectOptions,
-  runCreateApp,
-} from './shared.js'
-
-import type { PersistedOptions } from '../config-file'
-import type {
-  AddOn,
-  AddOnCompiled,
-  AddOnInfo,
-  Environment,
-  Options,
-} from '../types'
-
-const ADD_ON_DIR = '.add-on'
-
-export const ADD_ON_IGNORE_FILES: Array<string> = [
-  'main.jsx',
-  'App.jsx',
-  'main.tsx',
-  'App.tsx',
-  'routeTree.gen.ts',
-]
-
-const INFO_FILE = '.add-on/info.json'
-const COMPILED_FILE = 'add-on.json'
-
-const ASSETS_DIR = 'assets'
-
-export function camelCase(str: string) {
-  return str
-    .split(/(\.|-|\/)/)
-    .filter((part) => /^[a-zA-Z]+$/.test(part))
-    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-    .join('')
-}
-
-export function templatize(routeCode: string, routeFile: string) {
-  let code = routeCode
-
-  // Replace the import
-  code = code.replace(
-    /import { createFileRoute } from ['"]@tanstack\/react-router['"]/g,
-    `import { <% if (fileRouter) { %>createFileRoute<% } else { %>createRoute<% } %> } from '@tanstack/react-router'`,
-  )
-
-  // Extract route path and definition, then transform the route declaration
-  const routeMatch = code.match(
-    /export\s+const\s+Route\s*=\s*createFileRoute\(['"]([^'"]+)['"]\)\s*\(\{([^}]+)\}\)/,
-  )
-
-  let path = ''
-
-  if (routeMatch) {
-    const fullMatch = routeMatch[0]
-    path = routeMatch[1]
-    const routeDefinition = routeMatch[2]
-    code = code.replace(
-      fullMatch,
-      `<% if (codeRouter) { %>
-import type { RootRoute } from '@tanstack/react-router'
-<% } else { %>
-export const Route = createFileRoute('${path}')({${routeDefinition}})
-<% } %>`,
-    )
-
-    code += `
-<% if (codeRouter) { %>
-export default (parentRoute: RootRoute) => createRoute({
-  path: '${path}',
-  ${routeDefinition}
-  getParentRoute: () => parentRoute,
-})
-<% } %>
-`
-  } else {
-    console.error(`No route found in the file: ${routeFile}`)
-  }
-
-  const name = basename(path)
-    .replace('.tsx', '')
-    .replace(/^demo/, '')
-    .replace('.', ' ')
-    .trim()
-
-  const jsName = camelCase(basename(path))
-
-  return { url: path, code, name, jsName }
-}
-
-export async function validateAddOnSetup(environment: Environment) {
-  const options = await readCurrentProjectOptions(environment)
-
-  if (options.mode !== 'file-router') {
-    environment.error(
-      'This project is not using file-router mode.',
-      'To create an add-on, the project must be created with the file-router mode.',
-    )
-    process.exit(1)
-  }
-  if (!options.tailwind) {
-    environment.error(
-      'This project is not using Tailwind CSS.',
-      'To create an add-on, the project must be created with Tailwind CSS.',
-    )
-    process.exit(1)
-  }
-  if (!options.typescript) {
-    environment.error(
-      'This project is not using TypeScript.',
-      'To create an add-on, the project must be created with TypeScript.',
-    )
-    process.exit(1)
-  }
-}
-
-export async function readOrGenerateAddOnInfo(
-  options: PersistedOptions,
-): Promise<AddOnInfo> {
-  return existsSync(INFO_FILE)
-    ? JSON.parse((await readFile(INFO_FILE)).toString())
-    : ({
-        id: `${options.projectName}-add-on`,
-        name: `${options.projectName}-add-on`,
-        version: '0.0.1',
-        description: 'Add-on',
-        author: 'Jane Smith <jane.smith@example.com>',
-        license: 'MIT',
-        link: `https://github.com/jane-smith/${options.projectName}-add-on`,
-        shadcnComponents: [],
-        framework: options.framework,
-        modes: [options.mode],
-        routes: [],
-        warning: '',
-        phase: 'add-on',
-        type: 'add-on',
-        packageAdditions: {
-          scripts: {},
-          dependencies: {},
-          devDependencies: {},
-        },
-        dependsOn: options.existingAddOns,
-      } as AddOnInfo)
-}
-
-export async function generateProject(persistedOptions: PersistedOptions) {
-  const info = await readOrGenerateAddOnInfo(persistedOptions)
-
-  const output = await runCreateApp(
-    (await createAppOptionsFromPersisted(
-      persistedOptions,
-    )) as Required<Options>,
-  )
-
-  return { info, output }
-}
-
-export async function buildAssetsDirectory(
-  output: {
-    files: Record<string, string>
-  },
-  info: AddOnInfo,
-) {
-  const assetsDir = resolve(ADD_ON_DIR, ASSETS_DIR)
-  const ignore = createIgnore(process.cwd())
-
-  if (!existsSync(assetsDir)) {
-    const changedFiles: Record<string, string> = {}
-    await compareFilesRecursively('.', ignore, output.files, changedFiles)
-
-    for (const file of Object.keys(changedFiles).filter(
-      (file) => !ADD_ON_IGNORE_FILES.includes(basename(file)),
-    )) {
-      mkdirSync(dirname(resolve(assetsDir, file)), {
-        recursive: true,
-      })
-      if (file.includes('/routes/')) {
-        const { url, code, name, jsName } = templatize(changedFiles[file], file)
-        info.routes ||= []
-        if (!info.routes.find((r) => r.url === url)) {
-          info.routes.push({
-            url,
-            name,
-            jsName,
-            path: file,
-          })
-        }
-        writeFileSync(resolve(assetsDir, `${file}.ejs`), code)
-      } else {
-        writeFileSync(resolve(assetsDir, file), changedFiles[file])
-      }
-    }
-  }
-}
-
-export async function updateAddOnInfo(environment: Environment) {
-  const { info, output } = await generateProject(
-    await readCurrentProjectOptions(environment),
-  )
-
-  info.packageAdditions = createPackageAdditions(
-    JSON.parse(output.files['./package.json']),
-    JSON.parse((await readFile('package.json')).toString()),
-  )
-
-  await buildAssetsDirectory(output, info)
-
-  mkdirSync(resolve(dirname(INFO_FILE)), { recursive: true })
-  writeFileSync(INFO_FILE, JSON.stringify(info, null, 2))
-}
-
-export async function compileAddOn(environment: Environment) {
-  const info = await readOrGenerateAddOnInfo(
-    await readCurrentProjectOptions(environment),
-  )
-
-  const assetsDir = resolve(ADD_ON_DIR, ASSETS_DIR)
-
-  const compiledInfo: AddOnCompiled = {
-    ...info,
-    files: await recursivelyGatherFiles(assetsDir),
-    deletedFiles: [],
-  }
-
-  writeFileSync(COMPILED_FILE, JSON.stringify(compiledInfo, null, 2))
-}
-
-export async function initAddOn(environment: Environment) {
-  await validateAddOnSetup(environment)
-  await updateAddOnInfo(environment)
-  await compileAddOn(environment)
-}
-
-export async function loadRemoteAddOn(url: string): Promise<AddOn> {
-  const response = await fetch(url)
-  const jsonContent = await response.json()
-
-  const checked = AddOnCompiledSchema.safeParse(jsonContent)
-  if (!checked.success) {
-    throw new Error(`Invalid add-on: ${url}`)
-  }
-
-  const addOn = checked.data
-  addOn.id = url
-  const out = {
-    ...addOn,
-    getFiles: () => Promise.resolve(Object.keys(addOn.files)),
-    getFileContents: (path: string) => Promise.resolve(addOn.files[path]),
-    getDeletedFiles: () => Promise.resolve(addOn.deletedFiles),
-  }
-  return out
-}

package/src/custom-add-ons/shared.ts

@@ -1,161 +0,0 @@
-import { readdir } from 'node:fs/promises'
-import { resolve } from 'node:path'
-import { createApp } from '../create-app.js'
-import { createMemoryEnvironment } from '../environment.js'
-import { finalizeAddOns } from '../add-ons.js'
-import { getFrameworkById } from '../frameworks.js'
-import { readConfigFileFromEnvironment } from '../config-file.js'
-import { readFileHelper } from '../file-helpers.js'
-import { loadStarter } from '../custom-add-ons/starter.js'
-
-import type { Environment, Mode, Options, SerializedOptions } from '../types.js'
-import type { PersistedOptions } from '../config-file.js'
-
-export function createPackageAdditions(
-  originalPackageJson: Record<string, any>,
-  currentPackageJson: Record<string, any>,
-) {
-  const packageAdditions: Record<string, any> = {}
-
-  const scripts: Record<string, any> = {}
-  for (const script of Object.keys(currentPackageJson.scripts || {})) {
-    if (
-      originalPackageJson.scripts[script] !== currentPackageJson.scripts[script]
-    ) {
-      scripts[script] = currentPackageJson.scripts[script]
-    }
-  }
-  packageAdditions.scripts = Object.keys(scripts).length ? scripts : undefined
-
-  const dependencies: Record<string, string> = {}
-  for (const dependency of Object.keys(currentPackageJson.dependencies || {})) {
-    if (
-      originalPackageJson.dependencies[dependency] !==
-      currentPackageJson.dependencies[dependency]
-    ) {
-      dependencies[dependency] = currentPackageJson.dependencies[dependency]
-    }
-  }
-  packageAdditions.dependencies = Object.keys(dependencies).length
-    ? dependencies
-    : undefined
-
-  const devDependencies: Record<string, string> = {}
-  for (const dependency of Object.keys(
-    currentPackageJson.devDependencies || {},
-  )) {
-    if (
-      originalPackageJson.devDependencies[dependency] !==
-      currentPackageJson.devDependencies[dependency]
-    ) {
-      devDependencies[dependency] =
-        currentPackageJson.devDependencies[dependency]
-    }
-  }
-  packageAdditions.devDependencies = Object.keys(devDependencies).length
-    ? devDependencies
-    : undefined
-
-  return packageAdditions
-}
-
-export async function createAppOptionsFromPersisted(
-  json: PersistedOptions,
-): Promise<Options> {
-  /* eslint-disable unused-imports/no-unused-vars */
-  const { version, ...rest } = json
-  /* eslint-enable unused-imports/no-unused-vars */
-  const framework = getFrameworkById(rest.framework)
-  return {
-    ...rest,
-    mode: json.mode as Mode,
-    projectName: json.projectName!,
-    typescript: json.typescript!,
-    tailwind: json.tailwind!,
-    git: json.git!,
-    packageManager: json.packageManager!,
-    targetDir: '',
-    framework: framework!,
-    starter: json.starter ? await loadStarter(json.starter) : undefined,
-    chosenAddOns: await finalizeAddOns(framework!, json.mode as Mode, [
-      ...json.existingAddOns,
-    ]),
-  }
-}
-
-export function createSerializedOptionsFromPersisted(
-  json: PersistedOptions,
-): SerializedOptions {
-  /* eslint-disable unused-imports/no-unused-vars */
-  const { version, ...rest } = json
-  /* eslint-enable unused-imports/no-unused-vars */
-  return {
-    ...rest,
-    mode: json.mode as Mode,
-    projectName: json.projectName!,
-    typescript: json.typescript!,
-    tailwind: json.tailwind!,
-    git: json.git!,
-    packageManager: json.packageManager!,
-    targetDir: '',
-    framework: json.framework,
-    starter: json.starter,
-    chosenAddOns: json.existingAddOns,
-  }
-}
-
-export async function runCreateApp(options: Required<Options>) {
-  const { environment, output } = createMemoryEnvironment()
-
-  const targetDir = resolve(process.cwd())
-
-  await createApp(environment, {
-    ...options,
-    targetDir,
-  })
-
-  output.files = Object.fromEntries(
-    Object.entries(output.files).map(([key, value]) => {
-      return [key.replace(targetDir, '.'), value]
-    }),
-  )
-
-  return output
-}
-
-export async function compareFilesRecursively(
-  path: string,
-  ignore: (filePath: string) => boolean,
-  original: Record<string, string>,
-  changedFiles: Record<string, string>,
-) {
-  const files = await readdir(path, { withFileTypes: true })
-  for (const file of files) {
-    const filePath = `${path}/${file.name}`
-    if (!ignore(file.name)) {
-      if (file.isDirectory()) {
-        await compareFilesRecursively(filePath, ignore, original, changedFiles)
-      } else {
-        const contents = await readFileHelper(filePath)
-        if (!original[filePath] || original[filePath] !== contents) {
-          changedFiles[filePath] = contents
-        }
-      }
-    }
-  }
-}
-
-export async function readCurrentProjectOptions(environment: Environment) {
-  const persistedOptions = await readConfigFileFromEnvironment(
-    environment,
-    process.cwd(),
-  )
-  if (!persistedOptions) {
-    environment.error(
-      'There is no .cta.json file in your project.',
-      `This is probably because this was created with an older version of create-tsrouter-app.`,
-    )
-    process.exit(1)
-  }
-  return persistedOptions
-}