@tanstack/cli 0.61.1 → 0.62.1

package/tests/options.test.ts

@@ -1,281 +0,0 @@
-import { beforeEach, describe, it, expect, vi } from 'vitest'
-
-import { promptForCreateOptions } from '../src/options'
-import {
-  __testClearFrameworks,
-  __testRegisterFramework,
-} from '@tanstack/create'
-import * as create from '@tanstack/create'
-
-import * as prompts from '../src/ui-prompts'
-import * as commandLine from '../src/command-line'
-
-import type { Framework } from '@tanstack/create'
-
-import type { CliOptions } from '../src/types'
-
-vi.mock('../src/ui-prompts')
-vi.mock('../src/command-line')
-
-beforeEach(() => {
-  __testClearFrameworks()
-  __testRegisterFramework({
-    id: 'react',
-    name: 'react',
-    getAddOns: () => [
-      {
-        id: 'react-query',
-        type: 'add-on',
-        modes: ['file-router'],
-      },
-      {
-        id: 'tanstack-chat',
-        type: 'add-on',
-        modes: ['file-router'],
-      },
-      {
-        id: 'biome',
-        type: 'toolchain',
-        modes: ['file-router'],
-      },
-    ],
-    supportedModes: {
-      'file-router': {
-        displayName: 'File Router',
-        description: 'TanStack Start with file-based routing',
-        forceTypescript: true,
-      },
-    },
-  } as unknown as Framework)
-
-  __testRegisterFramework({
-    id: 'solid',
-    name: 'solid',
-    getAddOns: () => [],
-  } as unknown as Framework)
-})
-
-const baseCliOptions: CliOptions = {
-  framework: 'react',
-  addOns: [],
-  toolchain: undefined,
-  projectName: undefined,
-  git: undefined,
-}
-
-function setBasicSpies() {
-  vi.spyOn(commandLine, 'listTemplateChoices').mockImplementation(async () => [])
-  vi
-    .spyOn(commandLine, 'resolveStarterSpecifier')
-    .mockImplementation(async (value) =>
-      value === 'blog'
-        ? 'https://example.com/react/blog/starter.json'
-        : value,
-    )
-  vi.spyOn(create, 'loadStarter').mockImplementation(
-    async (id) =>
-      ({
-        id: String(id),
-        name: 'Blog',
-        description: 'Blog template',
-        type: 'starter',
-        framework: 'react',
-        mode: 'file-router',
-        typescript: true,
-        dependsOn: [],
-        files: {},
-        deletedFiles: [],
-      }) as any,
-  )
-  vi.spyOn(prompts, 'getProjectName').mockImplementation(async () => 'hello')
-  vi.spyOn(prompts, 'selectTemplate').mockImplementation(async () => undefined)
-  vi.spyOn(prompts, 'selectPackageManager').mockImplementation(
-    async () => 'npm',
-  )
-  vi.spyOn(prompts, 'selectToolchain').mockImplementation(async () => undefined)
-  vi.spyOn(prompts, 'selectAddOns').mockImplementation(async () => [])
-}
-
-describe('promptForCreateOptions', () => {
-  //// Project name
-
-  it('prompt for a project name', async () => {
-    setBasicSpies()
-
-    const options = await promptForCreateOptions(baseCliOptions, {})
-
-    expect(options?.projectName).toBe('hello')
-  })
-
-  it('accept incoming project name', async () => {
-    setBasicSpies()
-
-    const options = await promptForCreateOptions(
-      { ...baseCliOptions, projectName: 'override' },
-      {},
-    )
-
-    expect(options?.projectName).toBe('override')
-  })
-
-  //// Mode is always file-router (TanStack Start)
-
-  it('mode should always be file-router', async () => {
-    setBasicSpies()
-
-    const options = await promptForCreateOptions(baseCliOptions, {})
-
-    expect(options?.mode).toBe('file-router')
-    expect(options?.typescript).toBe(true)
-  })
-
-  //// Tailwind is always enabled
-
-  it('tailwind is always enabled', async () => {
-    setBasicSpies()
-    const options = await promptForCreateOptions(baseCliOptions, {})
-
-    expect(options?.tailwind).toBe(true)
-  })
-
-  it('prompts for templates when none was provided', async () => {
-    setBasicSpies()
-    vi.spyOn(commandLine, 'listTemplateChoices').mockImplementation(async () => [
-      {
-        id: 'blog',
-        name: 'Blog',
-        description: 'Blog template',
-        framework: 'react',
-      },
-    ])
-
-    await promptForCreateOptions(baseCliOptions, {})
-
-    expect(prompts.selectTemplate).toHaveBeenCalledWith([
-      {
-        id: 'blog',
-        name: 'Blog',
-        description: 'Blog template',
-      },
-    ])
-  })
-
-  it('skips template prompt when template was provided via CLI', async () => {
-    setBasicSpies()
-
-    await promptForCreateOptions({ ...baseCliOptions, template: 'blog' }, {})
-
-    expect(prompts.selectTemplate).not.toHaveBeenCalled()
-  })
-
-  it('skips template prompt in router-only mode', async () => {
-    setBasicSpies()
-
-    await promptForCreateOptions({ ...baseCliOptions, routerOnly: true }, {})
-
-    expect(prompts.selectTemplate).not.toHaveBeenCalled()
-  })
-
-  //// Package manager
-
-  it('uses the package manager from the cli options', async () => {
-    setBasicSpies()
-
-    const options = await promptForCreateOptions(
-      { ...baseCliOptions, packageManager: 'bun' },
-      {},
-    )
-
-    expect(options?.packageManager).toBe('bun')
-  })
-
-  it('detects package manager from environment', async () => {
-    setBasicSpies()
-
-    process.env.npm_config_userconfig = 'blarg'
-
-    const options = await promptForCreateOptions(
-      { ...baseCliOptions, packageManager: undefined },
-      {},
-    )
-
-    expect(options?.packageManager).toBe('pnpm')
-  })
-
-  //// Add-ons
-  it('should be clean when no add-ons are selected', async () => {
-    setBasicSpies()
-
-    const options = await promptForCreateOptions({ ...baseCliOptions }, {})
-
-    expect(options?.chosenAddOns).toEqual([])
-  })
-
-  it('should select biome when toolchain is specified', async () => {
-    setBasicSpies()
-
-    vi.spyOn(prompts, 'selectToolchain').mockImplementation(async () => 'biome')
-
-    const options = await promptForCreateOptions(
-      { ...baseCliOptions, toolchain: 'biome' },
-      {},
-    )
-
-    expect(options?.chosenAddOns.map((a) => a.id).sort()).toEqual(['biome'])
-  })
-
-  it('should handle forced add-ons', async () => {
-    setBasicSpies()
-
-    vi.spyOn(prompts, 'selectToolchain').mockImplementation(
-      async () => undefined,
-    )
-
-    const options = await promptForCreateOptions(
-      { ...baseCliOptions },
-      { forcedAddOns: ['react-query'] },
-    )
-
-    expect(options?.chosenAddOns.map((a) => a.id).sort()).toEqual([
-      'react-query',
-    ])
-    expect(options?.tailwind).toBe(true)
-    expect(options?.typescript).toBe(true)
-  })
-
-  it('should handle add-ons from the CLI', async () => {
-    setBasicSpies()
-
-    const options = await promptForCreateOptions(
-      { ...baseCliOptions, addOns: ['biome', 'react-query'] },
-      {},
-    )
-
-    expect(options?.chosenAddOns.map((a) => a.id).sort()).toEqual([
-      'biome',
-      'react-query',
-    ])
-    expect(options?.tailwind).toBe(true)
-    expect(options?.typescript).toBe(true)
-  })
-
-  it('should handle user-selected add-ons', async () => {
-    setBasicSpies()
-
-    vi.spyOn(prompts, 'selectAddOns').mockImplementation(async () =>
-      Promise.resolve(['biome', 'react-query']),
-    )
-
-    const options = await promptForCreateOptions(
-      { ...baseCliOptions, addOns: undefined },
-      {},
-    )
-
-    expect(options?.chosenAddOns.map((a) => a.id).sort()).toEqual([
-      'biome',
-      'react-query',
-    ])
-    expect(options?.tailwind).toBe(true)
-    expect(options?.typescript).toBe(true)
-  })
-})

