@navita/extraction 3.0.0-next.0

package/toAmd.mjs

@@ -0,0 +1,192 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { importedName, patternNames } from "./ast.mjs";
+import { getParser } from "./loadOxc.mjs";
+//#region src/toAmd.ts
+/**
+* Convert an ES module (already TypeScript-stripped) into a single AMD
+* `define([...deps], function (require, exports, ...modules) { ... })` call
+* expression — the shape `@navita/core`'s evaluator expects.
+*/
+function esmToAmd(code, { dropUnusedImports }) {
+	const { program } = getParser().parseSync("module.js", code, {
+		lang: "js",
+		sourceType: "module"
+	});
+	const body = program.body;
+	const sources = [];
+	const sourceIndex = /* @__PURE__ */ new Map();
+	const sideEffectSources = [];
+	const sourceInfoFor = (source) => {
+		let info = sourceIndex.get(source);
+		if (!info) {
+			info = {
+				source,
+				specs: [],
+				param: ""
+			};
+			sourceIndex.set(source, info);
+			sources.push(info);
+		}
+		return info;
+	};
+	for (const stmt of body) {
+		if (stmt.type !== "ImportDeclaration") continue;
+		const source = stmt.source.value;
+		const specifiers = stmt.specifiers || [];
+		if (specifiers.length === 0) {
+			sideEffectSources.push(source);
+			continue;
+		}
+		const info = sourceInfoFor(source);
+		for (const spec of specifiers) if (spec.type === "ImportDefaultSpecifier") info.specs.push({
+			kind: "default",
+			local: spec.local.name
+		});
+		else if (spec.type === "ImportNamespaceSpecifier") info.specs.push({
+			kind: "namespace",
+			local: spec.local.name
+		});
+		else info.specs.push({
+			kind: "named",
+			imported: importedName(spec),
+			local: spec.local.name
+		});
+	}
+	const referenced = /* @__PURE__ */ new Set();
+	if (dropUnusedImports) for (const stmt of body) {
+		if (stmt.type === "ImportDeclaration") continue;
+		collectIdentifierNames(stmt, referenced);
+	}
+	const keptSources = [];
+	for (const info of sources) {
+		const specs = dropUnusedImports ? info.specs.filter((s) => referenced.has(s.local)) : info.specs;
+		if (specs.length === 0) continue;
+		info.specs = specs;
+		keptSources.push(info);
+	}
+	const keptSideEffects = dropUnusedImports ? [] : sideEffectSources;
+	keptSources.forEach((info, i) => {
+		info.param = `_navita_import_${i}`;
+	});
+	const sideEffectParams = keptSideEffects.map((_, i) => `_navita_side_${i}`);
+	const deps = [
+		"\"require\"",
+		"\"exports\"",
+		...keptSources.map((info) => JSON.stringify(info.source)),
+		...keptSideEffects.map((source) => JSON.stringify(source))
+	];
+	const params = [
+		"require",
+		"exports",
+		...keptSources.map((info) => info.param),
+		...sideEffectParams
+	];
+	const lines = [];
+	let reexportCounter = 0;
+	const nextReexportNs = () => `_navita_reexport_${reexportCounter++}`;
+	for (const info of keptSources) lines.push(...destructure(info));
+	for (const stmt of body) {
+		if (stmt.type === "ImportDeclaration") continue;
+		emitStatement(stmt, code, lines, nextReexportNs);
+	}
+	const bodyText = lines.join("\n");
+	return `define([${deps.join(", ")}], function (${params.join(", ")}) {\n${bodyText}\n})`;
+}
+function destructure(info) {
+	const lines = [];
+	const named = [];
+	for (const spec of info.specs) if (spec.kind === "named") named.push(spec.imported === spec.local ? spec.local : `${spec.imported}: ${spec.local}`);
+	else if (spec.kind === "namespace") lines.push(`const ${spec.local} = ${info.param};`);
+	else lines.push(`const ${spec.local} = ${info.param} && ${info.param}.__esModule ? ${info.param}.default : (${info.param}.default !== undefined ? ${info.param}.default : ${info.param});`);
+	if (named.length > 0) lines.push(`const { ${named.join(", ")} } = ${info.param};`);
+	return lines;
+}
+function emitStatement(stmt, code, lines, nextReexportNs) {
+	switch (stmt.type) {
+		case "ExportNamedDeclaration":
+			if (stmt.declaration) {
+				const decl = stmt.declaration;
+				lines.push(code.slice(decl.start, decl.end));
+				for (const name of declaredNames(decl)) lines.push(`exports.${name} = ${name};`);
+				return;
+			}
+			if (stmt.source) {
+				const ns = nextReexportNs();
+				lines.push(`const ${ns} = require(${JSON.stringify(stmt.source.value)});`);
+				for (const spec of stmt.specifiers || []) lines.push(`exports.${spec.exported.name} = ${ns}.${spec.local.name};`);
+				return;
+			}
+			for (const spec of stmt.specifiers || []) lines.push(`exports.${spec.exported.name} = ${spec.local.name};`);
+			return;
+		case "ExportDefaultDeclaration": {
+			const decl = stmt.declaration;
+			if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") if (decl.id) {
+				lines.push(code.slice(decl.start, decl.end));
+				lines.push(`exports.default = ${decl.id.name};`);
+			} else lines.push(`exports.default = ${code.slice(decl.start, decl.end)};`);
+			else lines.push(`exports.default = ${code.slice(decl.start, decl.end)};`);
+			return;
+		}
+		case "ExportAllDeclaration": {
+			const ns = nextReexportNs();
+			lines.push(`const ${ns} = require(${JSON.stringify(stmt.source.value)});`);
+			if (stmt.exported) lines.push(`exports.${stmt.exported.name} = ${ns};`);
+			else lines.push(`for (const _k in ${ns}) { if (_k !== "default") exports[_k] = ${ns}[_k]; }`);
+			return;
+		}
+		default: lines.push(code.slice(stmt.start, stmt.end));
+	}
+}
+function declaredNames(decl) {
+	if (decl.type === "VariableDeclaration") {
+		const names = [];
+		for (const d of decl.declarations) patternNames(d.id, names);
+		return names;
+	}
+	if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") return decl.id ? [decl.id.name] : [];
+	return [];
+}
+const SKIP_KEYS = /* @__PURE__ */ new Set([
+	"type",
+	"start",
+	"end",
+	"range",
+	"loc",
+	"parent"
+]);
+/** Collect identifier names referenced in a subtree (skip static member/key). */
+function collectIdentifierNames(node, out) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const child of node) collectIdentifierNames(child, out);
+		return;
+	}
+	const n = node;
+	switch (n.type) {
+		case "Identifier":
+		case "IdentifierReference":
+			out.add(n.name);
+			return;
+		case "MemberExpression":
+		case "StaticMemberExpression":
+		case "ComputedMemberExpression":
+			if (n.computed) collectIdentifierNames(n.property, out);
+			collectIdentifierNames(n.object, out);
+			return;
+		case "Property":
+		case "ObjectProperty":
+			if (n.computed) collectIdentifierNames(n.key, out);
+			collectIdentifierNames(n.value, out);
+			return;
+		default: break;
+	}
+	for (const key in n) {
+		if (SKIP_KEYS.has(key)) continue;
+		const value = n[key];
+		if (value && typeof value === "object") collectIdentifierNames(value, out);
+	}
+}
+//#endregion
+export { esmToAmd };