Skip to content
Source
Sign inSign up
TanStack/cli
Open History to see the last commit

generate-manifest.mjs

591 lines16.5 KB

1import {
2 existsSync,
3 mkdirSync,
4 readFileSync,
5 readdirSync,
6 rmSync,
7 writeFileSync,
8} from 'node:fs'
9import { dirname, extname, join, relative, resolve } from 'node:path'
10import { fileURLToPath } from 'node:url'
11​
12const packageDir = resolve(dirname(fileURLToPath(import.meta.url)), '..')
13const frameworksDir = resolve(packageDir, 'src/frameworks')
14const outputFile = resolve(packageDir, 'src/generated/create-manifest.ts')
15const workerOutputDir = resolve(packageDir, 'src/generated/worker')
16​
17const binaryExtensions = new Set(['.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico'])
18const templateRenderers = new Map()
19​
20const frameworkMetadata = {
21 react: {
22 id: 'react',
23 name: 'React',
24 description: 'Templates for React',
25 version: '0.1.0',
26 bundlers: [
27 { id: 'vite', name: 'Vite', description: 'Build with Vite' },
28 { id: 'rsbuild', name: 'Rsbuild', description: 'Build with Rsbuild' },
29 ],
30 defaultBundler: 'vite',
31 supportedModes: {
32 'file-router': {
33 displayName: 'File Router',
34 description: 'TanStack Start with file-based routing',
35 forceTypescript: true,
36 },
37 },
38 },
39 solid: {
40 id: 'solid',
41 name: 'Solid',
42 description: 'Solid templates for Tanstack Router Applications',
43 version: '0.1.0',
44 bundlers: [
45 { id: 'vite', name: 'Vite', description: 'Build with Vite' },
46 { id: 'rsbuild', name: 'Rsbuild', description: 'Build with Rsbuild' },
47 ],
48 defaultBundler: 'vite',
49 supportedModes: {
50 'file-router': {
51 displayName: 'File Router',
52 description: 'TanStack Start with file-based routing',
53 forceTypescript: true,
54 },
55 },
56 },
58​
59function readJson(file) {
60 return JSON.parse(readFileSync(file, 'utf8'))
62​
63function readTemplateFile(file) {
64 if (binaryExtensions.has(extname(file))) {
65 return `base64::${readFileSync(file).toString('base64')}`
66 }
67​
68 const contents = readFileSync(file, 'utf8').toString()
69 if (file.endsWith('.ejs')) {
70 registerTemplate(contents)
71 }
72​
73 return contents
75​
76function toCleanPath(file, baseDir) {
77 return relative(baseDir, file).replace(/\\/g, '/')
79​
80function findFilesRecursively(baseDir) {
81 const files = {}
82​
83 if (!existsSync(baseDir)) {
84 return files
85 }
86​
87 function visit(dir) {
88 for (const entry of readdirSync(dir, { withFileTypes: true })) {
89 const file = resolve(dir, entry.name)
90 if (entry.isDirectory()) {
91 visit(file)
92 } else {
93 files[toCleanPath(file, baseDir)] = readTemplateFile(file)
94 }
95 }
96 }
97​
98 visit(baseDir)
99​
100 return files
102​
103function scanProjectDirectory(frameworkDir) {
104 const projectDirectory = join(frameworkDir, 'project')
105 const baseDirectory = join(projectDirectory, 'base')
106 const basePackagePath = join(baseDirectory, 'package.json')
107 const optionalPackagesPath = join(projectDirectory, 'packages.json')
108​
109 return {
110 base: findFilesRecursively(baseDirectory),
111 basePackageJSON: existsSync(basePackagePath) ? readJson(basePackagePath) : {},
112 optionalPackages: existsSync(optionalPackagesPath)
113 ? readJson(optionalPackagesPath)
114 : {},
115 }
117​
118function scanCatalogDirectory(addOnsBase) {
119 if (!existsSync(addOnsBase)) {
120 return []
121 }
122​
123 const addOns = []
124​
125 for (const entry of readdirSync(addOnsBase, { withFileTypes: true })) {
126 if (!entry.isDirectory()) {
127 continue
128 }
129​
130 const addOnDir = join(addOnsBase, entry.name)
131 const info = readJson(join(addOnDir, 'info.json'))
132​
133 let packageAdditions = {}
134 let packageTemplate
135 const packageJsonPath = join(addOnDir, 'package.json')
136 const packageTemplatePath = join(addOnDir, 'package.json.ejs')
137 if (existsSync(packageJsonPath)) {
138 packageAdditions = readJson(packageJsonPath)
139 } else if (existsSync(packageTemplatePath)) {
140 packageTemplate = readFileSync(packageTemplatePath, 'utf8')
141 registerTemplate(packageTemplate)
142 }
143​
144 let readme
145 let readmeIsEjs = false
146 const readmePath = join(addOnDir, 'README.md')
147 const readmeTemplatePath = join(addOnDir, 'README.md.ejs')
148 if (existsSync(readmePath)) {
149 readme = readFileSync(readmePath, 'utf8')
150 } else if (existsSync(readmeTemplatePath)) {
151 readme = readFileSync(readmeTemplatePath, 'utf8')
152 registerTemplate(readme)
153 readmeIsEjs = true
154 }
155​
156 let smallLogo
157 const smallLogoPath = join(addOnDir, 'small-logo.svg')
158 if (existsSync(smallLogoPath)) {
159 smallLogo = readFileSync(smallLogoPath, 'utf8')
160 }
161​
162 addOns.push({
163 ...info,
164 id: entry.name,
165 version: info.version ?? '0.0.0',
166 packageAdditions,
167 packageTemplate,
168 readme,
169 readmeIsEjs,
170 files: findFilesRecursively(join(addOnDir, 'assets')),
171 deletedFiles: info.deletedFiles ?? [],
172 smallLogo,
173 })
174 }
175​
176 return addOns
178​
179function createFramework(frameworkId) {
180 const frameworkDir = join(frameworksDir, frameworkId)
181 const project = scanProjectDirectory(frameworkDir)
182​
183 return {
184 ...frameworkMetadata[frameworkId],
185 ...project,
186 addOns: [
187 ...scanCatalogDirectory(join(frameworkDir, 'add-ons')),
188 ...scanCatalogDirectory(join(frameworkDir, 'toolchains')),
189 ...scanCatalogDirectory(join(frameworkDir, 'examples')),
190 ...scanCatalogDirectory(join(frameworkDir, 'hosts')),
191 ],
192 }
194​
195function getTemplateKey(template) {
196 let hash = 0x811c9dc5
197 for (let i = 0; i < template.length; i++) {
198 hash ^= template.charCodeAt(i)
199 hash = Math.imul(hash, 0x01000193) >>> 0
200 }
201​
202 return `${hash.toString(16).padStart(8, '0')}:${template.length}`
204​
205function registerTemplate(template) {
206 const key = getTemplateKey(template)
207 if (!templateRenderers.has(key)) {
208 templateRenderers.set(key, compileTemplate(template))
209 }
211​
212function stripSemicolon(code) {
213 return code.replace(/;(\s*$)/, '$1')
215​
216function compileTemplate(template) {
217 const regex = /<%([=_#-]?|_)?([\s\S]*?)([-_]?%>)/g
218 let cursor = 0
219 let trimLeadingWhitespace = false
220 const lines = []
221​
222 function appendText(value) {
223 if (!value) {
224 return
225 }
226 lines.push(` __append(${JSON.stringify(value)})`)
227 }
228​
229 for (const match of template.matchAll(regex)) {
230 let text = template.slice(cursor, match.index)
231 if (trimLeadingWhitespace) {
232 text = text.replace(/^\s*\r?\n?/, '')
233 trimLeadingWhitespace = false
234 }
235 if (match[1] === '_') {
236 text = text.replace(/\s*$/, '')
237 }
238 appendText(text)
239​
240 const marker = match[1] || ''
241 const code = match[2]
242 const close = match[3]
243​
244 if (marker === '=') {
245 lines.push(` __append(__escapeXML(${stripSemicolon(code.trim())}))`)
246 } else if (marker === '-') {
247 lines.push(` __append(${stripSemicolon(code.trim())})`)
248 } else if (marker !== '#') {
249 lines.push(code)
250 }
251​
252 trimLeadingWhitespace = close.startsWith('-') || close.startsWith('_')
253 cursor = match.index + match[0].length
254 }
255​
256 let tail = template.slice(cursor)
257 if (trimLeadingWhitespace) {
258 tail = tail.replace(/^\s*\r?\n?/, '')
259 }
260 appendText(tail)
261​
262 return lines.join('\n')
264​
265function createTemplateRendererSource(renderers = templateRenderers) {
266 const entries = Array.from(renderers.entries()).sort(([a], [b]) =>
267 a.localeCompare(b),
268 )
269​
270 const functions = entries
271 .map(([key, body]) => {
272 const functionName = `__render_${key.replace(/[^a-zA-Z0-9_$]/g, '_')}`
273 return `function ${functionName}(context: TemplateRenderContext) {
274 const {
275 packageManager,
276 projectName,
277 bundler,
278 typescript,
279 tailwind,
280 blank,
281 js,
282 jsx,
283 fileRouter,
284 codeRouter,
285 routerOnly,
286 includeExamples,
287 addOnEnabled,
288 addOnOption,
289 addOns,
290 integrations,
291 routes,
292 getPackageManagerAddScript,
293 getPackageManagerRunScript,
294 getPackageManagerExecuteScript,
295 relativePath,
296 integrationImportContent,
297 integrationImportCode,
298 renderTemplate,
299 ignoreFile,
300 } = context
301 let __output = ''
302 const __append = (value: unknown) => {
303 if (value !== undefined && value !== null) {
304 __output += String(value)
305 }
306 }
307${body}
308 return __output
309}`
310 })
311 .join('\n\n')
312​
313 const mapEntries = entries
314 .map(([key]) => {
315 const functionName = `__render_${key.replace(/[^a-zA-Z0-9_$]/g, '_')}`
316 return ` ${JSON.stringify(key)}: ${functionName},`
317 })
318 .join('\n')
319​
320 return `type TemplateRecord = Record<string, any>
321type TemplateAddOn = TemplateRecord & {
322 integrations?: Array<TemplateRecord>
323 routes?: Array<TemplateRecord>
325​
326type TemplateRenderContext = {
327 [key: string]: any
328 packageManager: any
329 projectName: any
330 bundler: any
331 typescript: any
332 tailwind: any
333 blank: any
334 js: any
335 jsx: any
336 fileRouter: any
337 codeRouter: any
338 routerOnly: any
339 includeExamples: any
340 addOnEnabled: Record<string, any>
341 addOnOption: Record<string, any>
342 addOns: Array<TemplateAddOn>
343 integrations: Array<TemplateRecord>
344 routes: Array<TemplateRecord>
345 getPackageManagerAddScript: (...args: Array<any>) => string
346 getPackageManagerRunScript: (...args: Array<any>) => string
347 getPackageManagerExecuteScript: (...args: Array<any>) => string
348 relativePath: (...args: Array<any>) => string
349 integrationImportContent: (...args: Array<any>) => string
350 integrationImportCode: (...args: Array<any>) => string | undefined
351 renderTemplate: (content: string) => string
352 ignoreFile: () => never
354​
355type TemplateRenderer = (context: TemplateRenderContext) => string | undefined
356​
357function __escapeXML(value: unknown) {
358 if (value === undefined || value === null) {
359 return ''
360 }
361 return String(value).replace(/[&<>'"]/g, (character) => {
362 switch (character) {
363 case '&':
364 return '&amp;'
365 case '<':
366 return '&lt;'
367 case '>':
368 return '&gt;'
369 case '"':
370 return '&#34;'
371 case "'":
372 return '&#39;'
373 default:
374 return character
375 }
376 })
378​
379export function getManifestTemplateKey(template: string) {
380 let hash = 0x811c9dc5
381 for (let i = 0; i < template.length; i++) {
382 hash ^= template.charCodeAt(i)
383 hash = Math.imul(hash, 0x01000193) >>> 0
384 }
385​
386 return \`\${hash.toString(16).padStart(8, '0')}:\${template.length}\`
388​
389${functions}
390​
391const templateRenderers: Record<string, TemplateRenderer> = {
392${mapEntries}
394​
395export function hasManifestTemplate(template: string) {
396 return getManifestTemplateKey(template) in templateRenderers
398​
399export function renderManifestTemplate(
400 template: string,
401 context: TemplateRenderContext,
402) {
403 const key = getManifestTemplateKey(template)
404 const renderer = templateRenderers[key]
405 if (!renderer) {
406 throw new Error(\`Template \${key} was not precompiled into the manifest\`)
407 }
408 return renderer(context) ?? ''
412​
413function createTemplateRenderersForFrameworkBase(framework) {
414 const renderers = new Map()
415​
416 for (const [file, contents] of Object.entries(framework.base)) {
417 if (file.endsWith('.ejs')) {
418 renderers.set(getTemplateKey(contents), compileTemplate(contents))
419 }
420 }
421​
422 return renderers
424​
425function createTemplateRenderersForAddOn(addOn) {
426 const renderers = new Map()
427​
428 for (const [file, contents] of Object.entries(addOn.files)) {
429 if (file.endsWith('.ejs')) {
430 renderers.set(getTemplateKey(contents), compileTemplate(contents))
431 }
432 }
433​
434 if (addOn.packageTemplate) {
435 renderers.set(
436 getTemplateKey(addOn.packageTemplate),
437 compileTemplate(addOn.packageTemplate),
438 )
439 }
440​
441 if (addOn.readmeIsEjs && addOn.readme) {
442 renderers.set(getTemplateKey(addOn.readme), compileTemplate(addOn.readme))
443 }
444​
445 return renderers
447​
448function stripAddOnForCatalog(addOn) {
449 const {
450 files: _files,
451 deletedFiles: _deletedFiles,
452 packageTemplate: _packageTemplate,
453 readme: _readme,
454 readmeIsEjs: _readmeIsEjs,
455 ...metadata
456 } = addOn
457​
458 return metadata
460​
461function stripFrameworkForCatalog(framework) {
462 const { base: _base, addOns, ...metadata } = framework
463​
464 return {
465 ...metadata,
466 addOns: addOns.map(stripAddOnForCatalog),
467 }
469​
470function toModuleSegment(value) {
471 return value.toLowerCase().replace(/[^a-z0-9_-]+/g, '-')
473​
474function writeGeneratedModule(file, source) {
475 mkdirSync(dirname(file), { recursive: true })
476 writeFileSync(
477 file,
478 `// Generated by scripts/generate-manifest.mjs. Do not edit by hand.\n${source}`,
479 )
481​
482function writeWorkerManifest(manifest) {
483 rmSync(workerOutputDir, { recursive: true, force: true })
484​
485 writeGeneratedModule(
486 join(workerOutputDir, 'catalog.ts'),
487 `import type { ManifestCatalog } from '../../manifest-types.js'
488​
489export const manifestCatalog: ManifestCatalog = ${JSON.stringify(
490 {
491 frameworks: manifest.map(stripFrameworkForCatalog),
492 },
493 null,
494 2,
495 )}\n`,
496 )
497​
498 const frameworkLoaders = []
499 const addOnLoaders = []
500​
501 for (const framework of manifest) {
502 const frameworkSegment = toModuleSegment(framework.id)
503 const frameworkModule = `./frameworks/${frameworkSegment}.js`
504 frameworkLoaders.push([framework.id, frameworkModule])
505​
506 writeGeneratedModule(
507 join(workerOutputDir, 'frameworks', `${frameworkSegment}.ts`),
508 `import type { WorkerFrameworkManifestModule } from '../../../manifest-types.js'
509​
510${createTemplateRendererSource(
511 createTemplateRenderersForFrameworkBase(framework),
512)}\n\nexport const framework = ${JSON.stringify(
513 {
514 id: framework.id,
515 base: framework.base,
516 },
517 null,
518 2,
519 )} satisfies WorkerFrameworkManifestModule['framework']\n`,
520 )
521​
522 for (const addOn of framework.addOns) {
523 const addOnSegment = toModuleSegment(addOn.id)
524 const addOnModule = `./frameworks/${frameworkSegment}/add-ons/${addOnSegment}.js`
525 addOnLoaders.push([framework.id, addOn.id, addOnModule])
526​
527 writeGeneratedModule(
528 join(
529 workerOutputDir,
530 'frameworks',
531 frameworkSegment,
532 'add-ons',
533 `${addOnSegment}.ts`,
534 ),
535 `import type { AddOnCompiled } from '../../../../../types.js'
536​
537${createTemplateRendererSource(
538 createTemplateRenderersForAddOn(addOn),
539)}\n\nexport const addOn = ${JSON.stringify(addOn, null, 2)} satisfies AddOnCompiled\n`,
540 )
541 }
542 }
543​
544 const frameworkLoaderSource = frameworkLoaders
545 .map(
546 ([frameworkId, modulePath]) =>
547 ` ${JSON.stringify(frameworkId)}: () => import(${JSON.stringify(
548 modulePath,
549 )}),`,
550 )
551 .join('\n')
552​
553 const addOnLoaderGroups = manifest
554 .map((framework) => {
555 const entries = addOnLoaders
556 .filter(([frameworkId]) => frameworkId === framework.id)
557 .map(
558 ([, addOnId, modulePath]) =>
559 ` ${JSON.stringify(addOnId)}: () => import(${JSON.stringify(
560 modulePath,
561 )}),`,
562 )
563 .join('\n')
564​
565 return ` ${JSON.stringify(framework.id)}: {\n${entries}\n },`
566 })
567 .join('\n')
568​
569 writeGeneratedModule(
570 join(workerOutputDir, 'bundled-loader.ts'),
571 `const frameworkLoaders = {\n${frameworkLoaderSource}\n}\n\nconst addOnLoaders = {\n${addOnLoaderGroups}\n}\n\nexport function createBundledWorkerManifestLoader() {\n return {\n async loadCatalog() {\n const module = await import('./catalog.js')\n return module.manifestCatalog\n },\n async loadFramework(frameworkId: string) {\n const load = frameworkLoaders[frameworkId as keyof typeof frameworkLoaders]\n if (!load) {\n throw new Error(\`Framework \${frameworkId} not found in bundled worker manifest\`)\n }\n const module = await load()\n return {\n ...module.framework,\n renderManifestTemplate: module.renderManifestTemplate,\n hasManifestTemplate: module.hasManifestTemplate,\n }\n },\n async loadAddOn(frameworkId: string, addOnId: string) {\n const frameworkAddOnLoaders = addOnLoaders[frameworkId as keyof typeof addOnLoaders]\n const load = frameworkAddOnLoaders?.[addOnId as keyof typeof frameworkAddOnLoaders]\n if (!load) {\n throw new Error(\`Add-on \${addOnId} not found in bundled worker manifest for framework \${frameworkId}\`)\n }\n const module = await load()\n return {\n ...module.addOn,\n renderManifestTemplate: module.renderManifestTemplate,\n hasManifestTemplate: module.hasManifestTemplate,\n }\n },\n }\n}\n`,
572 )
574​
575const manifest = [createFramework('react'), createFramework('solid')]
576​
577mkdirSync(dirname(outputFile), { recursive: true })
578writeFileSync(
579 outputFile,
580 `// Generated by scripts/generate-manifest.mjs. Do not edit by hand.\n` +
581 `import type { ManifestFrameworkDefinition } from '../manifest-types.js'\n\n` +
582 createTemplateRendererSource() +
583 '\n' +
584 `export const createManifestFrameworks = (): Array<ManifestFrameworkDefinition> => ${JSON.stringify(
585 manifest,
586 null,
587 2,
588 )}\n`,
590​
591writeWorkerManifest(manifest)