package/tests/setupVitest.ts

@@ -1,6 +0,0 @@
-import createFetchMock from 'vitest-fetch-mock'
-import { vi } from 'vitest'
-
-const fetchMocker = createFetchMock(vi)
-
-fetchMocker.enableMocks()

package/tests/ui-environment.test.ts

@@ -1,97 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-
-import * as clack from '@clack/prompts'
-
-import { createUIEnvironment } from '../src/ui-environment.js'
-
-vi.mock('@clack/prompts')
-
-// @ts-expect-error
-vi.spyOn(process, 'exit').mockImplementation(() => {})
-
-describe('createUIEnvironment', () => {
-  it('should create a silent UI environment', () => {
-    const environment = createUIEnvironment('test', true)
-    expect(environment.appName).toBe('test')
-  })
-
-  it('should handle intro', () => {
-    const environment = createUIEnvironment('test', false)
-    const spy = vi
-      .spyOn(clack, 'intro')
-      .mockImplementation(async () => undefined)
-    environment.intro('test')
-    expect(spy).toHaveBeenCalledWith('test')
-  })
-
-  it('should handle outro', () => {
-    const environment = createUIEnvironment('test', false)
-    const spy = vi
-      .spyOn(clack, 'outro')
-      .mockImplementation(async () => undefined)
-    environment.outro('test')
-    expect(spy).toHaveBeenCalledWith('test')
-  })
-
-  it('should handle info', () => {
-    const environment = createUIEnvironment('test', false)
-    const spy = vi
-      .spyOn(clack.log, 'info')
-      .mockImplementation(async () => undefined)
-    environment.info('test')
-    expect(spy).toHaveBeenCalled()
-  })
-
-  it('should handle error', () => {
-    const environment = createUIEnvironment('test', false)
-    const spy = vi
-      .spyOn(clack.log, 'error')
-      .mockImplementation(async () => undefined)
-    environment.error('test')
-    expect(spy).toHaveBeenCalled()
-  })
-
-  it('should handle warn', () => {
-    const environment = createUIEnvironment('test', false)
-    const spy = vi
-      .spyOn(clack.log, 'warn')
-      .mockImplementation(async () => undefined)
-    environment.warn('test')
-    expect(spy).toHaveBeenCalled()
-  })
-
-  it('should handle confirm', async () => {
-    const environment = createUIEnvironment('test', false)
-    const spy = vi.spyOn(clack, 'confirm').mockImplementation(async () => true)
-    const isCancelSpy = vi
-      .spyOn(clack, 'isCancel')
-      .mockImplementation(() => false)
-    const result = await environment.confirm('test')
-    expect(spy).toHaveBeenCalled()
-    expect(isCancelSpy).toHaveBeenCalled()
-    expect(result).toBe(true)
-  })
-
-  it('should handle confirm', async () => {
-    const environment = createUIEnvironment('test', false)
-    const spy = vi.spyOn(clack, 'confirm').mockImplementation(async () => true)
-    const isCancelSpy = vi
-      .spyOn(clack, 'isCancel')
-      .mockImplementation(() => true)
-    await environment.confirm('test')
-    expect(spy).toHaveBeenCalled()
-    expect(isCancelSpy).toHaveBeenCalled()
-  })
-
-  it('should handle spinner', async () => {
-    const environment = createUIEnvironment('test', false)
-    // @ts-expect-error
-    const spy = vi.spyOn(clack, 'spinner').mockImplementation(async () => ({
-      start: (_msg?: string) => {},
-      stop: (_msg?: string) => {},
-      message: (_msg?: string) => {},
-    }))
-    const result = await environment.spinner()
-    expect(spy).toHaveBeenCalled()
-  })
-})

