@tanstack/create 0.68.2 → 0.68.3

package/src/edge-environment.ts

@@ -0,0 +1,175 @@
+import { cleanUpFileArray, cleanUpFiles } from './edge-file-helpers.js'
+import {
+  basenamePath,
+  dirnamePath,
+  joinPaths,
+  normalizePath,
+} from './edge-path.js'
+
+import type { Environment } from './types.js'
+
+export interface MemoryEnvironmentOutput {
+  files: Record<string, string>
+  deletedFiles: Array<string>
+  commands: Array<{ command: string; args: Array<string> }>
+}
+
+function hasDirectory(files: Record<string, string>, path: string) {
+  const directory = normalizePath(path)
+  const prefix = directory.endsWith('/') ? directory : `${directory}/`
+  return Object.keys(files).some((file) => file.startsWith(prefix))
+}
+
+function createMissingDirectoryError(path: string) {
+  return new Error(`Directory not found: ${path}`)
+}
+
+export function createMemoryEnvironment(returnPathsRelativeTo: string = '') {
+  const output: MemoryEnvironmentOutput = {
+    files: {},
+    commands: [],
+    deletedFiles: [],
+  }
+  const files: Record<string, string> = {}
+  let errors: Array<string> = []
+
+  const environment: Environment = {
+    startRun: () => {
+      errors = []
+      output.files = {}
+      output.commands = []
+      output.deletedFiles = []
+    },
+    finishRun: () => {
+      output.files = Object.keys(files).reduce<Record<string, string>>(
+        (acc, file) => {
+          acc[file] = files[file]
+          return acc
+        },
+        {},
+      )
+
+      if (returnPathsRelativeTo.length) {
+        output.files = cleanUpFiles(output.files, returnPathsRelativeTo)
+        output.deletedFiles = cleanUpFileArray(
+          output.deletedFiles,
+          returnPathsRelativeTo,
+        )
+      }
+    },
+    getErrors: () => errors,
+
+    appendFile: (path: string, contents: string) => {
+      const normalized = normalizePath(path)
+      files[normalized] = `${files[normalized] ?? ''}${contents}`
+      return Promise.resolve()
+    },
+    copyFile: (from: string, to: string) => {
+      const normalizedFrom = normalizePath(from)
+      const normalizedTo = normalizePath(to)
+      if (!(normalizedFrom in files)) {
+        throw new Error(`File not found: ${from}`)
+      }
+      files[normalizedTo] = files[normalizedFrom]
+      return Promise.resolve()
+    },
+    writeFile: (path: string, contents: string) => {
+      files[normalizePath(path)] = contents
+      return Promise.resolve()
+    },
+    writeFileBase64: (path: string, base64Contents: string) => {
+      files[normalizePath(path)] = base64Contents
+      return Promise.resolve()
+    },
+    execute: (command: string, args: Array<string>) => {
+      output.commands.push({
+        command,
+        args,
+      })
+      return Promise.resolve({ stdout: '' })
+    },
+    deleteFile: (path: string) => {
+      const normalized = normalizePath(path)
+      output.deletedFiles.push(normalized)
+      delete files[normalized]
+      return Promise.resolve()
+    },
+
+    exists: (path: string) => {
+      const normalized = normalizePath(path)
+      return normalized in files || hasDirectory(files, normalized)
+    },
+    isDirectory: (path: string) => hasDirectory(files, path),
+    readFile: (path: string) => {
+      const normalized = normalizePath(path)
+      if (!(normalized in files)) {
+        throw new Error(`File not found: ${path}`)
+      }
+      return Promise.resolve(files[normalized])
+    },
+    readdir: (path: string) => {
+      const normalized = normalizePath(path)
+      const directory = normalized === '.' ? '' : normalized
+      const prefix = directory ? `${directory}/` : ''
+
+      if (directory && !hasDirectory(files, directory)) {
+        throw createMissingDirectoryError(path)
+      }
+
+      const entries = new Set<string>()
+      for (const file of Object.keys(files)) {
+        if (!file.startsWith(prefix)) {
+          continue
+        }
+
+        const rest = file.slice(prefix.length)
+        const entry = rest.split('/')[0]
+        if (entry) {
+          entries.add(entry)
+        }
+      }
+
+      return Promise.resolve(Array.from(entries))
+    },
+    rimraf: (path: string) => {
+      const normalized = normalizePath(path)
+      const prefix = normalized.endsWith('/') ? normalized : `${normalized}/`
+      for (const file of Object.keys(files)) {
+        if (file === normalized || file.startsWith(prefix)) {
+          delete files[file]
+        }
+      }
+      return Promise.resolve()
+    },
+
+    appName: 'TanStack',
+
+    startStep: () => {},
+    finishStep: () => {},
+
+    intro: () => {},
+    outro: () => {},
+    info: () => {},
+    error: (_title?: string, message?: string) => {
+      if (message) {
+        errors.push(message)
+      }
+    },
+    warn: () => {},
+    confirm: () => Promise.resolve(true),
+    spinner: () => ({
+      start: () => {},
+      stop: () => {},
+    }),
+  }
+
+  return {
+    environment,
+    output,
+    paths: {
+      basename: basenamePath,
+      dirname: dirnamePath,
+      join: joinPaths,
+    },
+  }
+}

