rebuildjs 0.70.46 → 0.71.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rebuildjs",
-	"version": "0.70.46",
+	"version": "0.71.0",
 	"description": "Reactive esbuild...simple hackable alternative to vite for Multi Page Apps",
 	"keywords": [
 		"reactive",
@@ -51,6 +51,14 @@
 			"types": "./server/index.d.ts",
 			"default": "./server/index.js"
 		},
+		"./server/export": {
+			"types": "./server/export/index.d.ts",
+			"default": "./server/export/index.js"
+		},
+		"./server/export/cloudflare": {
+			"types": "./server/export/cloudflare/index.d.ts",
+			"default": "./server/export/cloudflare/index.js"
+		},
 		"./package.json": "./package.json"
 	},
 	"scripts": {
@@ -65,7 +73,6 @@
 	},
 	"dependencies": {
 		"ctx-core": "*",
-		"elysia": "^1.4.27",
 		"fdir": "^6.5.0",
 		"picomatch": "^4.0.3"
 	},
@@ -75,6 +82,7 @@
 	"devDependencies": {
 		"@typescript-eslint/eslint-plugin": "^8.56.1",
 		"@typescript-eslint/parser": "^8.56.1",
+		"bun-types": "^1.3.10",
 		"c8": "^11.0.0",
 		"eslint": "^10.0.2",
 		"esmock": "^2.7.3",

package/server/build/index.js

@@ -276,6 +276,7 @@ export async function rebuildjs_browser__build(config) {
 		sourcemap: 'external',
 		loader: default_loader,
 		publicPath: '/',
+		write: true,
 		...esbuild__config,
 		entryPoints,
 		format: 'esm',
@@ -292,7 +293,10 @@ export async function rebuildjs_browser__build(config) {
 		console.log('browser__build|watch')
 		return esbuild_ctx
 	} else {
-		await build(esbuild_config)
+		const result = await build(esbuild_config)
+		if (!result.metafile) {
+			throw new Error('rebuildjs_browser__build: esbuild.build() produced no metafile')
+		}
 		return undefined
 	}
 }
@@ -333,6 +337,7 @@ export async function rebuildjs_server__build(config) {
 		sourcemap: 'external',
 		loader: default_loader,
 		publicPath: '/',
+		write: true,
 		...esbuild__config,
 		entryPoints,
 		format: 'esm',
@@ -349,7 +354,10 @@ export async function rebuildjs_server__build(config) {
 		console.log('server__build|watch')
 		return esbuild_ctx
 	} else {
-		await build(esbuild_config)
+		const result = await build(esbuild_config)
+		if (!result.metafile) {
+			throw new Error('rebuildjs_server__build: esbuild.build() produced no metafile')
+		}
 		return undefined
 	}
 }

package/server/export/cloudflare/index.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="bun-types" />
+import type { static_export_config_T, static_export_result_T } from '../index.js'
+export declare function cloudflare_export_(
+	config:cloudflare_export_config_T,
+	static_export_:(config:static_export_config_T, app__start:(app?:any)=>Promise<any>)=>Promise<static_export_result_T>,
+	app__start:(app?:any)=>Promise<any>
+):Promise<cloudflare_export_result_T>
+export declare function worker_entry__generate_(
+	dynamic_routes:route_handler_T[]
+):string
+export declare function wrangler_toml__generate_(
+	overrides:Partial<wrangler_config_T>,
+	out_dir?:string
+):string
+export type cloudflare_export_config_T =
+	& static_export_config_T
+	& {
+		dynamic_routes?:route_handler_T[]
+		worker_out?:string
+		wrangler?:Partial<wrangler_config_T>
+	}
+export type cloudflare_export_result_T =
+	& static_export_result_T
+	& {
+		worker_entry_path?:string
+		wrangler_path:string
+	}
+export type route_handler_T = {
+	pattern:string
+	handler:string
+}
+export type wrangler_config_T = {
+	name:string
+	compatibility_date:string
+	vars?:Record<string, string>
+	routes?:{ pattern:string, zone_name?:string }[]
+}

package/server/export/cloudflare/index.js

@@ -0,0 +1,108 @@
+/// <reference types="bun-types" />
+/// <reference types="./index.d.ts" />
+import { build } from 'esbuild'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join, resolve } from 'node:path'
+/**
+ * @param {cloudflare_export_config_T} config
+ * @param {(config:import('../index.js').static_export_config_T, app__start:(app?:any)=>Promise<any>)=>Promise<import('../index.js').static_export_result_T>} static_export_
+ * @param {(app?:any)=>Promise<any>} app__start
+ * @returns {Promise<cloudflare_export_result_T>}
+ */
+export async function cloudflare_export_(config, static_export_, app__start) {
+	const {
+		dynamic_routes = [],
+		worker_out = 'dist/worker',
+		wrangler = {},
+		...static_config
+	} = config
+	// 1. Run static export
+	const static_result = await static_export_(static_config, app__start)
+	// 2. Generate and bundle worker if dynamic routes exist
+	let worker_entry_path
+	if (dynamic_routes.length > 0) {
+		const entry_source = worker_entry__generate_(dynamic_routes)
+		const generated_path = join(worker_out, '_worker.src.js')
+		await mkdir(worker_out, { recursive: true })
+		await writeFile(generated_path, entry_source)
+		// Bundle with esbuild for Cloudflare Workers runtime
+		worker_entry_path = join(worker_out, '_worker.js')
+		await build({
+			entryPoints: [generated_path],
+			bundle: true,
+			format: 'esm',
+			target: 'es2022',
+			platform: 'browser',
+			outfile: worker_entry_path,
+			minify: true,
+		})
+		console.info(`[cloudflare_export] worker bundled: ${worker_entry_path}`)
+	}
+	// 3. Generate wrangler.toml
+	const wrangler_config = wrangler_toml__generate_(wrangler, static_config.out_dir)
+	const wrangler_path = 'wrangler.toml'
+	await writeFile(wrangler_path, wrangler_config)
+	console.info(`[cloudflare_export] wrote ${wrangler_path}`)
+	return {
+		...static_result,
+		worker_entry_path,
+		wrangler_path,
+	}
+}
+/**
+ * @param {route_handler_T[]} dynamic_routes
+ * @returns {string}
+ */
+export function worker_entry__generate_(dynamic_routes) {
+	const imports = []
+	const route_checks = []
+	for (let i = 0; i < dynamic_routes.length; i++) {
+		const { pattern, handler } = dynamic_routes[i]
+		const handler_name = `handler_${i}`
+		imports.push(`import ${handler_name} from '${resolve(handler)}'`)
+		if (pattern.endsWith('/*')) {
+			const prefix = pattern.slice(0, -2)
+			route_checks.push(
+				`\tif (url.pathname.startsWith('${prefix}')) return ${handler_name}(request, env, ctx)`)
+		} else {
+			route_checks.push(
+				`\tif (url.pathname === '${pattern}') return ${handler_name}(request, env, ctx)`)
+		}
+	}
+	return `${imports.join('\n')}
+
+export default {
+	async fetch(request, env, ctx) {
+		const url = new URL(request.url)
+${route_checks.join('\n')}
+		return env.ASSETS.fetch(request)
+	}
+}
+`
+}
+/**
+ * @param {Partial<wrangler_config_T>} overrides
+ * @param {string} [out_dir]
+ * @returns {string}
+ */
+export function wrangler_toml__generate_(overrides, out_dir = 'dist/browser') {
+	const name = overrides.name || 'app'
+	const compatibility_date = overrides.compatibility_date || new Date().toISOString().slice(0, 10)
+	let toml = `name = "${name}"
+compatibility_date = "${compatibility_date}"
+pages_build_output_dir = "${out_dir}"
+`
+	if (overrides.vars) {
+		toml += '\n[vars]\n'
+		for (const [key, val] of Object.entries(overrides.vars)) {
+			toml += `${key} = "${val}"\n`
+		}
+	}
+	if (overrides.routes) {
+		for (const route of overrides.routes) {
+			toml += `\n[[routes]]\npattern = "${route.pattern}"\n`
+			if (route.zone_name) toml += `zone_name = "${route.zone_name}"\n`
+		}
+	}
+	return toml
+}

