@tanstack/cli 0.0.8 → 0.48.3

package/tests/options.test.ts

@@ -0,0 +1,304 @@
+import { beforeEach, describe, it, expect, vi } from 'vitest'
+
+import { promptForCreateOptions } from '../src/options'
+import {
+  __testClearFrameworks,
+  __testRegisterFramework,
+} from '@tanstack/create'
+
+import * as prompts from '../src/ui-prompts'
+
+import type { Framework } from '@tanstack/create'
+
+import type { CliOptions } from '../src/types'
+
+vi.mock('../src/ui-prompts')
+
+beforeEach(() => {
+  __testClearFrameworks()
+  __testRegisterFramework({
+    id: 'react-cra',
+    name: 'react',
+    getAddOns: () => [
+      {
+        id: 'react-query',
+        type: 'add-on',
+        modes: ['file-router', 'code-router'],
+      },
+      {
+        id: 'tanstack-chat',
+        type: 'add-on',
+        modes: ['file-router', 'code-router'],
+      },
+      {
+        id: 'biome',
+        type: 'toolchain',
+        modes: ['file-router', 'code-router'],
+      },
+    ],
+    supportedModes: {
+      'code-router': {
+        displayName: 'Code Router',
+        description: 'TanStack Router using code to define the routes',
+        forceTypescript: false,
+      },
+      'file-router': {
+        displayName: 'File Router',
+        description: 'TanStack Router using files to define the routes',
+        forceTypescript: true,
+      },
+    },
+  } as unknown as Framework)
+
+  __testRegisterFramework({
+    id: 'solid',
+    name: 'solid',
+    getAddOns: () => [],
+  } as unknown as Framework)
+})
+
+const baseCliOptions: CliOptions = {
+  framework: 'react-cra',
+  addOns: [],
+  toolchain: undefined,
+  projectName: undefined,
+  git: undefined,
+}
+
+function setBasicSpies() {
+  vi.spyOn(prompts, 'getProjectName').mockImplementation(async () => 'hello')
+  vi.spyOn(prompts, 'selectRouterType').mockImplementation(
+    async () => 'file-router',
+  )
+  vi.spyOn(prompts, 'selectTypescript').mockImplementation(async () => true)
+  vi.spyOn(prompts, 'selectTailwind').mockImplementation(async () => true)
+  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 (router type)
+
+  it('forceMode should override template', async () => {
+    setBasicSpies()
+
+    const options = await promptForCreateOptions(
+      { ...baseCliOptions, template: 'javascript' },
+      { forcedMode: 'file-router' },
+    )
+
+    expect(options?.mode).toBe('file-router')
+    expect(options?.typescript).toBe(true)
+  })
+
+  it('takes template from cli options - code-router', async () => {
+    setBasicSpies()
+
+    vi.spyOn(prompts, 'selectRouterType').mockImplementation(
+      async () => 'code-router',
+    )
+
+    const options = await promptForCreateOptions(
+      { ...baseCliOptions, template: 'javascript' },
+      {},
+    )
+
+    expect(options?.mode).toBe('code-router')
+  })
+
+  it('takes template from cli options - file-router', async () => {
+    setBasicSpies()
+
+    vi.spyOn(prompts, 'selectRouterType').mockImplementation(
+      async () => 'code-router',
+    )
+
+    const options = await promptForCreateOptions(
+      { ...baseCliOptions, template: 'file-router' },
+      {},
+    )
+
+    expect(options?.mode).toBe('file-router')
+  })
+
+  it('prompt for router type when unspecified', async () => {
+    setBasicSpies()
+
+    vi.spyOn(prompts, 'selectRouterType').mockImplementation(
+      async () => 'code-router',
+    )
+
+    const options = await promptForCreateOptions(
+      { ...baseCliOptions, tailwind: false, framework: undefined },
+      {},
+    )
+
+    expect(options?.mode).toBe('code-router')
+  })
+
+  //// Tailwind
+
+  it('prompt for tailwind when unspecified in react-cra', async () => {
+    setBasicSpies()
+    vi.spyOn(prompts, 'selectTailwind').mockImplementation(async () => false)
+    const options = await promptForCreateOptions(
+      { ...baseCliOptions, tailwind: undefined },
+      {},
+    )
+
+    expect(options?.tailwind).toBe(false)
+  })
+
+  it('prompt for tailwind when unspecified in react-cra - true', async () => {
+    setBasicSpies()
+    vi.spyOn(prompts, 'selectTailwind').mockImplementation(async () => true)
+    const options = await promptForCreateOptions(
+      { ...baseCliOptions, tailwind: undefined },
+      {},
+    )
+
+    expect(options?.tailwind).toBe(true)
+  })
+
+  it('set tailwind when solid', async () => {
+    setBasicSpies()
+    const options = await promptForCreateOptions(
+      { ...baseCliOptions, tailwind: undefined, framework: 'solid' },
+      {},
+    )
+
+    expect(options?.tailwind).toBe(true)
+  })
+
+  //// 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('uses the package manager from the cli options', 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',
+    ])
+    // Tailwind should be prompted (and mock returns true) since no add-on explicitly requires it
+    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',
+    ])
+    // In non-interactive mode with add-ons, tailwind defaults to false unless explicitly required
+    // But since we're in interactive mode (addOns is an array but we still prompt), tailwind is prompted
+    // The mock returns true, so tailwind should be true
+    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',
+    ])
+    // Tailwind should be prompted (and mock returns true) since no add-on explicitly requires it
+    expect(options?.tailwind).toBe(true)
+    expect(options?.typescript).toBe(true)
+  })
+})

package/tests/setupVitest.ts

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

package/tests/ui-environment.test.ts

@@ -0,0 +1,97 @@
+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

@@ -0,0 +1,238 @@
+import { describe, it, expect, vi } from 'vitest'
+
+import * as clack from '@clack/prompts'
+
+import {
+  getProjectName,
+  selectAddOns,
+  selectGit,
+  selectPackageManager,
+  selectRouterType,
+  selectTailwind,
+  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('selectRouterType', () => {
+  it('should select the file router', async () => {
+    vi.spyOn(clack, 'select').mockImplementation(async () => 'file-router')
+    vi.spyOn(clack, 'isCancel').mockImplementation(() => false)
+
+    const routerType = await selectRouterType()
+    expect(routerType).toBe('file-router')
+  })
+
+  it('should exit on cancel', async () => {
+    vi.spyOn(clack, 'select').mockImplementation(async () => 'Cancelled')
+    vi.spyOn(clack, 'isCancel').mockImplementation(() => true)
+
+    await expect(() => selectRouterType()).rejects.toThrowError(/exit/)
+  })
+})
+
+describe('selectTailwind', () => {
+  it('should select tailwind', async () => {
+    vi.spyOn(clack, 'confirm').mockImplementation(async () => true)
+    vi.spyOn(clack, 'isCancel').mockImplementation(() => false)
+
+    const tailwind = await selectTailwind()
+    expect(tailwind).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(selectTailwind()).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('selectAddOns', () => {
+  it('should show keyboard shortcuts help and select add-ons', async () => {
+    const noteSpy = vi.spyOn(clack, 'note').mockImplementation(() => {})
+    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',
+    )
+  })
+
+  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/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ES2020",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "declaration": true,
+    "declarationDir": "./dist/types"
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.js

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    setupFiles: ['./tests/setupVitest.js'],
+  },
+})