package/tests/ui-prompts.test.ts

@@ -1,233 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-
-import * as clack from '@clack/prompts'
-
-import {
-  getProjectName,
-  selectAddOns,
-  selectGit,
-  selectPackageManager,
-  selectTemplate,
-  selectToolchain,
-} from '../src/ui-prompts'
-
-import type { AddOn, Framework } from '@tanstack/create'
-
-vi.mock('@clack/prompts')
-
-vi.spyOn(process, 'exit').mockImplementation((number) => {
-  throw new Error(`process.exit: ${number}`)
-})
-
-describe('getProjectName', () => {
-  it('should return the project name', async () => {
-    vi.spyOn(clack, 'text').mockImplementation(async () => 'my-app')
-    vi.spyOn(clack, 'isCancel').mockImplementation(() => false)
-
-    const projectName = await getProjectName()
-    expect(projectName).toBe('my-app')
-  })
-
-  it('should exit on cancel', async () => {
-    vi.spyOn(clack, 'text').mockImplementation(async () => 'Cancelled')
-    vi.spyOn(clack, 'isCancel').mockImplementation(() => true)
-
-    await expect(getProjectName()).rejects.toThrowError(/exit/)
-  })
-})
-
-describe('selectPackageManager', () => {
-  it('should select pnpm', async () => {
-    vi.spyOn(clack, 'select').mockImplementation(async () => 'pnpm')
-    vi.spyOn(clack, 'isCancel').mockImplementation(() => false)
-
-    const packageManager = await selectPackageManager()
-    expect(packageManager).toBe('pnpm')
-  })
-
-  it('should exit on cancel', async () => {
-    vi.spyOn(clack, 'select').mockImplementation(async () =>
-      Symbol.for('cancel'),
-    )
-    vi.spyOn(clack, 'isCancel').mockImplementation(() => true)
-
-    await expect(selectPackageManager()).rejects.toThrowError(/exit/)
-  })
-})
-
-describe('selectTemplate', () => {
-  it('should select a template id', async () => {
-    vi.spyOn(clack, 'select').mockImplementation(async () => 'blog')
-    vi.spyOn(clack, 'isCancel').mockImplementation(() => false)
-
-    const selectedTemplate = await selectTemplate([
-      { id: 'blog', name: 'Blog', description: 'A blog template' },
-    ])
-
-    expect(selectedTemplate).toBe('blog')
-  })
-
-  it('should return undefined when no templates are available', async () => {
-    const selectedTemplate = await selectTemplate([])
-    expect(selectedTemplate).toBeUndefined()
-  })
-
-  it('should exit on cancel', async () => {
-    vi.spyOn(clack, 'select').mockImplementation(async () => Symbol.for('cancel'))
-    vi.spyOn(clack, 'isCancel').mockImplementation(() => true)
-
-    await expect(
-      selectTemplate([{ id: 'blog', name: 'Blog' }]),
-    ).rejects.toThrowError(/exit/)
-  })
-})
-
-describe('selectAddOns', () => {
-  it('should show keyboard shortcuts help and select add-ons', async () => {
-    const noteSpy = vi.spyOn(clack, 'note').mockImplementation(() => {})
-    const multiselectSpy = vi
-      .spyOn(clack, 'multiselect')
-      .mockImplementation(async () => ['add-on-1'])
-    vi.spyOn(clack, 'isCancel').mockImplementation(() => false)
-
-    const packageManager = await selectAddOns(
-      {
-        getAddOns: () =>
-          [
-            {
-              id: 'add-on-1',
-              name: 'Add-on 1',
-              description: 'Add-on 1 description',
-              type: 'add-on',
-              modes: ['file-router'],
-            },
-          ] as Array<AddOn>,
-      } as Framework,
-      'file-router',
-      'add-on',
-      'Select add-ons',
-    )
-
-    expect(packageManager).toEqual(['add-on-1'])
-    expect(noteSpy).toHaveBeenCalledWith(
-      'Use ↑/↓ to navigate • Space to select/deselect • Enter to confirm',
-      'Keyboard Shortcuts',
-    )
-    expect(multiselectSpy).toHaveBeenCalledWith(
-      expect.objectContaining({ maxItems: 1 }),
-    )
-  })
-
-  it('should exit on cancel', async () => {
-    vi.spyOn(clack, 'select').mockImplementation(async () =>
-      Symbol.for('cancel'),
-    )
-    vi.spyOn(clack, 'isCancel').mockImplementation(() => true)
-
-    await expect(
-      selectAddOns(
-        {
-          getAddOns: () =>
-            [
-              {
-                id: 'add-on-1',
-                name: 'Add-on 1',
-                description: 'Add-on 1 description',
-                type: 'add-on',
-                modes: ['file-router'],
-              },
-            ] as Array<AddOn>,
-        } as Framework,
-        'file-router',
-        'add-on',
-        'Select add-ons',
-      ),
-    ).rejects.toThrowError(/exit/)
-  })
-})
-
-describe('selectGit', () => {
-  it('should select git', async () => {
-    vi.spyOn(clack, 'confirm').mockImplementation(async () => true)
-    vi.spyOn(clack, 'isCancel').mockImplementation(() => false)
-
-    const git = await selectGit()
-    expect(git).toBe(true)
-  })
-
-  it('should exit on cancel', async () => {
-    vi.spyOn(clack, 'confirm').mockImplementation(async () =>
-      Symbol.for('cancel'),
-    )
-    vi.spyOn(clack, 'isCancel').mockImplementation(() => true)
-
-    await expect(selectGit()).rejects.toThrowError(/exit/)
-  })
-})
-
-describe('selectToolchain', () => {
-  it('should select a toolchain', async () => {
-    vi.spyOn(clack, 'select').mockImplementation(async () => 'biome')
-    vi.spyOn(clack, 'isCancel').mockImplementation(() => false)
-
-    const packageManager = await selectToolchain({
-      getAddOns: () =>
-        [
-          {
-            id: 'biome',
-            name: 'Biome',
-            description: 'Biome description',
-            type: 'toolchain',
-            modes: ['file-router'],
-          },
-        ] as Array<AddOn>,
-    } as Framework)
-    expect(packageManager).toEqual('biome')
-  })
-  it('should select a toolchain', async () => {
-    const selectSpy = vi
-      .spyOn(clack, 'select')
-      .mockImplementation(async () => 'biome')
-    vi.spyOn(clack, 'isCancel').mockImplementation(() => false)
-
-    const packageManager = await selectToolchain(
-      {
-        getAddOns: () =>
-          [
-            {
-              id: 'biome',
-              name: 'Biome',
-              description: 'Biome description',
-              type: 'toolchain',
-              modes: ['file-router'],
-            },
-          ] as Array<AddOn>,
-      } as Framework,
-      'biome',
-    )
-    expect(packageManager).toEqual('biome')
-    expect(selectSpy).not.toHaveBeenCalled()
-  })
-
-  it('should exit on cancel', async () => {
-    vi.spyOn(clack, 'select').mockImplementation(async () =>
-      Symbol.for('cancel'),
-    )
-    vi.spyOn(clack, 'isCancel').mockImplementation(() => true)
-
-    await expect(
-      selectToolchain({
-        getAddOns: () =>
-          [
-            {
-              id: 'biome',
-              name: 'Biome',
-              description: 'Biome description',
-              type: 'toolchain',
-              modes: ['file-router'],
-            },
-          ] as Array<AddOn>,
-      } as Framework),
-    ).rejects.toThrowError(/exit/)
-  })
-})

