@ecopages/core 0.2.0-alpha.23 → 0.2.0-alpha.25

package/src/build/runtime-build-executor.test.ts

@@ -0,0 +1,81 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import { createAppBuildManifest } from './build-manifest.ts';
+import { setAppBuildAdapter, setAppBuildManifest, ViteHostBuildAdapter } from './build-adapter.ts';
+import { createAppBuildExecutor, DevBuildCoordinator } from './dev-build-coordinator.ts';
+import { EsbuildBuildAdapter } from './esbuild-build-adapter.ts';
+import { installAppRuntimeBuildExecutor } from './runtime-build-executor.ts';
+
+test('installAppRuntimeBuildExecutor replaces Bun-only coordinator state on the Vite-host path', async () => {
+	const staleBunCoordinator = new DevBuildCoordinator(new EsbuildBuildAdapter());
+	const appConfig = {
+		runtime: {
+			buildExecutor: staleBunCoordinator,
+		},
+		loaders: new Map(),
+	} as any;
+
+	setAppBuildAdapter(appConfig, new ViteHostBuildAdapter());
+	setAppBuildManifest(
+		appConfig,
+		createAppBuildManifest({
+			runtimePlugins: [],
+		}),
+	);
+
+	const executor = installAppRuntimeBuildExecutor(appConfig, {
+		development: true,
+	});
+
+	assert.notEqual(executor, staleBunCoordinator);
+	assert.ok(!(executor instanceof DevBuildCoordinator));
+
+	await assert.rejects(
+		executor.build({
+			entrypoints: ['/tmp/entry.ts'],
+			root: '/tmp',
+			outdir: '/tmp/out',
+			target: 'browser',
+			format: 'esm',
+			sourcemap: 'none',
+			splitting: false,
+			minify: false,
+		}),
+		/Vite-hosted builds are owned by the host runtime/,
+	);
+});
+
+test('installAppRuntimeBuildExecutor keeps Bun-native development execution off the raw adapter path', () => {
+	const adapter = new EsbuildBuildAdapter();
+	const appConfig = {
+		runtime: {},
+		loaders: new Map(),
+	} as any;
+
+	setAppBuildAdapter(appConfig, adapter);
+	setAppBuildManifest(
+		appConfig,
+		createAppBuildManifest({
+			runtimePlugins: [],
+		}),
+	);
+
+	const executor = installAppRuntimeBuildExecutor(appConfig, {
+		development: true,
+	});
+
+	assert.notEqual(executor, adapter);
+	assert.notEqual(appConfig.runtime.buildExecutor, adapter);
+	assert.equal(appConfig.runtime.buildExecutor, executor);
+});
+
+test('createAppBuildExecutor keeps Bun-native production execution on the plain Bun adapter boundary', () => {
+	const adapter = new EsbuildBuildAdapter();
+	const executor = createAppBuildExecutor({
+		development: false,
+	});
+
+	assert.notEqual(executor, adapter);
+	assert.ok(!(executor instanceof DevBuildCoordinator));
+	assert.equal('ownership' in executor ? executor.ownership : undefined, 'bun-native');
+});

package/src/build/runtime-build-executor.ts

@@ -0,0 +1,40 @@
+import type { EcoPagesAppConfig } from '../types/internal-types.ts';
+import {
+	getAppBuildAdapter,
+	getAppBuildExecutor,
+	getAppBuildOwnership,
+	getAppServerBuildPlugins,
+	setAppBuildExecutor,
+	type BuildExecutor,
+} from './build-adapter.ts';
+import { createOrReuseAppBuildExecutor, withBuildExecutorPlugins } from './dev-build-coordinator.ts';
+
+/**
+ * Installs the app-owned runtime build executor for one app instance.
+ *
+ * @remarks
+ * This is the single runtime executor boundary for adapter-owned startup.
+ * Bun-native ownership may reuse `DevBuildCoordinator` in development, while
+ * Vite-host ownership stays on a plain host-owned executor boundary with no
+ * Bun-specific coordination policy.
+ */
+export function installAppRuntimeBuildExecutor(
+	appConfig: EcoPagesAppConfig,
+	options: {
+		development: boolean;
+	},
+): BuildExecutor {
+	const buildOwnership = getAppBuildOwnership(appConfig);
+	const buildExecutor =
+		buildOwnership === 'bun-native'
+			? createOrReuseAppBuildExecutor({
+					development: options.development,
+					adapter: getAppBuildAdapter(appConfig),
+					currentExecutor: getAppBuildExecutor(appConfig),
+					getPlugins: () => getAppServerBuildPlugins(appConfig),
+				})
+			: withBuildExecutorPlugins(getAppBuildAdapter(appConfig), () => getAppServerBuildPlugins(appConfig));
+
+	setAppBuildExecutor(appConfig, buildExecutor);
+	return buildExecutor;
+}

