@wyw-in-js/transform 1.1.0 → 2.0.0-alpha.0

package/esm/utils/oxcShaker.js

@@ -0,0 +1,662 @@
+/* eslint-disable no-restricted-syntax */
+import fs from "fs";
+import path from "path";
+import { syncResolve } from "@wyw-in-js/shared";
+import { collectOxcExportsAndImportsFromProgram } from "./collectOxcExportsAndImports.js";
+import { getImportOverride, toImportKey } from "./importOverrides.js";
+import { parseOxcCached } from "./parseOxc.js";
+import { stripQueryAndHash } from "./parseRequest.js";
+const warnedDynamicImportFiles = new Set();
+const isNode = (value) => !!value && typeof value === "object" && "type" in value && typeof value.type === "string";
+const getChildren = (node) => {
+	const result = [];
+	const record = node;
+	Object.keys(record).forEach((key) => {
+		if (key === "type" || key === "start" || key === "end" || key === "range") {
+			return;
+		}
+		const value = record[key];
+		if (isNode(value)) {
+			result.push(value);
+			return;
+		}
+		if (Array.isArray(value)) {
+			value.forEach((item) => {
+				if (isNode(item)) {
+					result.push(item);
+				}
+			});
+		}
+	});
+	return result;
+};
+const parseOxc = (code, filename) => {
+	try {
+		const parsed = parseOxcCached(filename, code, "unambiguous");
+		return {
+			isEsModule: parsed.module.hasModuleSyntax,
+			program: parsed.program
+		};
+	} catch (error) {
+		if (process.env.WYW_DEBUG_SHAKER_DUMP) {
+			const dumpFile = path.join("/tmp", `wyw-oxc-shaker-${path.basename(filename).replace(/[^a-z0-9_.-]/gi, "_")}-${Date.now()}.js`);
+			fs.writeFileSync(dumpFile, code);
+			const message = error instanceof Error ? error.message : "Unknown Oxc shaker parse error";
+			throw new Error(`${message} [${filename}] [dump: ${dumpFile}]`);
+		}
+		throw error;
+	}
+};
+const applyReplacements = (code, replacements) => {
+	let result = code;
+	replacements.sort((a, b) => b.start - a.start).forEach((replacement) => {
+		result = result.slice(0, replacement.start) + replacement.value + result.slice(replacement.end);
+	});
+	return result;
+};
+const collectBindingNames = (node) => {
+	if (!node) {
+		return [];
+	}
+	if (node.type === "Identifier") {
+		return [node.name];
+	}
+	if (node.type === "RestElement") {
+		return collectBindingNames(node.argument);
+	}
+	if (node.type === "AssignmentPattern") {
+		return collectBindingNames(node.left);
+	}
+	if (node.type === "ObjectPattern") {
+		return node.properties.flatMap((property) => property.type === "RestElement" ? collectBindingNames(property.argument) : collectBindingNames(property.value));
+	}
+	if (node.type === "ArrayPattern") {
+		return node.elements.flatMap((element) => collectBindingNames(element));
+	}
+	return [];
+};
+const declarationBindings = (declaration) => {
+	if (!declaration) {
+		return [];
+	}
+	if (declaration.type === "VariableDeclaration") {
+		return declaration.declarations.flatMap((item) => collectBindingNames(item.id));
+	}
+	if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration" || declaration.type === "TSEnumDeclaration") && declaration.id) {
+		return [declaration.id.name];
+	}
+	return [];
+};
+const moduleExportName = (node) => {
+	if (node.type === "Identifier" || node.type === "Literal") {
+		return String(node.name ?? node.value);
+	}
+	return null;
+};
+const isBindingIdentifier = (node, parent) => {
+	if (node.type !== "Identifier" || !parent) {
+		return false;
+	}
+	const parentNode = parent;
+	if (parent.type === "VariableDeclarator" && parentNode.id === node) {
+		return true;
+	}
+	if ((parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ClassDeclaration" || parent.type === "ClassExpression" || parent.type === "TSEnumDeclaration") && parentNode.id === node) {
+		return true;
+	}
+	if ((parent.type === "ImportSpecifier" || parent.type === "ImportDefaultSpecifier" || parent.type === "ImportNamespaceSpecifier") && parentNode.local === node) {
+		return true;
+	}
+	return false;
+};
+const isIdentifierReference = (node, parent, grandparent) => {
+	if (node.type !== "Identifier") {
+		return false;
+	}
+	if (isBindingIdentifier(node, parent)) {
+		return false;
+	}
+	if (!parent) {
+		return true;
+	}
+	const parentNode = parent;
+	if (parent.type === "Property" && parentNode.key === node && !parentNode.computed) {
+		return false;
+	}
+	if (parent.type === "MemberExpression" && parentNode.property === node && !parentNode.computed) {
+		return false;
+	}
+	if (parent.type === "ExportSpecifier" && parentNode.exported === node) {
+		return false;
+	}
+	if (parent.type === "ExportSpecifier" && parentNode.local === node) {
+		return grandparent?.type === "ExportNamedDeclaration" ? !grandparent.source : true;
+	}
+	// The `imported` name of `import { X as Y }` is what to take from the source
+	// module — it does not reference a local binding `X` in the current module.
+	if (parent.type === "ImportSpecifier" && parentNode.imported === node) {
+		return false;
+	}
+	return true;
+};
+const TS_EXPRESSION_WRAPPER_TYPES = new Set([
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSTypeAssertion",
+	"TSNonNullExpression",
+	"TSInstantiationExpression"
+]);
+const collectReferences = (node) => {
+	const references = new Set();
+	const visit = (current, parent = null, grandparent = null) => {
+		if (TS_EXPRESSION_WRAPPER_TYPES.has(current.type)) {
+			const expression = current.expression;
+			if (expression) {
+				visit(expression, current, parent);
+			}
+			return;
+		}
+		if (current.type.startsWith("TS") && current.type !== "TSEnumDeclaration") {
+			return;
+		}
+		if (isIdentifierReference(current, parent, grandparent)) {
+			references.add(current.name);
+		}
+		getChildren(current).forEach((child) => visit(child, current, parent));
+	};
+	visit(node);
+	return references;
+};
+const getMutatedBinding = (node) => {
+	if (node.type === "Identifier") {
+		return node.name;
+	}
+	if (node.type === "MemberExpression" && node.object.type === "Identifier") {
+		return node.object.name;
+	}
+	return null;
+};
+const getMutationCallTarget = (node) => {
+	if (node.type !== "CallExpression") {
+		return null;
+	}
+	const { callee } = node;
+	if (callee.type !== "MemberExpression" || callee.object.type !== "Identifier" || callee.object.name !== "Object" || callee.computed || callee.property.type !== "Identifier") {
+		return null;
+	}
+	if (callee.property.name !== "assign" && callee.property.name !== "defineProperty" && callee.property.name !== "defineProperties") {
+		return null;
+	}
+	const [target] = node.arguments;
+	if (!target || target.type === "SpreadElement") {
+		return null;
+	}
+	return getMutatedBinding(target);
+};
+const collectMutations = (node) => {
+	const mutations = new Set();
+	const visit = (current) => {
+		if (current.type === "AssignmentExpression") {
+			const mutated = getMutatedBinding(current.left);
+			if (mutated) {
+				mutations.add(mutated);
+			}
+		} else if (current.type === "UpdateExpression") {
+			const mutated = getMutatedBinding(current.argument);
+			if (mutated) {
+				mutations.add(mutated);
+			}
+		} else {
+			const mutated = getMutationCallTarget(current);
+			if (mutated) {
+				mutations.add(mutated);
+			}
+		}
+		getChildren(current).forEach(visit);
+	};
+	visit(node);
+	return mutations;
+};
+const buildStatementInfo = (program, collected) => {
+	const { exports: collectedExports, imports: collectedImports } = collected;
+	const importsByStart = new Map();
+	collectedImports.forEach((item) => {
+		const bucket = importsByStart.get(item.local.start) ?? [];
+		bucket.push(item);
+		importsByStart.set(item.local.start, bucket);
+	});
+	return program.body.map((statement) => {
+		const node = statement;
+		const exportNames = new Set();
+		const bindings = new Set();
+		const imports = [];
+		const references = collectReferences(node);
+		let sideEffectImport = false;
+		if (node.type === "ImportDeclaration") {
+			sideEffectImport = node.specifiers.length === 0;
+			node.specifiers.forEach((specifier) => {
+				bindings.add(specifier.local.name);
+				const matched = importsByStart.get(specifier.local.start) ?? [];
+				imports.push(...matched);
+			});
+			if (sideEffectImport) {
+				const matched = collectedImports.filter((item) => item.imported === "side-effect" && item.local.start === node.start && item.local.end === node.end);
+				imports.push(...matched);
+			}
+		} else if (node.type === "ExportNamedDeclaration") {
+			declarationBindings(node.declaration).forEach((name) => bindings.add(name));
+			if (node.declaration) {
+				declarationBindings(node.declaration).forEach((name) => exportNames.add(name));
+			}
+			node.specifiers.forEach((specifier) => {
+				const local = moduleExportName(specifier.local);
+				const exported = moduleExportName(specifier.exported);
+				if (local && !node.source) references.add(local);
+				if (exported) exportNames.add(exported);
+			});
+		} else if (node.type === "ExportDefaultDeclaration") {
+			exportNames.add("default");
+			declarationBindings(node.declaration).forEach((name) => bindings.add(name));
+		} else if (node.type === "ExportAllDeclaration") {
+			if (node.exported) {
+				const exported = moduleExportName(node.exported);
+				if (exported) {
+					exportNames.add(exported);
+				}
+			} else {
+				exportNames.add("*");
+			}
+		} else {
+			Object.entries(collectedExports).forEach(([exported, local]) => {
+				if (local.start >= node.start && local.end <= node.end) {
+					exportNames.add(exported);
+				}
+			});
+			declarationBindings(node).forEach((name) => bindings.add(name));
+		}
+		return {
+			bindings,
+			exportNames,
+			imports,
+			mutations: collectMutations(node),
+			node,
+			references,
+			sideEffectImport
+		};
+	});
+};
+const collectImportLocalNames = (node) => {
+	if (node.type !== "ImportDeclaration") {
+		return [];
+	}
+	return node.specifiers.map((specifier) => specifier.local.name);
+};
+const getImportSpecifierLocalName = (node) => {
+	const { local } = node;
+	return isNode(local) && "name" in local && typeof local.name === "string" ? local.name : null;
+};
+const expandImportRemovalRange = (code, start, end) => {
+	let removalStart = start;
+	while (removalStart > 0 && (code[removalStart - 1] === " " || code[removalStart - 1] === "	")) {
+		removalStart -= 1;
+	}
+	let removalEnd = end;
+	if (code[removalEnd] === ";") {
+		removalEnd += 1;
+	}
+	while (removalEnd < code.length && (code[removalEnd] === " " || code[removalEnd] === "	")) {
+		removalEnd += 1;
+	}
+	if (code[removalEnd] === "\r" && code[removalEnd + 1] === "\n") {
+		removalEnd += 2;
+	} else if (code[removalEnd] === "\n") {
+		removalEnd += 1;
+	}
+	return {
+		end: removalEnd,
+		start: removalStart,
+		value: ""
+	};
+};
+const expandImportSpecifierRemovalRange = (code, start, end) => {
+	let removalStart = start;
+	let removalEnd = end;
+	let whitespaceStart = removalStart;
+	while (whitespaceStart > 0 && (code[whitespaceStart - 1] === " " || code[whitespaceStart - 1] === "	")) {
+		whitespaceStart -= 1;
+	}
+	if (code[whitespaceStart - 1] !== "{") {
+		removalStart = whitespaceStart;
+	}
+	while (removalEnd < code.length && (code[removalEnd] === " " || code[removalEnd] === "	")) {
+		removalEnd += 1;
+	}
+	if (code[removalEnd] === ",") {
+		removalEnd += 1;
+		while (removalEnd < code.length && (code[removalEnd] === " " || code[removalEnd] === "	")) {
+			removalEnd += 1;
+		}
+	} else {
+		while (removalStart > 0 && (code[removalStart - 1] === " " || code[removalStart - 1] === "	")) {
+			removalStart -= 1;
+		}
+		if (code[removalStart - 1] === ",") {
+			removalStart -= 1;
+			while (removalStart > 0 && (code[removalStart - 1] === " " || code[removalStart - 1] === "	")) {
+				removalStart -= 1;
+			}
+		}
+	}
+	return {
+		end: removalEnd,
+		start: removalStart,
+		value: ""
+	};
+};
+const mergeEmptyRemovalRanges = (removals) => {
+	if (removals.length <= 1) {
+		return removals;
+	}
+	const sorted = [...removals].sort((a, b) => a.start - b.start);
+	const merged = [];
+	sorted.forEach((removal) => {
+		const previous = merged[merged.length - 1];
+		if (previous && previous.value === "" && removal.value === "" && removal.start <= previous.end) {
+			previous.end = Math.max(previous.end, removal.end);
+			return;
+		}
+		merged.push({ ...removal });
+	});
+	return merged;
+};
+const removeUnusedImportSpecifiers = (code, filename) => {
+	const parsed = parseOxc(code, filename);
+	const { program } = parsed;
+	const referencedNames = new Set();
+	program.body.forEach((statement) => {
+		if (statement.type === "ImportDeclaration") {
+			return;
+		}
+		collectReferences(statement).forEach((name) => referencedNames.add(name));
+	});
+	const removals = [];
+	program.body.forEach((statement) => {
+		if (statement.type !== "ImportDeclaration") {
+			return;
+		}
+		if (statement.specifiers.length === 0) {
+			return;
+		}
+		const localNames = collectImportLocalNames(statement);
+		if (localNames.every((localName) => !referencedNames.has(localName))) {
+			removals.push(expandImportRemovalRange(code, statement.start, statement.end));
+			return;
+		}
+		if (statement.specifiers.length <= 1) {
+			return;
+		}
+		statement.specifiers.forEach((specifier) => {
+			const localName = getImportSpecifierLocalName(specifier);
+			if (localName && !referencedNames.has(localName)) {
+				removals.push(expandImportSpecifierRemovalRange(code, specifier.start, specifier.end));
+			}
+		});
+	});
+	if (removals.length === 0) {
+		return {
+			code,
+			parsed
+		};
+	}
+	const mergedRemovals = mergeEmptyRemovalRanges(removals);
+	const nextCode = applyReplacements(code, mergedRemovals);
+	try {
+		return {
+			code: nextCode,
+			parsed: parseOxc(nextCode, filename)
+		};
+	} catch {
+		return {
+			code,
+			parsed
+		};
+	}
+};
+const hasImportOverride = (source, options) => {
+	const { importOverrides } = options;
+	if (!importOverrides || Object.keys(importOverrides).length === 0) {
+		return false;
+	}
+	const stripped = stripQueryAndHash(source);
+	const direct = getImportOverride(importOverrides, source) ?? (stripped !== source ? getImportOverride(importOverrides, stripped) : null);
+	if (direct && ("mock" in direct || "noShake" in direct)) {
+		return true;
+	}
+	if (!stripped.startsWith(".") && !path.isAbsolute(stripped)) {
+		return false;
+	}
+	return false;
+};
+const importsToMap = (collected) => {
+	const result = new Map();
+	const add = (source, imported) => {
+		const bucket = result.get(source) ?? [];
+		if (!bucket.includes(imported)) {
+			bucket.push(imported);
+		}
+		result.set(source, bucket);
+	};
+	collected.imports.forEach((item) => {
+		const imported = item.imported || "side-effect";
+		add(item.source, imported);
+	});
+	collected.reexports.forEach((item) => {
+		add(item.source, item.imported || "side-effect");
+	});
+	return result;
+};
+const dynamicImportWarningsEnabled = () => Boolean(process.env.WYW_WARN_DYNAMIC_IMPORTS) && process.env.WYW_WARN_DYNAMIC_IMPORTS !== "0" && process.env.WYW_WARN_DYNAMIC_IMPORTS !== "false";
+const filterDynamicImportsForWarning = (imports, filename, options) => {
+	const sources = Array.from(new Set(imports.filter((item) => item.type === "dynamic").map((item) => item.source))).sort();
+	if (!options.importOverrides || Object.keys(options.importOverrides).length === 0) {
+		return sources;
+	}
+	const shouldWarn = (source) => {
+		const strippedSource = stripQueryAndHash(source);
+		const direct = getImportOverride(options.importOverrides, source) ?? (strippedSource !== source ? getImportOverride(options.importOverrides, strippedSource) : undefined);
+		if (direct !== undefined) {
+			return false;
+		}
+		const isFileImport = strippedSource.startsWith(".") || path.isAbsolute(strippedSource);
+		if (!isFileImport) {
+			return true;
+		}
+		try {
+			const resolved = syncResolve(strippedSource, filename, []);
+			const importKey = toImportKey({
+				resolved,
+				root: options.root,
+				source: strippedSource
+			}).key;
+			return getImportOverride(options.importOverrides, importKey) === undefined;
+		} catch {
+			return true;
+		}
+	};
+	return sources.filter(shouldWarn);
+};
+const warnDynamicImports = (imports, filename, options) => {
+	if (!dynamicImportWarningsEnabled() || warnedDynamicImportFiles.has(filename)) {
+		return;
+	}
+	const sourcesToWarn = filterDynamicImportsForWarning(imports, filename, options);
+	if (sourcesToWarn.length === 0) {
+		return;
+	}
+	warnedDynamicImportFiles.add(filename);
+	const overrideKeys = sourcesToWarn.map((source) => {
+		const strippedSource = stripQueryAndHash(source);
+		const isFileImport = strippedSource.startsWith(".") || path.isAbsolute(strippedSource);
+		if (!isFileImport) {
+			return {
+				key: source,
+				source
+			};
+		}
+		try {
+			const resolved = syncResolve(strippedSource, filename, []);
+			return {
+				key: toImportKey({
+					resolved,
+					root: options.root,
+					source: strippedSource
+				}).key,
+				source
+			};
+		} catch {
+			return {
+				key: strippedSource,
+				source
+			};
+		}
+	}).filter((item, index, array) => {
+		const firstIndexForKey = array.findIndex((i) => i.key === item.key);
+		return firstIndexForKey === index;
+	});
+	const warning = [
+		`[wyw-in-js] Dynamic imports reached prepare stage`,
+		``,
+		`file: ${filename}`,
+		`count: ${sourcesToWarn.length}`,
+		`sources:`,
+		...sourcesToWarn.map((source) => `  - ${source}`),
+		``,
+		`note: these imports will be resolved/processed even if they are lazy (e.g. React.lazy(() => import(...)))`,
+		``,
+		`tip: if the imported module is runtime-only or heavy, mock it during evaluation via importOverrides:`,
+		`  importOverrides: {`,
+		...overrideKeys.map(({ key, source }) => `    '${key}': { mock: './path/to/mock' }, // from ${source}`),
+		`  }`,
+		``,
+		`note: importOverrides affects only build-time evaluation (it does not change your bundler runtime behavior)`
+	].join("\n");
+	// eslint-disable-next-line no-console
+	console.warn(warning);
+};
+const removeExportKeyword = (code, node) => {
+	if (node.type !== "ExportNamedDeclaration" || !node.declaration || node.start === node.declaration.start) {
+		return null;
+	}
+	return {
+		end: node.declaration.start,
+		start: node.start,
+		value: ""
+	};
+};
+const splitExportedVariableDeclaration = (code, node, requested) => {
+	if (node.type !== "ExportNamedDeclaration" || !node.declaration || node.declaration.type !== "VariableDeclaration" || node.declaration.declarations.length <= 1) {
+		return null;
+	}
+	const declarators = node.declaration.declarations;
+	const declaratorNames = declarators.map((declarator) => collectBindingNames(declarator.id));
+	const requestedNames = declaratorNames.flat().filter((name) => requested.has(name));
+	if (requestedNames.length === 0 || requestedNames.length === declaratorNames.flat().length) {
+		return null;
+	}
+	const declarationCode = `${node.declaration.kind} ${declarators.map((declarator) => code.slice(declarator.start, declarator.end)).join(", ")};`;
+	return {
+		end: node.end,
+		start: node.start,
+		value: `${declarationCode}\nexport { ${requestedNames.join(", ")} };`
+	};
+};
+export const shakeOxcToESM = (code, filename, options) => {
+	const parsed = parseOxc(code, filename);
+	const { program } = parsed;
+	const collected = collectOxcExportsAndImportsFromProgram(program, code, parsed.isEsModule);
+	const statements = buildStatementInfo(program, collected);
+	const bindingOwners = new Map();
+	statements.forEach((statement) => {
+		statement.bindings.forEach((binding) => {
+			if (!bindingOwners.has(binding)) {
+				bindingOwners.set(binding, statement);
+			}
+		});
+	});
+	const requested = new Set(options.onlyExports);
+	const keepAllExports = requested.has("*");
+	const liveStatements = new Set();
+	const liveExportStatements = new Set();
+	const queue = [];
+	const mutationsByBinding = new Map();
+	statements.forEach((statement) => {
+		statement.mutations.forEach((binding) => {
+			const bucket = mutationsByBinding.get(binding) ?? [];
+			bucket.push(statement);
+			mutationsByBinding.set(binding, bucket);
+		});
+	});
+	const mark = (statement, exported = false) => {
+		if (!liveStatements.has(statement)) {
+			liveStatements.add(statement);
+			queue.push(statement);
+		}
+		if (exported) {
+			liveExportStatements.add(statement);
+		}
+	};
+	statements.forEach((statement) => {
+		const hasWildcardReexport = statement.exportNames.has("*");
+		if (statement.exportNames.size > 0 && (keepAllExports || hasWildcardReexport && requested.size > 0 && !requested.has("side-effect") || [...statement.exportNames].some((name) => requested.has(name)))) {
+			mark(statement, true);
+		}
+		if (statement.sideEffectImport && (requested.has("side-effect") || options.keepSideEffects || statement.imports.some((item) => hasImportOverride(item.source, options)))) {
+			mark(statement);
+		}
+	});
+	while (queue.length > 0) {
+		const current = queue.shift();
+		current.references.forEach((name) => {
+			const owner = bindingOwners.get(name);
+			if (owner) {
+				mark(owner);
+			}
+		});
+		current.bindings.forEach((binding) => {
+			mutationsByBinding.get(binding)?.forEach((mutation) => {
+				mark(mutation);
+			});
+		});
+	}
+	const replacements = [];
+	statements.forEach((statement) => {
+		if (!liveStatements.has(statement)) {
+			replacements.push({
+				end: statement.node.end,
+				start: statement.node.start,
+				value: ""
+			});
+			return;
+		}
+		if (!liveExportStatements.has(statement)) {
+			const replacement = removeExportKeyword(code, statement.node);
+			if (replacement) {
+				replacements.push(replacement);
+			}
+			return;
+		}
+		const splitReplacement = splitExportedVariableDeclaration(code, statement.node, requested);
+		if (splitReplacement) {
+			replacements.push(splitReplacement);
+		}
+	});
+	const cleaned = removeUnusedImportSpecifiers(applyReplacements(code, replacements), filename);
+	const nextCode = cleaned.code;
+	const nextCollected = collectOxcExportsAndImportsFromProgram(cleaned.parsed.program, nextCode, cleaned.parsed.isEsModule);
+	warnDynamicImports(nextCollected.imports, filename, options);
+	return {
+		code: nextCode,
+		imports: importsToMap(nextCollected)
+	};
+};
+//# sourceMappingURL=oxcShaker.js.map