package/src/edge-file-helpers.ts

@@ -0,0 +1,112 @@
+import { basenamePath, extnamePath } from './edge-path.js'
+import { hasDrive, stripDrive } from './utils.js'
+
+const BINARY_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico']
+
+export function isBinaryFile(path: string): boolean {
+  return BINARY_EXTENSIONS.includes(extnamePath(path))
+}
+
+export function isBase64(content: string): boolean {
+  return content.startsWith('base64::')
+}
+
+export function toCleanPath(absolutePath: string, baseDir: string): string {
+  const normalizedPath = absolutePath.replace(/\\/g, '/')
+  const normalizedBase = baseDir.replace(/\\/g, '/')
+  let cleanPath = normalizedPath
+  if (normalizedPath.startsWith(normalizedBase)) {
+    cleanPath = normalizedPath.slice(normalizedBase.length)
+  } else if (hasDrive(normalizedPath) !== hasDrive(normalizedBase)) {
+    const pathNoDrive = stripDrive(normalizedPath)
+    const baseNoDrive = stripDrive(normalizedBase)
+    if (pathNoDrive.startsWith(baseNoDrive)) {
+      cleanPath = pathNoDrive.slice(baseNoDrive.length)
+    }
+  }
+  if (cleanPath.startsWith('/')) {
+    cleanPath = cleanPath.slice(1)
+  }
+  return cleanPath
+}
+
+export function relativePath(
+  from: string,
+  to: string,
+  stripExtension: boolean = false,
+) {
+  const normalized = from.replace(/\\/g, '/')
+  const cleanedFrom = normalized.startsWith('./')
+    ? normalized.slice(2)
+    : normalized
+  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)
+  const target = stripExtension ? to.replace(extnamePath(to), '') : to
+
+  if (upLevels === 0 && downLevels.length === 0) {
+    return `./${basenamePath(target)}`
+  } else if (upLevels === 0 && downLevels.length > 0) {
+    return `./${downLevels.join('/')}/${basenamePath(target)}`
+  } else {
+    const relative = [...Array(upLevels).fill('..'), ...downLevels].join('/')
+    return `${relative}/${basenamePath(target)}`
+  }
+}
+
+export function isDemoFilePath(path?: string): boolean {
+  if (!path) return false
+  const normalized = path.replace(/\\/g, '/')
+
+  if (
+    normalized.includes('/routes/demo/') ||
+    normalized.includes('/routes/example/')
+  ) {
+    return true
+  }
+
+  const filename = normalized.split('/').pop() || ''
+  return (
+    filename.startsWith('demo.') ||
+    filename.startsWith('demo-') ||
+    filename.startsWith('example.') ||
+    filename.startsWith('example-')
+  )
+}
+
+export function cleanUpFiles(
+  files: Record<string, string>,
+  targetDir?: string,
+) {
+  return Object.keys(files).reduce<Record<string, string>>((acc, file) => {
+    if (basenamePath(file) !== '.cta.json') {
+      acc[targetDir ? toCleanPath(file, targetDir) : file] = files[file]
+    }
+    return acc
+  }, {})
+}
+
+export function cleanUpFileArray(files: Array<string>, targetDir?: string) {
+  return files.reduce<Array<string>>((acc, file) => {
+    if (basenamePath(file) !== '.cta.json') {
+      acc.push(targetDir ? toCleanPath(file, targetDir) : file)
+    }
+    return acc
+  }, [])
+}

