devflare 1.0.0-next.5 → 1.0.0-next.50

package/dist/_chunks/worker-bundler-dTTnYU3n.js

@@ -0,0 +1,458 @@
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "pathe";
+import { fileURLToPath } from "node:url";
+import MagicString from "magic-string";
+import ts from "typescript";
+//#region src/bundler/defaults.ts
+function createWorkerdBundlerDefaults() {
+	return {
+		platform: "browser",
+		defaultTsconfigMode: "if-present",
+		sourcemap: false,
+		minify: false
+	};
+}
+//#endregion
+//#region src/bundler/worker-compat.ts
+const WORKER_DYNAMIC_IMPORT_ERROR = "Devflare worker bundles cannot contain unresolved dynamic import() expressions because Miniflare/workerd reject dynamic module specifiers";
+function getScriptKind(id) {
+	if (id.endsWith(".tsx")) return ts.ScriptKind.TSX;
+	if (id.endsWith(".ts") || id.endsWith(".mts") || id.endsWith(".cts")) return ts.ScriptKind.TS;
+	if (id.endsWith(".jsx")) return ts.ScriptKind.JSX;
+	return ts.ScriptKind.JS;
+}
+function createSourceFile(code, id) {
+	return ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true, getScriptKind(id));
+}
+function hasExportModifier(node) {
+	if (!ts.canHaveModifiers(node)) return false;
+	return ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function isConstVariableStatement(statement) {
+	return ts.isVariableStatement(statement) && (statement.declarationList.flags & ts.NodeFlags.Const) !== 0;
+}
+function quoteString(value) {
+	return `'${value.replace(/\\/g, "\\\\").replace(/'/g, `\\'`)}'`;
+}
+function resolveLiteralImportSpecifier(expression, constStrings) {
+	if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) return expression.text;
+	if (ts.isParenthesizedExpression(expression)) return resolveLiteralImportSpecifier(expression.expression, constStrings);
+	if (ts.isIdentifier(expression)) return constStrings.get(expression.text) ?? null;
+	return null;
+}
+function collectTopLevelConstStrings(sourceFile) {
+	const constStrings = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (!isConstVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) {
+			if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+			const literal = resolveLiteralImportSpecifier(declaration.initializer, constStrings);
+			if (literal !== null) constStrings.set(declaration.name.text, literal);
+		}
+	}
+	return constStrings;
+}
+function unwrapDynamicImportExpression(expression) {
+	if (ts.isParenthesizedExpression(expression)) return unwrapDynamicImportExpression(expression.expression);
+	if (ts.isAwaitExpression(expression)) return unwrapDynamicImportExpression(expression.expression);
+	if (!ts.isCallExpression(expression) || expression.expression.kind !== ts.SyntaxKind.ImportKeyword) return null;
+	return expression;
+}
+function getWrapperBodyExpression(body) {
+	if (!body) return null;
+	if (!ts.isBlock(body)) return body;
+	if (body.statements.length !== 1) return null;
+	const [statement] = body.statements;
+	if (!ts.isReturnStatement(statement) || !statement.expression) return null;
+	return statement.expression;
+}
+function createImportWrapper(name, parameterName, body, sourceFile) {
+	const bodyExpression = getWrapperBodyExpression(body);
+	if (!bodyExpression) return null;
+	const importExpression = unwrapDynamicImportExpression(bodyExpression);
+	if (!importExpression || importExpression.arguments.length < 1) return null;
+	const [importArgument] = importExpression.arguments;
+	if (!ts.isIdentifier(importArgument) || importArgument.text !== parameterName || !body) return null;
+	return {
+		name,
+		parameterName,
+		bodyStart: body.getStart(sourceFile),
+		bodyEnd: body.getEnd(),
+		specifiers: /* @__PURE__ */ new Set(),
+		hasUnsupportedCalls: false
+	};
+}
+function collectImportWrappers(sourceFile) {
+	const wrappers = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (ts.isFunctionDeclaration(statement) && statement.name && !hasExportModifier(statement) && statement.parameters.length === 1 && ts.isIdentifier(statement.parameters[0]?.name)) {
+			const wrapper = createImportWrapper(statement.name.text, statement.parameters[0].name.text, statement.body, sourceFile);
+			if (wrapper) wrappers.set(wrapper.name, wrapper);
+		}
+		if (!isConstVariableStatement(statement) || hasExportModifier(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) {
+			if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+			if (!ts.isArrowFunction(declaration.initializer) && !ts.isFunctionExpression(declaration.initializer)) continue;
+			if (declaration.initializer.parameters.length !== 1 || !ts.isIdentifier(declaration.initializer.parameters[0]?.name)) continue;
+			const wrapper = createImportWrapper(declaration.name.text, declaration.initializer.parameters[0].name.text, declaration.initializer.body, sourceFile);
+			if (wrapper) wrappers.set(wrapper.name, wrapper);
+		}
+	}
+	return wrappers;
+}
+function collectWrapperCallSpecifiers(sourceFile, wrappers, constStrings) {
+	function visit(node) {
+		if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+			const wrapper = wrappers.get(node.expression.text);
+			if (wrapper) if (node.arguments.length !== 1) wrapper.hasUnsupportedCalls = true;
+			else {
+				const specifier = resolveLiteralImportSpecifier(node.arguments[0], constStrings);
+				if (specifier === null) wrapper.hasUnsupportedCalls = true;
+				else wrapper.specifiers.add(specifier);
+			}
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(sourceFile);
+}
+function createImportIdentifier(specifierToIdentifier, specifier) {
+	const existing = specifierToIdentifier.get(specifier);
+	if (existing) return existing;
+	const identifier = `__devflareDynamicImport${specifierToIdentifier.size}`;
+	specifierToIdentifier.set(specifier, identifier);
+	return identifier;
+}
+function buildWrapperBody(wrapper, specifierToIdentifier) {
+	const cases = Array.from(wrapper.specifiers).sort((left, right) => left.localeCompare(right)).map((specifier) => {
+		const identifier = createImportIdentifier(specifierToIdentifier, specifier);
+		return `\t\tcase ${quoteString(specifier)}:\n\t\t\treturn Promise.resolve(${identifier})`;
+	}).join("\n");
+	return `{
+		switch (${wrapper.parameterName}) {
+${cases}
+			default:
+				return Promise.reject(new Error(\`Unsupported dynamic import in Devflare worker bundle: \${${wrapper.parameterName}}\`))
+		}
+	}`;
+}
+function findContainingWrapper(callExpression, wrappers, sourceFile) {
+	const start = callExpression.getStart(sourceFile);
+	const end = callExpression.getEnd();
+	for (const wrapper of wrappers) if (start >= wrapper.bodyStart && end <= wrapper.bodyEnd) return wrapper;
+	return null;
+}
+function transformWorkerDynamicImports(code, id) {
+	const sourceFile = createSourceFile(code, id);
+	const constStrings = collectTopLevelConstStrings(sourceFile);
+	const wrappers = collectImportWrappers(sourceFile);
+	collectWrapperCallSpecifiers(sourceFile, wrappers, constStrings);
+	const transformableWrappers = Array.from(wrappers.values()).filter((wrapper) => {
+		return !wrapper.hasUnsupportedCalls && wrapper.specifiers.size > 0;
+	});
+	const replacements = [];
+	const specifierToIdentifier = /* @__PURE__ */ new Map();
+	function visit(node) {
+		if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+			const containingWrapper = findContainingWrapper(node, transformableWrappers, sourceFile);
+			if (containingWrapper && node.arguments.length === 1 && ts.isIdentifier(node.arguments[0]) && node.arguments[0].text === containingWrapper.parameterName) return;
+			const [argument] = node.arguments;
+			if (!argument) return;
+			const specifier = resolveLiteralImportSpecifier(argument, constStrings);
+			if (specifier !== null) replacements.push({
+				start: node.getStart(sourceFile),
+				end: node.getEnd(),
+				text: `Promise.resolve(${createImportIdentifier(specifierToIdentifier, specifier)})`
+			});
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(sourceFile);
+	if (replacements.length === 0 && transformableWrappers.length === 0) return null;
+	const s = new MagicString(code);
+	for (const replacement of replacements.sort((left, right) => right.start - left.start)) s.overwrite(replacement.start, replacement.end, replacement.text);
+	for (const wrapper of transformableWrappers.sort((left, right) => right.bodyStart - left.bodyStart)) s.overwrite(wrapper.bodyStart, wrapper.bodyEnd, buildWrapperBody(wrapper, specifierToIdentifier));
+	if (specifierToIdentifier.size > 0) {
+		const importBlock = Array.from(specifierToIdentifier.entries()).map(([specifier, identifier]) => `import * as ${identifier} from ${quoteString(specifier)}`).join("\n");
+		if (code.startsWith("#!")) {
+			const newlineIndex = code.indexOf("\n");
+			if (newlineIndex === -1) s.appendRight(code.length, `\n${importBlock}\n`);
+			else s.appendLeft(newlineIndex + 1, `${importBlock}\n`);
+		} else s.appendLeft(0, `${importBlock}\n`);
+	}
+	return {
+		code: s.toString(),
+		map: s.generateMap({
+			source: id,
+			file: `${id}.map`,
+			includeContent: true
+		})
+	};
+}
+function findDynamicImportCalls(sourceFile) {
+	const calls = [];
+	function visit(node) {
+		if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) calls.push(node);
+		ts.forEachChild(node, visit);
+	}
+	visit(sourceFile);
+	return calls;
+}
+async function assertWorkerBundleHasNoDynamicImports(bundlePath) {
+	const code = await (await import("node:fs/promises")).readFile(bundlePath, "utf-8");
+	const sourceFile = createSourceFile(code, bundlePath);
+	const dynamicImports = findDynamicImportCalls(sourceFile);
+	if (dynamicImports.length === 0) return;
+	const examples = dynamicImports.slice(0, 3).map((callExpression) => {
+		const start = callExpression.getStart(sourceFile);
+		const { line, character } = sourceFile.getLineAndCharacterOfPosition(start);
+		const snippet = code.slice(start, callExpression.getEnd()).replace(/\s+/g, " ").trim();
+		return `- ${line + 1}:${character + 1} ${snippet}`;
+	}).join("\n");
+	throw new Error([
+		WORKER_DYNAMIC_IMPORT_ERROR,
+		`Bundle: ${bundlePath}`,
+		`Examples:\n${examples}`,
+		"Devflare can normalize literal import() calls and simple helper wrappers whose call sites are literal strings, but truly runtime-computed specifiers must be converted to static imports for worker bundles."
+	].join("\n\n"));
+}
+function createWorkerDynamicImportPlugin() {
+	return {
+		name: "devflare-worker-dynamic-imports",
+		transform(code, id) {
+			return transformWorkerDynamicImports(code, id) ?? null;
+		}
+	};
+}
+//#endregion
+//#region src/bundler/rolldown-shared.ts
+const DEFAULT_EXTERNAL_MODULES = [
+	/^cloudflare:/,
+	/^node:/,
+	"buffer",
+	"crypto",
+	"events",
+	"http",
+	"https",
+	"net",
+	"os",
+	"path",
+	"stream",
+	"tls",
+	"url",
+	"util",
+	"zlib",
+	"fs",
+	"child_process",
+	"async_hooks",
+	"querystring",
+	"string_decoder",
+	"assert",
+	"dns"
+];
+function toArray(value) {
+	return Array.isArray(value) ? value : [value];
+}
+function matchesExternalPattern(pattern, id) {
+	if (pattern instanceof RegExp) {
+		pattern.lastIndex = 0;
+		return pattern.test(id);
+	}
+	return pattern === id;
+}
+function matchesExternalOption(option, id, parentId, isResolved) {
+	if (!option) return false;
+	if (typeof option === "function") return option(id, parentId, isResolved) ?? false;
+	return toArray(option).some((pattern) => matchesExternalPattern(pattern, id));
+}
+function mergeExternalOptions(base, user) {
+	if (!base) return user;
+	if (!user) return base;
+	if (typeof base !== "function" && typeof user !== "function") return [...toArray(base), ...toArray(user)];
+	return (id, parentId, isResolved) => {
+		return matchesExternalOption(base, id, parentId, isResolved) || matchesExternalOption(user, id, parentId, isResolved) || false;
+	};
+}
+function mergePluginOptions(base, user) {
+	if (!base) return user;
+	if (!user) return base;
+	return [base, user];
+}
+function aliasKey(find) {
+	return find instanceof RegExp ? `re:${find.source}:${find.flags}` : `str:${find}`;
+}
+function normalizeAliasEntries(input) {
+	if (!input) return [];
+	if (Array.isArray(input)) return input.filter((entry) => {
+		return Boolean(entry) && typeof entry.replacement === "string";
+	});
+	return Object.entries(input).filter(([, replacement]) => typeof replacement === "string").map(([find, replacement]) => ({
+		find,
+		replacement
+	}));
+}
+/**
+* Merge framework-default aliases with user-provided aliases.
+*
+* Contract:
+* - Framework defaults are emitted first, then user entries, so on duplicate
+*   `find` keys the user entry wins (object-spread / last-wins semantics).
+* - Entries are deduplicated by the normalized `find` key (string value or
+*   `RegExp.source` + flags).
+* - Ordering of user entries is preserved so regex specificity remains
+*   predictable.
+*/
+function mergeAliases(userAliases, frameworkDefaults) {
+	const userKeys = new Set(userAliases.map((entry) => aliasKey(entry.find)));
+	const frameworkFiltered = frameworkDefaults.filter((entry) => {
+		return !userKeys.has(aliasKey(entry.find));
+	});
+	const seenUserKeys = /* @__PURE__ */ new Set();
+	const dedupedUser = [];
+	for (let index = userAliases.length - 1; index >= 0; index--) {
+		const entry = userAliases[index];
+		const key = aliasKey(entry.find);
+		if (seenUserKeys.has(key)) continue;
+		seenUserKeys.add(key);
+		dedupedUser.unshift(entry);
+	}
+	return [...frameworkFiltered, ...dedupedUser];
+}
+function aliasEntriesToRolldownRecord(entries) {
+	const record = {};
+	for (const entry of entries) {
+		if (entry.find instanceof RegExp) continue;
+		record[entry.find] = entry.replacement;
+	}
+	return record;
+}
+function mergeResolveOptions(base, user) {
+	if (!base && !user) return;
+	const frameworkEntries = normalizeAliasEntries(base?.alias);
+	const mergedEntries = mergeAliases(normalizeAliasEntries(user?.alias), frameworkEntries);
+	const mergedAlias = aliasEntriesToRolldownRecord(mergedEntries);
+	return {
+		...user ?? {},
+		...base ?? {},
+		...mergedEntries.length > 0 ? { alias: mergedAlias } : {}
+	};
+}
+function resolveTsconfigOption(options) {
+	if (options.userTsconfig) return { tsconfig: options.userTsconfig };
+	const defaultTsconfigPath = resolve(options.cwd, "tsconfig.json");
+	if (options.defaultMode === "always" || existsSync(defaultTsconfigPath)) return { tsconfig: defaultTsconfigPath };
+	return {};
+}
+async function ensureDebugShim(outDir) {
+	const fs = await import("node:fs/promises");
+	const debugShimCode = `
+// Debug module shim for local development
+const createDebug = (namespace) => {
+	const logger = (...args) => {
+		if (createDebug.enabled) console.debug(\`[\${namespace}]\`, ...args)
+	}
+	logger.enabled = false
+	logger.namespace = namespace
+	logger.extend = (sub) => createDebug(\`\${namespace}:\${sub}\`)
+	return logger
+}
+createDebug.enabled = false
+createDebug.formatters = {}
+export default createDebug
+`;
+	const debugShimPath = resolve(outDir, "_debug_shim.js");
+	await fs.writeFile(debugShimPath, debugShimCode, "utf-8");
+	return debugShimPath;
+}
+function resolveWorkerCompatibleRolldownConfig(options) {
+	const { output: userOutputOptions, input: _ignoredInput, cwd: _ignoredCwd, platform: _ignoredPlatform, target: _ignoredTarget, watch: _ignoredWatch, external: userExternal, plugins: userPlugins, resolve: userResolve, tsconfig: userTsconfig, ...userInputOptions } = options.rolldownOptions ?? {};
+	const { codeSplitting: _ignoredCodeSplitting, dir: _ignoredDir, file: _ignoredFile, format: _ignoredFormat, inlineDynamicImports: _ignoredInlineDynamicImports, ...safeUserOutputOptions } = userOutputOptions ?? {};
+	return {
+		inputOptions: {
+			...userInputOptions,
+			input: options.inputFile,
+			cwd: options.cwd,
+			platform: options.platform,
+			...resolveTsconfigOption({
+				cwd: options.cwd,
+				userTsconfig,
+				defaultMode: options.defaultTsconfigMode
+			}),
+			external: mergeExternalOptions(DEFAULT_EXTERNAL_MODULES, userExternal),
+			plugins: mergePluginOptions(createWorkerDynamicImportPlugin(), userPlugins),
+			resolve: mergeResolveOptions(options.alias ? { alias: options.alias } : void 0, userResolve)
+		},
+		outputOptions: {
+			...safeUserOutputOptions,
+			file: options.outFile,
+			format: "esm",
+			sourcemap: safeUserOutputOptions.sourcemap ?? options.sourcemap ?? false,
+			minify: safeUserOutputOptions.minify ?? options.minify,
+			codeSplitting: false,
+			...options.inlineDynamicImports !== void 0 ? { inlineDynamicImports: options.inlineDynamicImports } : {}
+		}
+	};
+}
+async function writeWorkerCompatibleBundle(options) {
+	const { rolldown } = await import("rolldown");
+	const bundle = await rolldown(options.inputOptions);
+	try {
+		await bundle.write(options.outputOptions);
+		await assertWorkerBundleHasNoDynamicImports(options.outFile);
+	} finally {
+		await bundle.close();
+	}
+}
+//#endregion
+//#region src/bundler/worker-bundler.ts
+async function resolveInternalModuleEntry(relativeCandidates) {
+	const fs = await import("node:fs/promises");
+	const currentFileDir = dirname(fileURLToPath(import.meta.url));
+	for (const candidate of relativeCandidates) {
+		const absolutePath = resolve(currentFileDir, candidate);
+		try {
+			await fs.access(absolutePath);
+			return absolutePath;
+		} catch {}
+	}
+	return null;
+}
+async function resolveInternalAliasMap(outDir) {
+	const debugShimPath = await ensureDebugShim(outDir);
+	const runtimeEntry = await resolveInternalModuleEntry(["../runtime/index.ts", "../runtime/index.js"]);
+	const packageEntry = await resolveInternalModuleEntry(["../browser.ts", "../browser.js"]);
+	return {
+		debug: debugShimPath,
+		...runtimeEntry ? { "devflare/runtime": runtimeEntry } : {},
+		...packageEntry ? { devflare: packageEntry } : {}
+	};
+}
+async function bundleWorkerEntry(options) {
+	const fs = await import("node:fs/promises");
+	const outDir = dirname(options.outFile);
+	await fs.mkdir(outDir, { recursive: true });
+	await fs.rm(options.outFile, { force: true });
+	await fs.rm(`${options.outFile}.map`, { force: true });
+	const alias = await resolveInternalAliasMap(outDir);
+	const defaults = createWorkerdBundlerDefaults();
+	const { inputOptions, outputOptions } = resolveWorkerCompatibleRolldownConfig({
+		cwd: options.cwd,
+		inputFile: options.inputFile,
+		outFile: options.outFile,
+		alias,
+		...defaults,
+		platform: "browser",
+		rolldownOptions: options.rolldownOptions,
+		sourcemap: options.sourcemap ?? defaults.sourcemap,
+		minify: options.minify ?? defaults.minify,
+		defaultTsconfigMode: "if-present"
+	});
+	options.logger?.debug(`Bundling main worker → ${options.outFile}`);
+	await writeWorkerCompatibleBundle({
+		inputOptions,
+		outputOptions,
+		outFile: options.outFile
+	});
+	return options.outFile;
+}
+//#endregion
+export { createWorkerdBundlerDefaults as a, writeWorkerCompatibleBundle as i, ensureDebugShim as n, resolveWorkerCompatibleRolldownConfig as r, bundleWorkerEntry as t };