Open History to see the last commit
1import { basename, resolve } from 'node:path'
2
3import { isBase64 } from './file-helpers.js'
4import { formatCommand } from './utils.js'
5import { writeConfigFileToEnvironment } from './config-file.js'
6import {
7 getPackageManagerScriptCommand,
8 packageManagerInstall,
9} from './package-manager.js'
10import { createPackageJSON } from './package-json.js'
11import { createTemplateFile } from './template-file.js'
12import { installShadcnComponents } from './integrations/shadcn.js'
13import { setupGit } from './integrations/git.js'
14import { runSpecialSteps } from './special-steps/index.js'
15
16import type { Environment, FileBundleHandler, Options } from './types.js'
17
18async function writeFiles(environment: Environment, options: Options) {
19 const templateFileFromContent = createTemplateFile(environment, options)
20
21 async function writeFileBundle(bundle: FileBundleHandler) {
22 const files = await bundle.getFiles()
23 for (const file of files) {
24 const contents = await bundle.getFileContents(file)
25 const isBinaryFile = isBase64(contents)
26 if (isBinaryFile) {
27 await environment.writeFileBase64(
28 resolve(options.targetDir, file),
29 contents,
30 )
31 } else {
32 await templateFileFromContent(file, contents)
33 }
34 }
35
36 const deletedFiles = await bundle.getDeletedFiles()
37 for (const file of deletedFiles) {
38 await environment.deleteFile(resolve(options.targetDir, file))
39 }
40 }
41
42 environment.startStep({
43 id: 'write-framework-files',
44 type: 'file',
45 message: 'Writing framework files...',
46 })
47 await writeFileBundle(options.framework)
48 environment.finishStep('write-framework-files', 'Framework files written')
49
50 let wroteAddonFiles = false
51 for (const type of ['add-on', 'example', 'toolchain']) {
52 for (const phase of ['setup', 'add-on', 'example']) {
53 for (const addOn of options.chosenAddOns.filter(
54 (addOn) => addOn.phase === phase && addOn.type === type,
55 )) {
56 environment.startStep({
57 id: 'write-addon-files',
58 type: 'file',
59 message: `Writing ${addOn.name} files...`,
60 })
61 await writeFileBundle(addOn)
62 wroteAddonFiles = true
63 }
64 }
65 }
66 if (wroteAddonFiles) {
67 environment.finishStep('write-addon-files', 'Add-on files written')
68 }
69
70 if (options.starter) {
71 environment.startStep({
72 id: 'write-starter-files',
73 type: 'file',
74 message: 'Writing starter files...',
75 })
76 await writeFileBundle(options.starter)
77 environment.finishStep('write-starter-files', 'Starter files written')
78 }
79
80 environment.startStep({
81 id: 'write-package-json',
82 type: 'file',
83 message: 'Writing package.json...',
84 })
85 await environment.writeFile(
86 resolve(options.targetDir, './package.json'),
87 JSON.stringify(createPackageJSON(options), null, 2),
88 )
89 environment.finishStep('write-package-json', 'Package.json written')
90
91 environment.startStep({
92 id: 'write-config-file',
93 type: 'file',
94 message: 'Writing config file...',
95 })
96 await writeConfigFileToEnvironment(environment, options)
97 environment.finishStep('write-config-file', 'Config file written')
98}
99
100async function runCommandsAndInstallDependencies(
101 environment: Environment,
102 options: Options,
103) {
104 const s = environment.spinner()
105
106 // Setup git
107 if (options.git) {
108 s.start(`Initializing git repository...`)
109 environment.startStep({
110 id: 'initialize-git-repository',
111 type: 'command',
112 message: 'Initializing git repository...',
113 })
114
115 await setupGit(environment, options.targetDir)
116
117 environment.finishStep(
118 'initialize-git-repository',
119 'Initialized git repository',
120 )
121 s.stop(`Initialized git repository`)
122 }
123
124 // Run any special steps for the new add-ons
125 const specialSteps = new Set<string>([])
126 for (const addOn of options.chosenAddOns) {
127 for (const step of addOn.createSpecialSteps || []) {
128 specialSteps.add(step)
129 }
130 }
131 if (specialSteps.size) {
132 await runSpecialSteps(environment, options, Array.from(specialSteps))
133 }
134
135 // Install dependencies
136 s.start(`Installing dependencies via ${options.packageManager}...`)
137 environment.startStep({
138 id: 'install-dependencies',
139 type: 'package-manager',
140 message: `Installing dependencies via ${options.packageManager}...`,
141 })
142 await packageManagerInstall(
143 environment,
144 options.targetDir,
145 options.packageManager,
146 )
147 environment.finishStep('install-dependencies', 'Installed dependencies')
148 s.stop(`Installed dependencies`)
149
150 for (const phase of ['setup', 'add-on', 'example']) {
151 for (const addOn of options.chosenAddOns.filter(
152 (addOn) =>
153 addOn.phase === phase && addOn.command && addOn.command.command,
154 )) {
155 s.start(`Running commands for ${addOn.name}...`)
156 const cmd = formatCommand({
157 command: addOn.command!.command,
158 args: addOn.command!.args || [],
159 })
160 environment.startStep({
161 id: 'run-commands',
162 type: 'command',
163 message: cmd,
164 })
165 await environment.execute(
166 addOn.command!.command,
167 addOn.command!.args || [],
168 options.targetDir,
169 )
170 environment.finishStep('run-commands', 'Setup commands complete')
171 s.stop(`${addOn.name} commands complete`)
172 }
173 }
174
175 // Adding starter
176 if (
177 options.starter &&
178 options.starter.command &&
179 options.starter.command.command
180 ) {
181 s.start(`Setting up starter ${options.starter.name}...`)
182 const cmd = formatCommand({
183 command: options.starter.command.command,
184 args: options.starter.command.args || [],
185 })
186 environment.startStep({
187 id: 'run-starter-command',
188 type: 'command',
189 message: cmd,
190 })
191
192 await environment.execute(
193 options.starter.command.command,
194 options.starter.command.args || [],
195 options.targetDir,
196 )
197
198 environment.finishStep('run-starter-command', 'Starter command complete')
199 s.stop(`${options.starter.name} commands complete`)
200 }
201
202 await installShadcnComponents(environment, options.targetDir, options)
203}
204
205function report(environment: Environment, options: Options) {
206 const warnings: Array<string> = []
207 for (const addOn of options.chosenAddOns) {
208 if (addOn.warning) {
209 warnings.push(addOn.warning)
210 }
211 }
212
213 if (warnings.length > 0) {
214 environment.warn('Warnings', warnings.join('\n'))
215 }
216
217 // Format errors
218 let errorStatement = ''
219 if (environment.getErrors().length) {
220 errorStatement = `
221
222Errors were encountered during the creation of your app:
223
224${environment.getErrors().join('\n')}`
225 }
226
227 environment.outro(
228 `Your ${environment.appName} app is ready in '${basename(options.targetDir)}'.
229
230Use the following commands to start your app:
231% cd ${options.projectName}
232% ${formatCommand(
233 getPackageManagerScriptCommand(options.packageManager, ['dev']),
234 )}
235
236Please read the README.md for information on testing, styling, adding routes, etc.${errorStatement}`,
237 )
238}
239
240export async function createApp(environment: Environment, options: Options) {
241 environment.startRun()
242 await writeFiles(environment, options)
243 await runCommandsAndInstallDependencies(environment, options)
244 environment.finishRun()
245
246 report(environment, options)
247}