package/server/export/index.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="bun-types" />
+export declare function static_export_(
+	config:static_export_config_T,
+	app__start:(app?:any)=>Promise<any>
+):Promise<static_export_result_T>
+export declare function static_export__file_path_(
+	route:string,
+	out_dir:string,
+	content_type?:string
+):string
+export type static_export_config_T = {
+	routes?:string[]
+	site_url:string
+	out_dir?:string
+	base_url?:string
+	server_import?:string
+	app?:any
+	sitemap?:boolean
+	extra_routes?:string[]
+	url_rewrite?:boolean
+	incremental?:boolean
+	manifest?:boolean
+	clean?:boolean
+	on_export?:(route:string, file:string)=>void
+}
+export type static_export_result_T = {
+	exported:string[]
+	errors:string[]
+}

package/server/export/index.js

@@ -0,0 +1,168 @@
+/// <reference types="bun-types" />
+/// <reference types="./index.d.ts" />
+import { mkdir, readFile, rm, unlink, writeFile } from 'node:fs/promises'
+import { dirname, extname, join } from 'node:path'
+import { port_ } from '../app/index.js'
+import { app_ctx } from '../ctx/index.js'
+/**
+ * @param {static_export_config_T} config
+ * @param {(app?:any)=>Promise<any>} app__start
+ * @returns {Promise<static_export_result_T>}
+ */
+export async function static_export_(config, app__start) {
+	const {
+		site_url,
+		out_dir = 'dist/browser',
+		server_import = './dist/server/index.js',
+		sitemap = true,
+		url_rewrite = true,
+		incremental = false,
+		manifest: use_manifest = incremental,
+		clean = false,
+		on_export,
+	} = config
+	let { routes = [], extra_routes = [] } = config
+	const site_origin = site_url.replace(/\/$/, '')
+	const exported = []
+	const errors = []
+	let app = config.app
+	let we_started = false
+	let base_url = config.base_url
+	try {
+		if (base_url) {
+			// Connect to already-running external server
+			base_url = base_url.replace(/\/$/, '')
+			console.info(`[static_export] using external server: ${base_url}`)
+		} else if (!app) {
+			// Start server internally
+			const mod = await import(server_import)
+			app = typeof mod.default === 'function' ? await mod.default() : mod.default
+			await app__start(app)
+			we_started = true
+			base_url = `http://localhost:${port_(app_ctx)}`
+			console.info(`[static_export] server running on ${base_url}`)
+		} else {
+			base_url = `http://localhost:${port_(app_ctx)}`
+			console.info(`[static_export] using provided app on ${base_url}`)
+		}
+		console.info(`[static_export] site_url: ${site_origin}`)
+		// Clean output directory if requested
+		if (clean) {
+			await rm(out_dir, { recursive: true, force: true })
+		}
+		// Discover routes from sitemap
+		if (sitemap) {
+			try {
+				const res = await fetch(`${base_url}/sitemap.xml`)
+				if (res.ok) {
+					const xml = await res.text()
+					for (const m of xml.matchAll(/<loc>https?:\/\/[^<]+<\/loc>/g)) {
+						const url = m[0].replace(/<\/?loc>/g, '')
+						const path = new URL(url).pathname
+						const route = path === '' ? '/' : path
+						if (!routes.includes(route)) {
+							routes.push(route)
+						}
+					}
+					console.info(`[static_export] discovered ${routes.length} routes from sitemap`)
+				}
+			} catch {
+				console.warn('[static_export] sitemap fetch failed, using explicit routes only')
+			}
+		}
+		// Load previous manifest for stale file cleanup
+		const manifest_path = join(out_dir, '.export-manifest.json')
+		let prev_manifest = []
+		if (use_manifest) {
+			try {
+				prev_manifest = JSON.parse(await readFile(manifest_path, 'utf-8'))
+			} catch {
+				// No previous manifest
+			}
+		}
+		// Merge routes and extra_routes
+		const all_routes = [...routes, ...extra_routes]
+		// Export each route (streaming — write as we go)
+		for (const route of all_routes) {
+			const url = base_url + route
+			try {
+				const res = await fetch(url)
+				if (!res.ok) {
+					console.error(`[static_export] ${route} -> ${res.status} ${res.statusText}`)
+					errors.push(route)
+					continue
+				}
+				const content_type = res.headers.get('content-type') ?? ''
+				let body = await res.text()
+				if (url_rewrite) {
+					body = body.replaceAll(base_url, site_origin)
+				}
+				const file_path = static_export__file_path_(route, out_dir, content_type)
+				// Incremental: skip if content unchanged
+				if (incremental) {
+					try {
+						const existing = await readFile(file_path, 'utf-8')
+						if (existing === body) {
+							exported.push(file_path)
+							continue
+						}
+					} catch {
+						// File doesn't exist yet — write it
+					}
+				}
+				await mkdir(dirname(file_path), { recursive: true })
+				await writeFile(file_path, body)
+				exported.push(file_path)
+				on_export?.(route, file_path)
+				console.info(`[static_export] ${route} -> ${file_path} (${body.length} bytes)`)
+			} catch (err) {
+				console.error(`[static_export] ${route} -> ${err.message}`)
+				errors.push(route)
+			}
+		}
+		// Manifest: write new manifest and delete stale files
+		if (use_manifest) {
+			await mkdir(dirname(manifest_path), { recursive: true })
+			await writeFile(manifest_path, JSON.stringify(exported, null, '\t'))
+			const stale = prev_manifest.filter(f=>!exported.includes(f))
+			for (const file of stale) {
+				try {
+					await unlink(file)
+					console.info(`[static_export] deleted stale: ${file}`)
+				} catch {
+					// Already gone
+				}
+			}
+		}
+		if (errors.length > 0) {
+			console.warn(`[static_export] completed with ${errors.length} error(s)`)
+		} else {
+			console.info(`[static_export] exported ${exported.length} files`)
+		}
+	} finally {
+		if (we_started && app?.stop) {
+			app.stop()
+		}
+	}
+	return { exported, errors }
+}
+/**
+ * @param {string} route
+ * @param {string} out_dir
+ * @param {string} [content_type]
+ * @returns {string}
+ */
+export function static_export__file_path_(route, out_dir, content_type) {
+	const ext = extname(route)
+	// If the server responded with HTML content-type, treat as HTML page
+	const is_html = content_type ? content_type.includes('text/html') : !ext || ext === '.html'
+	if (ext && !is_html) {
+		// Raw file (robots.txt, sitemap.xml, rss.xml, etc.)
+		return join(out_dir, route)
+	}
+	// HTML route -> clean URL directory structure
+	if (route === '/') {
+		return join(out_dir, 'index.html')
+	}
+	return join(out_dir, route, 'index.html')
+}

