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

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

@@ -1,126 +0,0 @@
-import { readFile } from 'node:fs/promises'
-import { existsSync, writeFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-
-import { StarterCompiledSchema } from '../types.js'
-import { createIgnore } from '../file-helpers.js'
-import {
-  compareFilesRecursively,
-  createAppOptionsFromPersisted,
-  createPackageAdditions,
-  readCurrentProjectOptions,
-  runCreateApp,
-} from './shared.js'
-
-import type { PersistedOptions } from '../config-file'
-import type {
-  Environment,
-  Options,
-  Starter,
-  StarterCompiled,
-  StarterInfo,
-} from '../types'
-
-const INFO_FILE = 'starter-info.json'
-const COMPILED_FILE = 'starter.json'
-
-export async function readOrGenerateStarterInfo(
-  options: PersistedOptions,
-): Promise<StarterInfo> {
-  return existsSync(INFO_FILE)
-    ? JSON.parse((await readFile(INFO_FILE)).toString())
-    : {
-        id: `${options.projectName}-starter`,
-        name: `${options.projectName}-starter`,
-        version: '0.0.1',
-        description: 'Project starter',
-        author: 'Jane Smith <jane.smith@example.com>',
-        license: 'MIT',
-        link: `https://github.com/jane-smith/${options.projectName}-starter`,
-        shadcnComponents: [],
-        framework: options.framework,
-        mode: options.mode!,
-        routes: [],
-        warning: '',
-        type: 'starter',
-        packageAdditions: {
-          scripts: {},
-          dependencies: {},
-          devDependencies: {},
-        },
-        dependsOn: options.existingAddOns,
-        typescript: options.typescript!,
-        tailwind: options.tailwind!,
-      }
-}
-
-async function loadCurrentStarterInfo(environment: Environment) {
-  const persistedOptions = await readCurrentProjectOptions(environment)
-  const info = await readOrGenerateStarterInfo(persistedOptions)
-
-  const output = await runCreateApp(
-    (await createAppOptionsFromPersisted(
-      persistedOptions,
-    )) as Required<Options>,
-  )
-
-  return { info, output }
-}
-
-export async function updateStarterInfo(environment: Environment) {
-  const { info, output } = await loadCurrentStarterInfo(environment)
-
-  info.packageAdditions = createPackageAdditions(
-    JSON.parse(output.files['./package.json']),
-    JSON.parse((await readFile('package.json')).toString()),
-  )
-
-  writeFileSync(INFO_FILE, JSON.stringify(info, null, 2))
-}
-
-export async function compileStarter(environment: Environment) {
-  const { info, output } = await loadCurrentStarterInfo(environment)
-
-  const ignore = createIgnore(process.cwd())
-  const changedFiles: Record<string, string> = {}
-  await compareFilesRecursively('.', ignore, output.files, changedFiles)
-
-  const deletedFiles: Array<string> = []
-  for (const file of Object.keys(output.files)) {
-    if (!existsSync(resolve(process.cwd(), file))) {
-      deletedFiles.push(file)
-    }
-  }
-
-  const compiledInfo: StarterCompiled = {
-    ...info,
-    files: changedFiles,
-    deletedFiles,
-  }
-
-  writeFileSync(COMPILED_FILE, JSON.stringify(compiledInfo, null, 2))
-}
-
-export async function initStarter(environment: Environment) {
-  await updateStarterInfo(environment)
-  await compileStarter(environment)
-}
-
-export async function loadStarter(url: string): Promise<Starter> {
-  const response = await fetch(url)
-  const jsonContent = await response.json()
-
-  const checked = StarterCompiledSchema.safeParse(jsonContent)
-  if (!checked.success) {
-    throw new Error(`Invalid starter: ${url}`)
-  }
-
-  const starter = checked.data
-  starter.id = url
-  return {
-    ...starter,
-    getFiles: () => Promise.resolve(Object.keys(starter.files)),
-    getFileContents: (path: string) => Promise.resolve(starter.files[path]),
-    getDeletedFiles: () => Promise.resolve(starter.deletedFiles),
-  }
-}

package/src/file-helpers.ts

@@ -1,235 +0,0 @@
-import { readdir } from 'node:fs/promises'
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
-import { basename, extname, resolve } from 'node:path'
-import parseGitignore from 'parse-gitignore'
-import ignore from 'ignore'
-
-import type { Environment } from './types'
-
-const BINARY_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico']
-
-export function readFileHelper(path: string): string {
-  if (isBinaryFile(path)) {
-    return `base64::${readFileSync(path).toString('base64')}`
-  } else {
-    return readFileSync(path, 'utf-8').toString()
-  }
-}
-
-export function isBinaryFile(path: string): boolean {
-  return BINARY_EXTENSIONS.includes(extname(path))
-}
-
-export function convertBinaryContentsToBase64(contents: any): string {
-  return `base64::${Buffer.from(contents).toString('base64')}`
-}
-
-export function isBase64(content: string): boolean {
-  return content.startsWith('base64::')
-}
-
-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)
-    }
-  }
-}
-
-async function recursivelyGatherFilesHelper(
-  basePath: string,
-  path: string,
-  files: Record<string, string>,
-  ignore: (filePath: string) => boolean,
-) {
-  const dirFiles = await readdir(path, { withFileTypes: true })
-  for (const file of dirFiles) {
-    if (ignore(file.name)) {
-      continue
-    }
-    if (file.isDirectory()) {
-      await recursivelyGatherFilesHelper(
-        basePath,
-        resolve(path, file.name),
-        files,
-        ignore,
-      )
-    } else {
-      const filePath = resolve(path, file.name)
-      files[filePath.replace(basePath, '.')] = await readFileHelper(filePath)
-    }
-  }
-}
-
-export async function recursivelyGatherFiles(
-  path: string,
-  includeProjectFiles = true,
-) {
-  const ignore = createIgnore(path, includeProjectFiles)
-  const files: Record<string, string> = {}
-  await recursivelyGatherFilesHelper(path, path, files, ignore)
-  return files
-}
-
-async function recursivelyGatherFilesFromEnvironmentHelper(
-  environment: Environment,
-  basePath: string,
-  path: string,
-  files: Record<string, string>,
-  ignore: (filePath: string) => boolean,
-) {
-  const dirFiles = await environment.readdir(path)
-  for (const file of dirFiles) {
-    if (ignore(file)) {
-      continue
-    }
-    if (environment.isDirectory(resolve(path, file))) {
-      await recursivelyGatherFilesFromEnvironmentHelper(
-        environment,
-        basePath,
-        resolve(path, file),
-        files,
-        ignore,
-      )
-    } else {
-      const filePath = resolve(path, file)
-      files[filePath.replace(basePath, '.')] =
-        await environment.readFile(filePath)
-    }
-  }
-}
-
-export async function recursivelyGatherFilesFromEnvironment(
-  environment: Environment,
-  path: string,
-  includeProjectFiles = true,
-) {
-  const ignore = createIgnore(path, includeProjectFiles)
-  const files: Record<string, string> = {}
-  await recursivelyGatherFilesFromEnvironmentHelper(
-    environment,
-    path,
-    path,
-    files,
-    ignore,
-  )
-  return files
-}
-
-export const IGNORE_FILES = [
-  '.starter',
-  '.add-on',
-  '.cta.json',
-  '.git',
-  'add-on-info.json',
-  'add-on.json',
-  'build',
-  'bun.lock',
-  'bun.lockb',
-  'deno.lock',
-  'dist',
-  'node_modules',
-  'package-lock.json',
-  'pnpm-lock.yaml',
-  'starter.json',
-  'starter-info.json',
-  'yarn.lock',
-]
-
-const PROJECT_FILES = ['package.json']
-
-export function createIgnore(path: string, includeProjectFiles = true) {
-  const ignoreList = existsSync(resolve(path, '.gitignore'))
-    ? (
-        parseGitignore(
-          readFileSync(resolve(path, '.gitignore')),
-        ) as unknown as { patterns: Array<string> }
-      ).patterns
-    : []
-  const ig = ignore().add(ignoreList)
-  return (filePath: string) => {
-    const fileName = basename(filePath)
-    if (
-      IGNORE_FILES.includes(fileName) ||
-      (includeProjectFiles && PROJECT_FILES.includes(fileName))
-    ) {
-      return true
-    }
-    const nameWithoutDotSlash = fileName.replace(/^\.\//, '')
-    return ig.ignores(nameWithoutDotSlash)
-  }
-}
-
-export function cleanUpFiles(
-  files: Record<string, string>,
-  targetDir?: string,
-) {
-  return Object.keys(files).reduce<Record<string, string>>((acc, file) => {
-    if (basename(file) !== '.cta.json') {
-      acc[targetDir ? file.replace(targetDir, '.') : file] = files[file]
-    }
-    return acc
-  }, {})
-}
-
-export function cleanUpFileArray(files: Array<string>, targetDir?: string) {
-  return files.reduce<Array<string>>((acc, file) => {
-    if (basename(file) !== '.cta.json') {
-      acc.push(targetDir ? file.replace(targetDir, '.') : file)
-    }
-    return acc
-  }, [])
-}

package/src/frameworks.ts

@@ -1,134 +0,0 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs'
-import { resolve } from 'node:path'
-
-import {
-  findFilesRecursively,
-  isDirectory,
-  readFileHelper,
-} from './file-helpers.js'
-
-import type { AddOn, Framework, FrameworkDefinition } from './types.js'
-
-const frameworks: Array<Framework> = []
-
-function getAddOns(framework: FrameworkDefinition) {
-  const addOns: Array<AddOn> = []
-
-  for (const addOnsBase of framework.addOnsDirectories) {
-    for (const dir of readdirSync(addOnsBase).filter((file) =>
-      isDirectory(resolve(addOnsBase, file)),
-    )) {
-      const filePath = resolve(addOnsBase, dir, 'info.json')
-      const fileContent = readFileSync(filePath, 'utf-8')
-      const info = JSON.parse(fileContent)
-
-      let packageAdditions: Record<string, string> = {}
-      if (existsSync(resolve(addOnsBase, dir, 'package.json'))) {
-        packageAdditions = JSON.parse(
-          readFileSync(resolve(addOnsBase, dir, 'package.json'), 'utf-8'),
-        )
-      }
-
-      let readme: string | undefined
-      if (existsSync(resolve(addOnsBase, dir, 'README.md'))) {
-        readme = readFileSync(resolve(addOnsBase, dir, 'README.md'), 'utf-8')
-      }
-
-      let smallLogo: string | undefined
-      if (existsSync(resolve(addOnsBase, dir, 'small-logo.svg'))) {
-        smallLogo = readFileSync(
-          resolve(addOnsBase, dir, 'small-logo.svg'),
-          'utf-8',
-        )
-      }
-
-      const absoluteFiles: Record<string, string> = {}
-      const assetsDir = resolve(addOnsBase, dir, 'assets')
-      if (existsSync(assetsDir)) {
-        findFilesRecursively(assetsDir, absoluteFiles)
-      }
-      const files: Record<string, string> = {}
-      for (const file of Object.keys(absoluteFiles)) {
-        files[file.replace(assetsDir, '.')] = readFileHelper(file)
-      }
-
-      const getFiles = () => {
-        return Promise.resolve(Object.keys(files))
-      }
-      const getFileContents = (path: string) => {
-        return Promise.resolve(files[path])
-      }
-
-      addOns.push({
-        ...info,
-        id: dir,
-        packageAdditions,
-        readme,
-        files,
-        smallLogo,
-        getFiles,
-        getFileContents,
-        getDeletedFiles: () => Promise.resolve(info.deletedFiles ?? []),
-      })
-    }
-  }
-
-  return addOns
-}
-
-export function __testRegisterFramework(framework: Framework) {
-  frameworks.push(framework)
-}
-
-export function __testClearFrameworks() {
-  frameworks.length = 0
-}
-
-export function registerFramework(framework: FrameworkDefinition) {
-  const baseAssetsDirectory = resolve(framework.baseDirectory, 'base')
-
-  const basePackageJSON = JSON.parse(
-    readFileSync(resolve(baseAssetsDirectory, 'package.json'), 'utf8'),
-  )
-  const optionalPackages = JSON.parse(
-    readFileSync(resolve(framework.baseDirectory, 'packages.json'), 'utf8'),
-  )
-
-  const addOns = getAddOns(framework)
-
-  const frameworkWithBundler: Framework = {
-    ...framework,
-    getFiles: () => {
-      const files: Record<string, string> = {}
-      findFilesRecursively(baseAssetsDirectory, files)
-      return Promise.resolve(
-        Object.keys(files).map((path) =>
-          path.replace(baseAssetsDirectory, '.'),
-        ),
-      )
-    },
-    getFileContents: (path: string) => {
-      return Promise.resolve(readFileHelper(resolve(baseAssetsDirectory, path)))
-    },
-    getDeletedFiles: () => {
-      return Promise.resolve([])
-    },
-    basePackageJSON,
-    optionalPackages,
-    getAddOns: () => addOns,
-  }
-
-  frameworks.push(frameworkWithBundler)
-}
-
-export function getFrameworkById(id: string) {
-  return frameworks.find((framework) => framework.id === id)
-}
-
-export function getFrameworkByName(name: string) {
-  return frameworks.find((framework) => framework.name === name)
-}
-
-export function getFrameworks() {
-  return frameworks
-}

package/src/integrations/git.ts

@@ -1,7 +0,0 @@
-import { resolve } from 'node:path'
-
-import type { Environment } from '../types.js'
-
-export async function setupGit(environment: Environment, targetDir: string) {
-  await environment.execute('git', ['init'], resolve(targetDir))
-}

package/src/integrations/shadcn.ts

@@ -1,54 +0,0 @@
-import { resolve } from 'node:path'
-import { packageManagerExecute } from '../package-manager.js'
-import type { Environment, Options } from '../types.js'
-
-export async function installShadcnComponents(
-  environment: Environment,
-  targetDir: string,
-  options: Options,
-) {
-  const s = environment.spinner()
-
-  if (options.chosenAddOns.find((a) => a.id === 'shadcn')) {
-    const shadcnComponents = new Set<string>()
-    for (const addOn of options.chosenAddOns) {
-      if (addOn.shadcnComponents) {
-        for (const component of addOn.shadcnComponents) {
-          shadcnComponents.add(component)
-        }
-      }
-    }
-    if (options.starter) {
-      if (options.starter.shadcnComponents) {
-        for (const component of options.starter.shadcnComponents) {
-          shadcnComponents.add(component)
-        }
-      }
-    }
-
-    if (shadcnComponents.size > 0) {
-      s.start(
-        `Installing shadcn components (${Array.from(shadcnComponents).join(', ')})...`,
-      )
-      environment.startStep({
-        id: 'install-shadcn-components',
-        type: 'command',
-        message: `Installing shadcn components (${Array.from(shadcnComponents).join(', ')})...`,
-      })
-
-      await packageManagerExecute(
-        environment,
-        resolve(targetDir),
-        options.packageManager,
-        'shadcn@latest',
-        ['add', '--silent', '--yes', ...Array.from(shadcnComponents)],
-      )
-
-      environment.finishStep(
-        'install-shadcn-components',
-        'Shadcn components installed',
-      )
-      s.stop(`Installed additional shadcn components`)
-    }
-  }
-}

package/src/package-json.ts

@@ -1,69 +0,0 @@
-import { FILE_ROUTER } from './constants.js'
-import { sortObject } from './utils.js'
-
-import type { Options } from './types.js'
-
-export function mergePackageJSON(
-  packageJSON: Record<string, any>,
-  overlayPackageJSON?: Record<string, any>,
-) {
-  return {
-    ...packageJSON,
-    dependencies: {
-      ...packageJSON.dependencies,
-      ...(overlayPackageJSON?.dependencies || {}),
-    },
-    devDependencies: {
-      ...packageJSON.devDependencies,
-      ...(overlayPackageJSON?.devDependencies || {}),
-    },
-    scripts: {
-      ...packageJSON.scripts,
-      ...(overlayPackageJSON?.scripts || {}),
-    },
-  }
-}
-
-export function createPackageJSON(options: Options) {
-  let packageJSON = {
-    ...JSON.parse(JSON.stringify(options.framework.basePackageJSON)),
-    name: options.projectName,
-  }
-
-  const additions: Array<Record<string, any> | undefined> = [
-    options.typescript
-      ? options.framework.optionalPackages.typescript
-      : undefined,
-    options.tailwind
-      ? options.framework.optionalPackages.tailwindcss
-      : undefined,
-    options.mode === FILE_ROUTER
-      ? options.framework.optionalPackages['file-router']
-      : undefined,
-  ]
-  for (const addition of additions.filter(Boolean)) {
-    packageJSON = mergePackageJSON(packageJSON, addition)
-  }
-
-  for (const addOn of options.chosenAddOns.map(
-    (addOn) => addOn.packageAdditions,
-  )) {
-    packageJSON = mergePackageJSON(packageJSON, addOn)
-  }
-
-  if (options.starter) {
-    packageJSON = mergePackageJSON(
-      packageJSON,
-      options.starter.packageAdditions,
-    )
-  }
-
-  packageJSON.dependencies = sortObject(
-    (packageJSON.dependencies ?? {}) as Record<string, string>,
-  )
-  packageJSON.devDependencies = sortObject(
-    (packageJSON.devDependencies ?? {}) as Record<string, string>,
-  )
-
-  return packageJSON
-}

package/src/special-steps/index.ts

@@ -1,36 +0,0 @@
-import { rimrafNodeModules } from './rimraf-node-modules.js'
-
-import type { Environment, Options } from '../types.js'
-
-const specialStepsLookup: Record<
-  string,
-  (environment: Environment, options: Options) => Promise<void>
-> = {
-  'rimraf-node-modules': rimrafNodeModules,
-}
-
-export async function runSpecialSteps(
-  environment: Environment,
-  options: Options,
-  specialSteps: Array<string>,
-) {
-  if (specialSteps.length) {
-    environment.startStep({
-      id: 'special-steps',
-      type: 'command',
-      message: 'Removing node_modules...',
-    })
-
-    for (const step of specialSteps) {
-      const stepFunction = specialStepsLookup[step]
-      /* eslint-disable @typescript-eslint/no-unnecessary-condition */
-      if (stepFunction) {
-        await stepFunction(environment, options)
-      } else {
-        environment.error(`Special step ${step} not found`)
-      }
-    }
-
-    environment.finishStep('special-steps', 'Special steps complete')
-  }
-}

package/src/special-steps/rimraf-node-modules.ts

@@ -1,25 +0,0 @@
-import { resolve } from 'node:path'
-
-import type { Environment, Options } from '../types.js'
-
-const lockFiles = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml']
-
-export async function rimrafNodeModules(
-  environment: Environment,
-  options: Options,
-) {
-  environment.startStep({
-    id: 'special-steps',
-    type: 'command',
-    message: 'Removing node_modules...',
-  })
-
-  await environment.rimraf(resolve(options.targetDir, 'node_modules'))
-
-  for (const lockFile of lockFiles) {
-    const lockFilePath = resolve(options.targetDir, lockFile)
-    if (environment.exists(lockFilePath)) {
-      await environment.deleteFile(lockFilePath)
-    }
-  }
-}