package/src/edge-frameworks.ts

@@ -0,0 +1,54 @@
+import { createManifestFrameworks } from './generated/create-manifest.js'
+
+import type {
+  AddOn,
+  AddOnCompiled,
+  Framework,
+  FrameworkDefinition,
+} from './types.js'
+
+function createAddOn(addOn: AddOnCompiled): AddOn {
+  return {
+    ...addOn,
+    getFiles: () => Promise.resolve(Object.keys(addOn.files)),
+    getFileContents: (path: string) => Promise.resolve(addOn.files[path]),
+    getDeletedFiles: () => Promise.resolve(addOn.deletedFiles),
+  }
+}
+
+export function createFrameworkFromManifest(
+  framework: Omit<FrameworkDefinition, 'addOns'> & {
+    addOns: Array<AddOnCompiled>
+  },
+): Framework {
+  const addOns = framework.addOns.map(createAddOn)
+  const { addOns: _addOns, base, ...rest } = framework
+
+  return {
+    ...rest,
+    getFiles: () => Promise.resolve(Object.keys(base)),
+    getFileContents: (path: string) => Promise.resolve(base[path]),
+    getDeletedFiles: () => Promise.resolve([]),
+    getAddOns: () => addOns,
+  }
+}
+
+const frameworks = createManifestFrameworks().map(createFrameworkFromManifest)
+
+export function getFrameworkById(id: string) {
+  if (id === 'react-cra') {
+    return frameworks.find((framework) => framework.id === 'react')
+  }
+
+  return frameworks.find((framework) => framework.id === id)
+}
+
+export function getFrameworkByName(name: string) {
+  return frameworks.find(
+    (framework) => framework.name.toLowerCase() === name.toLowerCase(),
+  )
+}
+
+export function getFrameworks() {
+  return frameworks
+}

package/src/edge-package-json.ts