package/server/index.d.ts

@@ -9,3 +9,5 @@ export * from './metafile_l0/index.js'
 export * from './middleware/index.js'
 export * from './rebuildjs_browser/index.js'
 export * from './rebuildjs_server/index.js'
+export * from './route/index.js'
+export * from './static/index.js'

package/server/index.js

@@ -9,3 +9,5 @@ export * from './metafile_l0/index.js'
 export * from './middleware/index.js'
 export * from './rebuildjs_browser/index.js'
 export * from './rebuildjs_server/index.js'
+export * from './route/index.js'
+export * from './static/index.js'

package/server/route/index.d.ts

@@ -0,0 +1,12 @@
+/// <reference lib="dom" />
+import type { middleware_ctx_T, request_ctx_T } from '../ctx/index.js'
+export declare function html_route_<framework_ctx_T>(
+	middleware_ctx:middleware_ctx_T,
+	page_:($p:{ ctx:request_ctx_T })=>({ toString():string }|ReadableStream<string>),
+	request_ctx__ensure:(middleware_ctx:middleware_ctx_T, framework_ctx:framework_ctx_T)=>request_ctx_T,
+	response_init?:ResponseInit
+):(framework_ctx:framework_ctx_T)=>Response
+export declare function html_response__new(
+	html_OR_stream:string|ReadableStream,
+	response_init?:ResponseInit
+):Response

