Open History to see the last commit
1import { createApp as createEdgeApp } from './edge-create-app.js'
2import {
3 finalizeAddOns as finalizeBaseAddOns,
4 getAllAddOns,
5 loadRemoteAddOn,
6 populateAddOnOptionsDefaults,
7} from './edge-add-ons.js'
8import { registerTemplateRenderer } from './edge-render.js'
9import { createMemoryEnvironment } from './edge-environment.js'
10import { CONFIG_FILE } from './constants.js'
11import {
12 DEFAULT_PACKAGE_MANAGER,
13 SUPPORTED_PACKAGE_MANAGERS,
14 getPackageManagerExecuteCommand,
15 getPackageManagerInstallCommand,
16 getPackageManagerScriptCommand,
17 translateExecuteCommand,
18} from './package-manager.js'
19
20import type {
21 ManifestAddOnChunk,
22 ManifestAddOnMetadata,
23 ManifestFrameworkChunk,
24 ManifestFrameworkMetadata,
25 ManifestTemplateModule,
26 WorkerManifestLoader,
27 WorkerManifestModuleLoader,
28} from './manifest-types.js'
29import type { TemplateRenderContext } from './edge-render.js'
30import type {
31 AddOn,
32 Environment,
33 Framework,
34 Options,
35} from './types.js'
36import type { MemoryEnvironmentOutput } from './edge-environment.js'
37
38export {
39 assertAddOnSupportedByBundler,
40 getBundlers,
41 getDefaultBundler,
42 isAddOnSupportedByBundler,
43 normalizeAndValidateBundlerOptions,
44 resolveBundler,
45 VITE_BUNDLER,
46} from './build-tools.js'
47
48export function createWorkerManifestLoader(
49 moduleLoader: WorkerManifestModuleLoader,
50): WorkerManifestLoader {
51 return {
52 async loadCatalog() {
53 return moduleLoader.loadCatalog()
54 },
55 async loadFramework(frameworkId: string) {
56 const module = await moduleLoader.loadFramework(frameworkId)
57 return {
58 ...module.framework,
59 renderManifestTemplate: module.renderManifestTemplate,
60 hasManifestTemplate: module.hasManifestTemplate,
61 }
62 },
63 async loadAddOn(frameworkId: string, addOnId: string) {
64 const module = await moduleLoader.loadAddOn(frameworkId, addOnId)
65 return {
66 ...module.addOn,
67 renderManifestTemplate: module.renderManifestTemplate,
68 hasManifestTemplate: module.hasManifestTemplate,
69 }
70 },
71 }
72}
73
74function createChunkRenderer(chunks: () => Array<ManifestTemplateModule>) {
75 return (template: string, context: TemplateRenderContext) => {
76 for (const chunk of chunks()) {
77 if (chunk.hasManifestTemplate && !chunk.hasManifestTemplate(template)) {
78 continue
79 }
80
81 try {
82 return chunk.renderManifestTemplate(template, context)
83 } catch (error) {
84 if (chunk.hasManifestTemplate) {
85 throw error
86 }
87 }
88 }
89
90 throw new Error('Template was not loaded by the worker manifest provider')
91 }
92}
93
94export type WorkerCreateAPI = {
95 getFrameworks: () => Promise<Array<Framework>>
96 getFrameworkById: (id: string) => Promise<Framework | undefined>
97 getFrameworkByName: (name: string) => Promise<Framework | undefined>
98 getAllAddOns: typeof getAllAddOns
99 finalizeAddOns: (
100 framework: Framework,
101 mode: string,
102 chosenAddOnIDs: Array<string>,
103 bundlerId?: string,
104 ) => Promise<Array<AddOn>>
105 populateAddOnOptionsDefaults: typeof populateAddOnOptionsDefaults
106 createApp: (environment: Environment, options: Options) => Promise<void>
107}
108
109export function createWorkerCreate(
110 manifestLoader: WorkerManifestLoader,
111): WorkerCreateAPI {
112 let frameworksPromise: Promise<Array<Framework>> | undefined
113 const frameworkChunks = new Map<string, Promise<ManifestFrameworkChunk>>()
114 const addOnChunks = new Map<string, Promise<ManifestAddOnChunk>>()
115 const loadedRendererChunks = new Map<string, Array<ManifestTemplateModule>>()
116 const addOnFrameworkIds = new WeakMap<AddOn, string>()
117
118 function getRendererChunks(frameworkId: string) {
119 const chunks = loadedRendererChunks.get(frameworkId)
120 if (chunks) {
121 return chunks
122 }
123
124 const nextChunks: Array<ManifestTemplateModule> = []
125 loadedRendererChunks.set(frameworkId, nextChunks)
126 return nextChunks
127 }
128
129 function registerRendererChunk(
130 frameworkId: string,
131 chunk: ManifestTemplateModule,
132 ) {
133 const chunks = getRendererChunks(frameworkId)
134 if (!chunks.includes(chunk)) {
135 chunks.push(chunk)
136 }
137 }
138
139 function getRenderer(frameworkId: string) {
140 return createChunkRenderer(() => getRendererChunks(frameworkId))
141 }
142
143 async function loadFrameworkChunk(frameworkId: string) {
144 let promise = frameworkChunks.get(frameworkId)
145 if (!promise) {
146 promise = manifestLoader
147 .loadFramework(frameworkId)
148 .then((chunk) => {
149 registerRendererChunk(frameworkId, chunk)
150 return chunk
151 })
152 .catch((error: unknown) => {
153 frameworkChunks.delete(frameworkId)
154 throw error
155 })
156 frameworkChunks.set(frameworkId, promise)
157 }
158
159 return promise
160 }
161
162 async function loadAddOnChunk(frameworkId: string, addOnId: string) {
163 const key = `${frameworkId}:${addOnId}`
164 let promise = addOnChunks.get(key)
165 if (!promise) {
166 promise = manifestLoader
167 .loadAddOn(frameworkId, addOnId)
168 .then((chunk) => {
169 registerRendererChunk(frameworkId, chunk)
170 return chunk
171 })
172 .catch((error: unknown) => {
173 addOnChunks.delete(key)
174 throw error
175 })
176 addOnChunks.set(key, promise)
177 }
178
179 return promise
180 }
181
182 function createAddOnFromChunk(
183 frameworkId: string,
184 chunk: ManifestAddOnChunk,
185 ): AddOn {
186 const {
187 renderManifestTemplate: _renderManifestTemplate,
188 hasManifestTemplate: _hasManifestTemplate,
189 ...compiled
190 } = chunk
191
192 const addOn: AddOn = {
193 ...compiled,
194 getFiles: () => Promise.resolve(Object.keys(compiled.files)),
195 getFileContents: (path: string) => Promise.resolve(compiled.files[path]),
196 getDeletedFiles: () => Promise.resolve(compiled.deletedFiles),
197 }
198 addOnFrameworkIds.set(addOn, frameworkId)
199 return addOn
200 }
201
202 async function materializeAddOn(addOn: AddOn): Promise<AddOn> {
203 const frameworkId = addOnFrameworkIds.get(addOn)
204 if (!frameworkId) {
205 return addOn
206 }
207
208 const chunk = await loadAddOnChunk(frameworkId, addOn.id)
209 return createAddOnFromChunk(frameworkId, chunk)
210 }
211
212 function createLazyAddOn(
213 frameworkId: string,
214 metadata: ManifestAddOnMetadata,
215 ): AddOn {
216 const addOn: AddOn = {
217 ...metadata,
218 files: {},
219 deletedFiles: [],
220 getFiles: async () => {
221 const chunk = await loadAddOnChunk(frameworkId, metadata.id)
222 return Object.keys(chunk.files)
223 },
224 getFileContents: async (path: string) => {
225 const chunk = await loadAddOnChunk(frameworkId, metadata.id)
226 return chunk.files[path]
227 },
228 getDeletedFiles: async () => {
229 const chunk = await loadAddOnChunk(frameworkId, metadata.id)
230 return chunk.deletedFiles
231 },
232 }
233
234 addOnFrameworkIds.set(addOn, frameworkId)
235 return addOn
236 }
237
238 function createFrameworkFromMetadata(
239 metadata: ManifestFrameworkMetadata,
240 ): Framework {
241 const addOns = metadata.addOns.map((addOn) =>
242 createLazyAddOn(metadata.id, addOn),
243 )
244 const { addOns: _addOns, ...frameworkMetadata } = metadata
245
246 const framework: Framework = {
247 ...frameworkMetadata,
248 getFiles: async () => {
249 const chunk = await loadFrameworkChunk(metadata.id)
250 return Object.keys(chunk.base)
251 },
252 getFileContents: async (path: string) => {
253 const chunk = await loadFrameworkChunk(metadata.id)
254 return chunk.base[path]
255 },
256 getDeletedFiles: () => Promise.resolve([]),
257 getAddOns: () => addOns,
258 }
259
260 registerTemplateRenderer(framework, getRenderer(metadata.id))
261 return framework
262 }
263
264 async function getFrameworks() {
265 frameworksPromise ??= manifestLoader
266 .loadCatalog()
267 .then((catalog) => catalog.frameworks.map(createFrameworkFromMetadata))
268
269 return frameworksPromise
270 }
271
272 async function getFrameworkById(id: string) {
273 const frameworks = await getFrameworks()
274 const frameworkId = id === 'react-cra' ? 'react' : id
275 return frameworks.find((framework) => framework.id === frameworkId)
276 }
277
278 async function getFrameworkByName(name: string) {
279 const frameworks = await getFrameworks()
280 return frameworks.find(
281 (framework) => framework.name.toLowerCase() === name.toLowerCase(),
282 )
283 }
284
285 async function finalizeAddOns(
286 framework: Framework,
287 mode: string,
288 chosenAddOnIDs: Array<string>,
289 bundlerId?: string,
290 ) {
291 const finalized = await finalizeBaseAddOns(framework, mode, chosenAddOnIDs, bundlerId)
292 return Promise.all(finalized.map(materializeAddOn))
293 }
294
295 async function createApp(environment: Environment, options: Options) {
296 await loadFrameworkChunk(options.framework.id)
297 registerTemplateRenderer(
298 options.framework,
299 getRenderer(options.framework.id),
300 )
301
302 const chosenAddOns = await Promise.all(
303 options.chosenAddOns.map(materializeAddOn),
304 )
305
306 await createEdgeApp(environment, {
307 ...options,
308 chosenAddOns,
309 })
310 }
311
312 return {
313 getFrameworks,
314 getFrameworkById,
315 getFrameworkByName,
316 getAllAddOns,
317 finalizeAddOns,
318 populateAddOnOptionsDefaults,
319 createApp,
320 }
321}
322
323export {
324 CONFIG_FILE,
325 DEFAULT_PACKAGE_MANAGER,
326 SUPPORTED_PACKAGE_MANAGERS,
327 createMemoryEnvironment,
328 getPackageManagerExecuteCommand,
329 getPackageManagerInstallCommand,
330 getPackageManagerScriptCommand,
331 loadRemoteAddOn,
332 populateAddOnOptionsDefaults,
333 translateExecuteCommand,
334 type MemoryEnvironmentOutput,
335}
336
337export type {
338 AddOn,
339 AddOnOption,
340 AddOnOptions,
341 AddOnSelectOption,
342 AddOnSelection,
343 Environment,
344 FileBundleHandler,
345 Framework,
346 FrameworkDefinition,
347 BundlerDefinition,
348 Options,
349 SerializedOptions,
350 Starter,
351 StarterCompiled,
352} from './types.js'
353export type { PackageManager } from './package-manager.js'
354export type {
355 ManifestAddOnChunk,
356 ManifestAddOnMetadata,
357 ManifestCatalog,
358 ManifestFrameworkChunk,
359 ManifestFrameworkMetadata,
360 ManifestTemplateModule,
361 WorkerAddOnManifestModule,
362 WorkerFrameworkManifestModule,
363 WorkerManifestModuleLoader,
364 WorkerManifestLoader,
365} from './manifest-types.js'