@@ -0,0 +1,212 @@
+import { render } from './edge-render.js'
+import { formatCommand, sortObject } from './utils.js'
+import { getPackageManagerExecuteCommand } from './package-manager.js'
+
+import type { Options } from './types.js'
+
+export function mergePackageJSON(
+  packageJSON: Record<string, unknown>,
+  overlayPackageJSON?: Record<string, unknown>,
+) {
+  const packageDependencies =
+    packageJSON.dependencies && typeof packageJSON.dependencies === 'object'
+      ? (packageJSON.dependencies as Record<string, string>)
+      : {}
+  const overlayDependencies =
+    overlayPackageJSON?.dependencies &&
+    typeof overlayPackageJSON.dependencies === 'object'
+      ? (overlayPackageJSON.dependencies as Record<string, string>)
+      : {}
+  const packageDevDependencies =
+    packageJSON.devDependencies && typeof packageJSON.devDependencies === 'object'
+      ? (packageJSON.devDependencies as Record<string, string>)
+      : {}
+  const overlayDevDependencies =
+    overlayPackageJSON?.devDependencies &&
+    typeof overlayPackageJSON.devDependencies === 'object'
+      ? (overlayPackageJSON.devDependencies as Record<string, string>)
+      : {}
+  const packageScripts =
+    packageJSON.scripts && typeof packageJSON.scripts === 'object'
+      ? (packageJSON.scripts as Record<string, string>)
+      : {}
+  const overlayScripts =
+    overlayPackageJSON?.scripts && typeof overlayPackageJSON.scripts === 'object'
+      ? (overlayPackageJSON.scripts as Record<string, string>)
+      : {}
+
+  const mergedPackageJSON: Record<string, unknown> = {
+    ...packageJSON,
+    ...(overlayPackageJSON || {}),
+    dependencies: {
+      ...packageDependencies,
+      ...overlayDependencies,
+    },
+    devDependencies: {
+      ...packageDevDependencies,
+      ...overlayDevDependencies,
+    },
+    scripts: {
+      ...packageScripts,
+      ...overlayScripts,
+    },
+  }
+
+  const packagePnpm =
+    packageJSON.pnpm && typeof packageJSON.pnpm === 'object'
+      ? (packageJSON.pnpm as Record<string, unknown>)
+      : undefined
+  const overlayPnpm =
+    overlayPackageJSON?.pnpm && typeof overlayPackageJSON.pnpm === 'object'
+      ? (overlayPackageJSON.pnpm as Record<string, unknown>)
+      : undefined
+
+  const baseOnlyBuiltDependencies = Array.isArray(
+    packagePnpm?.onlyBuiltDependencies,
+  )
+    ? packagePnpm.onlyBuiltDependencies
+    : []
+  const overlayOnlyBuiltDependencies = Array.isArray(
+    overlayPnpm?.onlyBuiltDependencies,
+  )
+    ? overlayPnpm.onlyBuiltDependencies
+    : []
+
+  const onlyBuiltDependencies = [
+    ...new Set([
+      ...baseOnlyBuiltDependencies,
+      ...overlayOnlyBuiltDependencies,
+    ]),
+  ]
+
+  if (packagePnpm || overlayPnpm) {
+    mergedPackageJSON.pnpm = {
+      ...packagePnpm,
+      ...overlayPnpm,
+    }
+
+    if (onlyBuiltDependencies.length) {
+      const mergedPnpm = mergedPackageJSON.pnpm as Record<string, unknown>
+      mergedPnpm.onlyBuiltDependencies = onlyBuiltDependencies
+    }
+  }
+
+  return mergedPackageJSON
+}
+
+export function createPackageJSON(options: Options) {
+  const packageManager = options.packageManager
+
+  function getPackageManagerExecuteScript(
+    pkg: string,
+    args: Array<string> = [],
+  ) {
+    return formatCommand(getPackageManagerExecuteCommand(packageManager, pkg, args))
+  }
+
+  let packageJSON: Record<string, unknown> = {
+    ...(JSON.parse(
+      JSON.stringify(options.framework.basePackageJSON),
+    ) as Record<string, unknown>),
+    name: options.projectName,
+  }
+
+  const additions: Array<Record<string, unknown> | undefined> = [
+    options.framework.optionalPackages.typescript,
+    options.framework.optionalPackages.tailwindcss,
+    options.mode ? options.framework.optionalPackages[options.mode] : undefined,
+  ]
+  for (const addition of additions.filter(
+    (addition): addition is Record<string, unknown> => Boolean(addition),
+  )) {
+    packageJSON = mergePackageJSON(packageJSON, addition)
+  }
+
+  for (const addOn of options.chosenAddOns) {
+    let addOnPackageJSON = addOn.packageAdditions as
+      | Record<string, unknown>
+      | undefined
+
+    if (addOn.packageTemplate) {
+      const templateValues = {
+        packageManager: options.packageManager,
+        projectName: options.projectName,
+        typescript: true,
+        tailwind: true,
+        js: 'ts',
+        jsx: 'tsx',
+        fileRouter: options.mode === 'file-router',
+        codeRouter: options.mode === 'code-router',
+        routerOnly: options.routerOnly === true,
+        addOnEnabled: options.chosenAddOns.reduce<Record<string, boolean>>(
+          (acc, addon) => {
+            acc[addon.id] = true
+            return acc
+          },
+          {},
+        ),
+        addOnOption: options.addOnOptions,
+        addOns: options.chosenAddOns,
+        getPackageManagerExecuteScript,
+      }
+
+      try {
+        addOnPackageJSON = JSON.parse(render(addOn.packageTemplate, templateValues))
+      } catch (error) {
+        console.error(
+          `Error processing package.json.ejs for add-on ${addOn.id}:`,
+          error,
+        )
+      }
+    }
+
+    packageJSON = mergePackageJSON(packageJSON, addOnPackageJSON)
+  }
+
+  if (options.starter) {
+    packageJSON = mergePackageJSON(
+      packageJSON,
+      options.starter.packageAdditions as Record<string, unknown> | undefined,
+    )
+  }
+
+  const dependencies = packageJSON.dependencies as
+    | Record<string, string>
+    | undefined
+  const devDependencies = packageJSON.devDependencies as
+    | Record<string, string>
+    | undefined
+  const scripts = packageJSON.scripts as Record<string, string> | undefined
+
+  if (options.routerOnly) {
+    if (options.framework.id === 'react') {
+      delete dependencies?.['@tanstack/react-start']
+      delete dependencies?.['@tanstack/react-router-ssr-query']
+      packageJSON.devDependencies = {
+        ...(devDependencies ?? {}),
+        '@tanstack/router-plugin':
+          devDependencies?.['@tanstack/router-plugin'] ?? 'latest',
+      }
+    }
+
+    if (options.framework.id === 'solid') {
+      delete dependencies?.['@tanstack/solid-start']
+      delete dependencies?.['@tanstack/solid-router-ssr-query']
+      delete scripts?.start
+      packageJSON.devDependencies = {
+        ...(devDependencies ?? {}),
+        '@tanstack/router-plugin':
+          devDependencies?.['@tanstack/router-plugin'] ?? 'latest',
+      }
+    }
+  }
+
+  packageJSON.dependencies = sortObject(
+    (packageJSON.dependencies ?? {}) as Record<string, string>,
+  )
+  packageJSON.devDependencies = sortObject(
+    (packageJSON.devDependencies ?? {}) as Record<string, string>,
+  )
+
+  return packageJSON
+}