package/server/route/index.js

@@ -0,0 +1,52 @@
+/// <reference types="./index.d.ts" />
+// TODO: use built-in TextEncoderStream when bunjs implements TextEncoderStream
+// See https://github.com/oven-sh/bun/issues/5648
+// See https://github.com/oven-sh/bun/issues/159
+import { TextEncoderStream } from 'ctx-core/stream'
+import { request_ctx__new } from '../ctx/index.js'
+/**
+ * @param {middleware_ctx_T}middleware_ctx
+ * @param {($p:{ ctx:request_ctx_T })=>(string|ReadableStream<string|Uint8Array>)}page_
+ * @param {(middleware_ctx:middleware_ctx_T, framework_ctx:any)=>request_ctx_T}request_ctx__ensure
+ * @param {ResponseInit}[response_init]
+ * @returns {(framework_ctx:any)=>Response}
+ */
+export function html_route_(
+	middleware_ctx,
+	page_,
+	request_ctx__ensure,
+	response_init
+) {
+	return framework_ctx=>
+		html_response__new(
+			page_({
+				ctx: request_ctx__ensure(middleware_ctx, framework_ctx)
+			}),
+			response_init)
+}
+/**
+ * @param {string|ReadableStream}html_OR_stream
+ * @param {ResponseInit}[response_init]
+ * @returns {Response}
+ */
+export function html_response__new(
+	html_OR_stream,
+	response_init
+) {
+	const headers = new Headers(response_init?.headers)
+	headers.set('Content-Type', 'text/html;charset=UTF-8')
+	return new Response(
+		html_OR_stream.pipeTo
+			? html_OR_stream.pipeThrough(new TextEncoderStream())
+			: new ReadableStream({
+				start(controller) {
+					controller.enqueue('' + html_OR_stream)
+					controller.close()
+				}
+			}),
+		{
+			...(response_init ?? {}),
+			headers
+		}
+	)
+}