package/tests-e2e/addons-smoke.spec.ts

@@ -1,31 +0,0 @@
-import { expect, test } from '@playwright/test'
-
-import { attachRuntimeGuards, createReactAppFixture } from './helpers'
-
-test('@blocking creates app with multiple add-ons and renders demo routes', async ({ page }) => {
-  const fixture = await createReactAppFixture({
-    appName: 'addons-create-smoke-app',
-    addOns: ['shadcn', 'form', 'tanstack-query', 'store'],
-  })
-  const guards = attachRuntimeGuards(page, fixture.url)
-
-  try {
-    await page.goto(`${fixture.url}/demo/form/simple`)
-    await expect(page.getByText('Title', { exact: true })).toBeVisible()
-    await expect(page.getByRole('button', { name: 'Submit' })).toBeVisible()
-
-    await page.goto(`${fixture.url}/demo/tanstack-query`)
-    await expect(page.getByRole('heading', { name: /TanStack Query/ })).toBeVisible()
-
-    await page.goto(`${fixture.url}/demo/store`)
-    await expect(page.getByRole('heading', { name: 'Store Example' })).toBeVisible()
-  } finally {
-    try {
-      guards.assertClean()
-    } finally {
-      guards.dispose()
-      await fixture.stop()
-      await fixture.cleanup()
-    }
-  }
-})

