Open History to see the last commit
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 },
57}
58
59function readJson(file) {
60 return JSON.parse(readFileSync(file, 'utf8'))
61}
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
74}
75
76function toCleanPath(file, baseDir) {
77 return relative(baseDir, file).replace(/\\/g, '/')
78}
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
101}
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 }
116}
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
177}
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 }
193}
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}`
203}
204
205function registerTemplate(template) {
206 const key = getTemplateKey(template)
207 if (!templateRenderers.has(key)) {
208 templateRenderers.set(key, compileTemplate(template))
209 }
210}
211
212function stripSemicolon(code) {
213 return code.replace(/;(\s*$)/, '$1')
214}
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')
263}
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>
324}
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
353}
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 '&'
365 case '<':
366 return '<'
367 case '>':
368 return '>'
369 case '"':
370 return '"'
371 case "'":
372 return '''
373 default:
374 return character
375 }
376 })
377}
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}\`
387}
388
389${functions}
390
391const templateRenderers: Record<string, TemplateRenderer> = {
392${mapEntries}
393}
394
395export function hasManifestTemplate(template: string) {
396 return getManifestTemplateKey(template) in templateRenderers
397}
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) ?? ''
409}
410`
411}
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
423}
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
446}
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
459}
460
461function stripFrameworkForCatalog(framework) {
462 const { base: _base, addOns, ...metadata } = framework
463
464 return {
465 ...metadata,
466 addOns: addOns.map(stripAddOnForCatalog),
467 }
468}
469
470function toModuleSegment(value) {
471 return value.toLowerCase().replace(/[^a-z0-9_-]+/g, '-')
472}
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 )
480}
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 )
573}
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`,
589)
590
591writeWorkerManifest(manifest)