package/server/static/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="bun-types" />
+export declare function static_middleware__routes_(
+	config?:static_middleware__config_T
+):Promise<static_middleware__route_T[]>
+export type static_middleware__config_T = {
+	headers_?:(url_path:string, content_type:string, path:string)=>Record<string, string>
+}
+export type static_middleware__route_T = {
+	url_path:string
+	handler:()=>Response
+}

package/server/static/index.js

@@ -0,0 +1,37 @@
+/// <reference types="bun-types" />
+/// <reference types="./index.d.ts" />
+import { file, Glob } from 'bun'
+import { ext_R_mime } from 'ctx-core/http'
+import { extname, join } from 'node:path'
+import { browser_path_ } from '../app/index.js'
+import { app_ctx } from '../ctx/index.js'
+/**
+ * @param {static_middleware__config_T}[config]
+ * @returns {Promise<{get:(path:string, handler:Function)=>void}>}
+ */
+export async function static_middleware__routes_(config) {
+	const routes = []
+	const glob = new Glob('**')
+	for await (const relative_path of glob.scan(browser_path_(app_ctx))) {
+		const url_path = join('/', relative_path)
+		const content_type = ext_R_mime[extname(relative_path)] ?? 'text/plain'
+		const path = join(browser_path_(app_ctx), relative_path)
+		const headers = (config?.headers_ ?? (()=>({})))(
+			url_path,
+			content_type,
+			path)
+		routes.push({
+			url_path,
+			handler: ()=>{
+				const file_ref = file(path)
+				return new Response(file_ref.size ? file_ref.stream() : '', {
+					headers: {
+						'Content-Type': content_type,
+						...headers,
+					}
+				})
+			}
+		})
+	}
+	return routes
+}