package/src/edge-path.ts

@@ -0,0 +1,77 @@
+export function normalizePath(path: string): string {
+  const normalized = path.replace(/\\/g, '/')
+  const isAbsolute = normalized.startsWith('/')
+  const parts: Array<string> = []
+
+  for (const part of normalized.split('/')) {
+    if (!part || part === '.') {
+      continue
+    }
+    if (part === '..') {
+      if (parts.length && parts[parts.length - 1] !== '..') {
+        parts.pop()
+      } else if (!isAbsolute) {
+        parts.push(part)
+      }
+      continue
+    }
+    parts.push(part)
+  }
+
+  const joined = parts.join('/')
+  if (isAbsolute) {
+    return joined ? `/${joined}` : '/'
+  }
+
+  return joined || '.'
+}
+
+export function joinPaths(...paths: Array<string | undefined>): string {
+  const filtered = paths.filter(
+    (path): path is string => typeof path === 'string' && path.length > 0,
+  )
+  if (!filtered.length) {
+    return '.'
+  }
+
+  return normalizePath(filtered.join('/'))
+}
+
+export function basenamePath(path: string): string {
+  const normalized = normalizePath(path)
+  if (normalized === '/') {
+    return ''
+  }
+
+  return normalized.split('/').pop() ?? ''
+}
+
+export function dirnamePath(path: string): string {
+  const normalized = normalizePath(path)
+  if (normalized === '/') {
+    return '/'
+  }
+
+  const parts = normalized.split('/')
+  parts.pop()
+
+  if (!parts.length) {
+    return '.'
+  }
+
+  if (parts.length === 1 && parts[0] === '') {
+    return '/'
+  }
+
+  return parts.join('/') || '.'
+}
+
+export function extnamePath(path: string): string {
+  const basename = basenamePath(path)
+  const index = basename.lastIndexOf('.')
+  if (index <= 0) {
+    return ''
+  }
+
+  return basename.slice(index)
+}

package/src/edge-render.ts

@@ -0,0 +1,32 @@
+import { renderManifestTemplate } from './generated/create-manifest.js'
+
+export function render(template: string, data?: Record<string, any>) {
+  return renderManifestTemplate(template, {
+    packageManager: undefined,
+    projectName: undefined,
+    typescript: undefined,
+    tailwind: undefined,
+    js: undefined,
+    jsx: undefined,
+    fileRouter: undefined,
+    codeRouter: undefined,
+    routerOnly: undefined,
+    includeExamples: undefined,
+    addOnEnabled: {},
+    addOnOption: {},
+    addOns: [],
+    integrations: [],
+    routes: [],
+    getPackageManagerAddScript: () => '',
+    getPackageManagerRunScript: () => '',
+    getPackageManagerExecuteScript: () => '',
+    relativePath: () => '',
+    integrationImportContent: () => '',
+    integrationImportCode: () => '',
+    renderTemplate: () => '',
+    ignoreFile: () => {
+      throw new Error('ignoreFile')
+    },
+    ...(data ?? {}),
+  })
+}