package/src/build/runtime-specifier-alias-plugin.test.ts

@@ -0,0 +1,67 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import type { EcoBuildOnResolveResult } from './build-types.ts';
+import { createRuntimeSpecifierAliasPlugin } from './runtime-specifier-alias-plugin.ts';
+import { collectRuntimeSpecifierAliasMap, rewriteRuntimeSpecifierAliases } from './runtime-specifier-aliases.ts';
+
+test('createRuntimeSpecifierAliasPlugin resolves mapped specifiers as externals', async () => {
+	const registrations: Array<{
+		filter: RegExp;
+		callback: (args: {
+			path: string;
+		}) => EcoBuildOnResolveResult | undefined | Promise<EcoBuildOnResolveResult | undefined>;
+	}> = [];
+	const plugin = createRuntimeSpecifierAliasPlugin(
+		{
+			react: '/assets/vendors/react.js',
+			'react-dom/client': '/assets/vendors/react-dom.js',
+		},
+		{ name: 'test-runtime-alias' },
+	);
+
+	assert.ok(plugin);
+	assert.equal(plugin.name, 'test-runtime-alias');
+
+	plugin.setup({
+		onResolve(options, callback) {
+			registrations.push({ filter: options.filter, callback });
+		},
+		onLoad() {},
+		module() {},
+	});
+
+	assert.equal(registrations.length, 1);
+	assert.equal(registrations[0]?.filter.test('react'), true);
+	assert.deepEqual(await registrations[0]?.callback({ path: 'react' }), {
+		path: '/assets/vendors/react.js',
+		external: true,
+	});
+	assert.equal(await registrations[0]?.callback({ path: 'unknown' }), undefined);
+});
+
+test('createRuntimeSpecifierAliasPlugin returns null for an empty specifier map', () => {
+	assert.equal(createRuntimeSpecifierAliasPlugin(new Map()), null);
+});
+
+test('createRuntimeSpecifierAliasPlugin exposes alias data for emitted-JS fallback rewriting', () => {
+	const plugin = createRuntimeSpecifierAliasPlugin(
+		{
+			react: '/assets/vendors/react.js',
+			'react/jsx-dev-runtime': '/assets/vendors/react-jsx-dev-runtime.js',
+		},
+		{ name: 'test-runtime-alias' },
+	);
+
+	assert.ok(plugin);
+
+	const aliasMap = collectRuntimeSpecifierAliasMap([plugin]);
+	assert.equal(aliasMap.get('react'), '/assets/vendors/react.js');
+	assert.equal(aliasMap.get('react/jsx-dev-runtime'), '/assets/vendors/react-jsx-dev-runtime.js');
+	assert.equal(
+		rewriteRuntimeSpecifierAliases(
+			'import { jsxDEV } from "react/jsx-dev-runtime";\nconst snippet = "import { jsxDEV } from \'react/jsx-dev-runtime\'";',
+			aliasMap,
+		),
+		'import { jsxDEV } from "/assets/vendors/react-jsx-dev-runtime.js";\nconst snippet = "import { jsxDEV } from \'react/jsx-dev-runtime\'";',
+	);
+});

package/src/build/runtime-specifier-alias-plugin.ts

