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', 'deployment']) {
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 // Run any post-init special steps for the new add-ons
151 const postInitSpecialSteps = new Set<string>([])
152 for (const addOn of options.chosenAddOns) {
153 for (const step of addOn.postInitSpecialSteps || []) {
154 postInitSpecialSteps.add(step)
155 }
156 }
157 if (postInitSpecialSteps.size) {
158 await runSpecialSteps(
159 environment,
160 options,
161 Array.from(postInitSpecialSteps),
162 )
163 }
164
165 for (const phase of ['setup', 'add-on', 'example']) {
166 for (const addOn of options.chosenAddOns.filter(
167 (addOn) =>
168 addOn.phase === phase && addOn.command && addOn.command.command,
169 )) {
170 s.start(`Running commands for ${addOn.name}...`)
171 const cmd = formatCommand({
172 command: addOn.command!.command,
173 args: addOn.command!.args || [],
174 })
175 environment.startStep({
176 id: 'run-commands',
177 type: 'command',
178 message: cmd,
179 })
180 await environment.execute(
181 addOn.command!.command,
182 addOn.command!.args || [],
183 options.targetDir,
184 { inherit: true },
185 )
186 environment.finishStep('run-commands', 'Setup commands complete')
187 s.stop(`${addOn.name} commands complete`)
188 }
189 }
190
191 // Adding starter
192 if (
193 options.starter &&
194 options.starter.command &&
195 options.starter.command.command
196 ) {
197 s.start(`Setting up starter ${options.starter.name}...`)
198 const cmd = formatCommand({
199 command: options.starter.command.command,
200 args: options.starter.command.args || [],
201 })
202 environment.startStep({
203 id: 'run-starter-command',
204 type: 'command',
205 message: cmd,
206 })
207
208 await environment.execute(
209 options.starter.command.command,
210 options.starter.command.args || [],
211 options.targetDir,
212 { inherit: true },
213 )
214
215 environment.finishStep('run-starter-command', 'Starter command complete')
216 s.stop(`${options.starter.name} commands complete`)
217 }
218
219 await installShadcnComponents(environment, options.targetDir, options)
220}
221
222function report(environment: Environment, options: Options) {
223 const warnings: Array<string> = []
224 for (const addOn of options.chosenAddOns) {
225 if (addOn.warning) {
226 warnings.push(addOn.warning)
227 }
228 }
229
230 if (warnings.length > 0) {
231 environment.warn('Warnings', warnings.join('\n'))
232 }
233
234 // Format errors
235 let errorStatement = ''
236 if (environment.getErrors().length) {
237 errorStatement = `
238
239Errors were encountered during the creation of your app:
240
241${environment.getErrors().join('\n')}`
242 }
243
244 // Check if we created in current directory (user specified ".")
245 const isCurrentDirectory =
246 resolve(options.targetDir) === resolve(process.cwd())
247 const locationMessage = isCurrentDirectory
248 ? `Your ${environment.appName} app is ready.`
249 : `Your ${environment.appName} app is ready in '${basename(options.targetDir)}'.`
250 const cdInstruction = isCurrentDirectory
251 ? ''
252 : `% cd ${options.projectName}
253`
254
255 // Use the force luke! :)
256 environment.outro(
257 `${locationMessage}
258
259Use the following commands to start your app:
260${cdInstruction}% ${formatCommand(
261 getPackageManagerScriptCommand(options.packageManager, ['dev']),
262 )}
263
264Please check the README.md file for information on testing, styling, adding routes, etc.${errorStatement}`,
265 )
266}
267
268export async function createApp(environment: Environment, options: Options) {
269 environment.startRun()
270 await writeFiles(environment, options)
271 await runCommandsAndInstallDependencies(environment, options)
272 environment.finishRun()
273
274 report(environment, options)
275}