package/tests-e2e/create-smoke.spec.ts

@@ -1,39 +0,0 @@
-import { expect, test } from '@playwright/test'
-
-import { attachRuntimeGuards, createReactAppFixture } from './helpers'
-
-test('@blocking creates a React app and navigates core starter routes', async ({ page }) => {
-  const fixture = await createReactAppFixture({
-    appName: 'react-smoke-app',
-  })
-  const guards = attachRuntimeGuards(page, fixture.url)
-
-  try {
-    await page.goto(fixture.url)
-    await expect(
-      page.getByRole('heading', {
-        name: 'Start simple, ship quickly.',
-      }),
-    ).toBeVisible()
-
-    await page.getByRole('link', { name: 'About', exact: true }).click()
-    await expect(page).toHaveURL(/\/about\/?$/)
-    await expect(
-      page.getByRole('heading', { name: 'A small starter with room to grow.' }),
-    ).toBeVisible()
-
-    await page.getByRole('link', { name: 'Home' }).click()
-    await expect(page).toHaveURL(/\/?$/)
-    await expect(
-      page.getByRole('heading', { name: 'Start simple, ship quickly.' }),
-    ).toBeVisible()
-  } finally {
-    try {
-      guards.assertClean()
-    } finally {
-      guards.dispose()
-      await fixture.stop()
-      await fixture.cleanup()
-    }
-  }
-})