@@ -0,0 +1,62 @@
+import type { EcoBuildPlugin } from './build-types.ts';
+import { attachRuntimeSpecifierAliasMap } from './runtime-specifier-aliases.ts';
+
+type RuntimeSpecifierMap = ReadonlyMap<string, string> | Record<string, string>;
+
+/**
+ * Normalizes runtime specifier input into a read-only map shape.
+ */
+function toRuntimeSpecifierMap(specifierMap: RuntimeSpecifierMap): ReadonlyMap<string, string> {
+	return specifierMap instanceof Map ? specifierMap : new Map(Object.entries(specifierMap));
+}
+
+/**
+ * Escapes a literal specifier for inclusion in a regular expression.
+ */
+function escapeRegExp(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Creates a build plugin that aliases runtime bare specifiers to concrete URLs.
+ *
+ * @remarks
+ * This helper is used when browser-target builds must preserve integration-owned
+ * runtime specifier semantics while letting the bundler treat the mapped URLs as
+ * external runtime assets.
+ */
+export function createRuntimeSpecifierAliasPlugin(
+	specifierMapInput: RuntimeSpecifierMap,
+	options?: {
+		name?: string;
+		external?: boolean;
+	},
+): EcoBuildPlugin | null {
+	const specifierMap = toRuntimeSpecifierMap(specifierMapInput);
+
+	if (specifierMap.size === 0) {
+		return null;
+	}
+
+	const filter = new RegExp(`^(${Array.from(specifierMap.keys()).map(escapeRegExp).join('|')})$`);
+
+	return attachRuntimeSpecifierAliasMap(
+		{
+			name: options?.name ?? 'runtime-specifier-alias',
+			setup(build) {
+				build.onResolve({ filter }, (args) => {
+					const mappedPath = specifierMap.get(args.path);
+					if (!mappedPath) {
+						return undefined;
+					}
+
+					return {
+						path: mappedPath,
+						external: options?.external ?? true,
+					};
+				});
+			},
+		},
+		specifierMap,
+	);
+}

package/src/build/runtime-specifier-aliases.ts

@@ -0,0 +1,135 @@
+import type { EcoBuildPlugin } from './build-types.ts';
+import { parseSync } from 'oxc-parser';
+
+const RUNTIME_SPECIFIER_ALIAS_MAP = Symbol('ecopages.runtimeSpecifierAliasMap');
+
+type RuntimeSpecifierAliasPlugin = EcoBuildPlugin & {
+	[RUNTIME_SPECIFIER_ALIAS_MAP]?: ReadonlyMap<string, string>;
+};
+
+export function attachRuntimeSpecifierAliasMap(
+	plugin: EcoBuildPlugin,
+	specifierMap: ReadonlyMap<string, string>,
+): EcoBuildPlugin {
+	(plugin as RuntimeSpecifierAliasPlugin)[RUNTIME_SPECIFIER_ALIAS_MAP] = specifierMap;
+	return plugin;
+}
+
+export function getRuntimeSpecifierAliasMap(plugin: EcoBuildPlugin): ReadonlyMap<string, string> | undefined {
+	return (plugin as RuntimeSpecifierAliasPlugin)[RUNTIME_SPECIFIER_ALIAS_MAP];
+}
+
+export function collectRuntimeSpecifierAliasMap(plugins: EcoBuildPlugin[] | undefined): ReadonlyMap<string, string> {
+	const merged = new Map<string, string>();
+
+	for (const plugin of plugins ?? []) {
+		const specifierMap = getRuntimeSpecifierAliasMap(plugin);
+		if (!specifierMap) {
+			continue;
+		}
+
+		for (const [specifier, mappedPath] of specifierMap.entries()) {
+			if (!merged.has(specifier)) {
+				merged.set(specifier, mappedPath);
+			}
+		}
+	}
+
+	return merged;
+}
+
+export function rewriteRuntimeSpecifierAliases(code: string, specifierMap: ReadonlyMap<string, string>): string {
+	if (specifierMap.size === 0) {
+		return code;
+	}
+
+	type Edit = {
+		start: number;
+		end: number;
+		replacement: string;
+	};
+
+	const edits: Edit[] = [];
+
+	try {
+		const result = parseSync('runtime-alias-output.js', code, {
+			sourceType: 'module',
+			lang: 'js',
+		});
+
+		const queueReplacement = (source: { value?: string; start: number; end: number }) => {
+			if (typeof source.value !== 'string') {
+				return;
+			}
+
+			const mappedPath = specifierMap.get(source.value);
+			if (!mappedPath) {
+				return;
+			}
+
+			const quote = code[source.start] === "'" ? "'" : '"';
+			edits.push({
+				start: source.start,
+				end: source.end,
+				replacement: `${quote}${mappedPath}${quote}`,
+			});
+		};
+
+		const walk = (node: unknown) => {
+			if (!node || typeof node !== 'object') {
+				return;
+			}
+
+			if (Array.isArray(node)) {
+				for (const child of node) {
+					walk(child);
+				}
+				return;
+			}
+
+			const candidate = node as {
+				type?: string;
+				source?: { value?: string; start: number; end: number };
+			};
+
+			if (
+				candidate.type === 'ImportDeclaration' ||
+				candidate.type === 'ExportNamedDeclaration' ||
+				candidate.type === 'ExportAllDeclaration'
+			) {
+				if (candidate.source) {
+					queueReplacement(candidate.source);
+				}
+			}
+
+			if (candidate.type === 'ImportExpression') {
+				const importNode = candidate as {
+					source?: { type?: string; value?: string; start: number; end: number };
+				};
+				if (importNode.source?.type === 'StringLiteral' || importNode.source?.type === 'Literal') {
+					queueReplacement(importNode.source);
+				}
+			}
+
+			for (const value of Object.values(candidate)) {
+				walk(value);
+			}
+		};
+
+		walk(result.program);
+	} catch {
+		return code;
+	}
+
+	if (edits.length === 0) {
+		return code;
+	}
+
+	edits.sort((left, right) => right.start - left.start);
+	let rewritten = code;
+	for (const edit of edits) {
+		rewritten = rewritten.slice(0, edit.start) + edit.replacement + rewritten.slice(edit.end);
+	}
+
+	return rewritten;
+}