@navita/extraction 3.0.0-next.0

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@navita/extraction",
+  "version": "3.0.0-next.0",
+  "description": "Style extraction transform for Navita (OXC-based)",
+  "keywords": [
+    "oxc",
+    "css-in-js",
+    "navita",
+    "extraction"
+  ],
+  "private": false,
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.cjs",
+      "types": "./index.d.ts"
+    }
+  },
+  "dependencies": {
+    "magic-string": "^0.30.0",
+    "oxc-parser": "^0.137.0",
+    "oxc-transform": "^0.137.0"
+  },
+  "license": "MIT",
+  "author": "Eagerpatch",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eagerpatch/navita.git",
+    "directory": "packages/extraction"
+  }
+}

package/rewrite.cjs

@@ -0,0 +1,185 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_ast = require("./ast.cjs");
+const require_loadOxc = require("./loadOxc.cjs");
+let magic_string = require("magic-string");
+magic_string = require_runtime.__toESM(magic_string);
+//#region src/rewrite.ts
+const COLLECT_RESULT_NAME = "collectResult";
+const ADAPTER_SOURCE = "@navita/adapter";
+/**
+* The core extraction rewrite. Produces an ES module (still TypeScript, still
+* pre-AMD) where:
+*  - every navita style call is wrapped in `collectResult({ ... })`,
+*  - the module is pruned to only the imports + statements needed to evaluate
+*    those calls (with nested style declarations hoisted to the top level),
+*  - unresolved free identifiers referenced inside style calls are synthesized
+*    as bare `let x;` declarations.
+*
+* This mirrors the behavior of the original Rust/swc-plugin transform (see the
+* `test!` fixtures in crates/extraction/src/lib.rs).
+*/
+function rewrite(code, { filename, importMap }) {
+	const { program } = require_loadOxc.getParser().parseSync(filename, code, {
+		lang: "tsx",
+		sourceType: "module"
+	});
+	const body = program.body;
+	const importCalls = /* @__PURE__ */ new Set();
+	const importBindings = /* @__PURE__ */ new Set();
+	for (const stmt of body) {
+		if (stmt.type !== "ImportDeclaration" || stmt.importKind === "type") continue;
+		const source = stmt.source.value;
+		for (const spec of stmt.specifiers || []) {
+			importBindings.add(spec.local.name);
+			if (spec.type !== "ImportSpecifier" || spec.importKind === "type") continue;
+			const imported = require_ast.importedName(spec);
+			for (const entry of importMap) if (entry.source === source && entry.callee === imported) importCalls.add(spec.local.name);
+		}
+	}
+	const isMatchedCall = (node) => node.type === "CallExpression" && importCalls.has(require_ast.getCalleeName(node) ?? "\0");
+	const usedIdents = /* @__PURE__ */ new Set();
+	require_ast.walk(program, (node) => {
+		if (isMatchedCall(node)) require_ast.collectArgumentIdents(node.arguments, usedIdents);
+	});
+	const moduleImports = [];
+	const keptItems = [];
+	const callIdentifier = /* @__PURE__ */ new Map();
+	/** Decide whether to keep a VariableDeclaration; records identifier labels. */
+	const computeVarDeclKeep = (varDecl) => {
+		let keep = false;
+		for (const decl of varDecl.declarations) {
+			const initCallee = require_ast.getInitCalleeName(decl.init);
+			if (initCallee !== null && importCalls.has(initCallee)) {
+				keep = true;
+				const label = require_ast.patternNames(decl.id)[0] ?? "";
+				walkMatched(decl.init, isMatchedCall, (call) => {
+					callIdentifier.set(call, label);
+				});
+			}
+			for (const name of require_ast.patternNames(decl.id)) if (usedIdents.has(name)) {
+				usedIdents.delete(name);
+				keep = true;
+			}
+		}
+		return keep;
+	};
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const child of node) visit(child);
+			return;
+		}
+		const n = node;
+		switch (n.type) {
+			case "ImportDeclaration":
+				for (const spec of n.specifiers || []) usedIdents.delete(spec.local.name);
+				moduleImports.push(n);
+				return;
+			case "VariableDeclaration":
+				if (computeVarDeclKeep(n)) keptItems.push({
+					kind: "statement",
+					node: n
+				});
+				else visitChildren(n);
+				return;
+			case "ExportNamedDeclaration":
+				if (n.declaration && n.declaration.type === "VariableDeclaration") {
+					if (computeVarDeclKeep(n.declaration)) keptItems.push({
+						kind: "statement",
+						node: n
+					});
+					else visitChildren(n.declaration);
+					return;
+				}
+				visitChildren(n);
+				return;
+			case "FunctionDeclaration":
+				visitChildren(n);
+				if (n.id && usedIdents.has(n.id.name)) {
+					keptItems.push({
+						kind: "statement",
+						node: n
+					});
+					usedIdents.delete(n.id.name);
+				}
+				return;
+			case "ClassDeclaration":
+				visitChildren(n);
+				if (n.id && usedIdents.has(n.id.name)) {
+					keptItems.push({
+						kind: "statement",
+						node: n
+					});
+					usedIdents.delete(n.id.name);
+				}
+				return;
+			case "CallExpression":
+				if (isMatchedCall(n)) {
+					keptItems.push({
+						kind: "exprCall",
+						node: n
+					});
+					return;
+				}
+				visitChildren(n);
+				return;
+			default: visitChildren(n);
+		}
+	};
+	const visitChildren = (node) => {
+		for (const key in node) {
+			if (key === "type" || key === "start" || key === "end") continue;
+			const value = node[key];
+			if (value && typeof value === "object") visit(value);
+		}
+	};
+	for (const stmt of body) visit(stmt);
+	const leftoverLets = [...usedIdents];
+	const magic = new magic_string.default(code);
+	const lineColumn = require_ast.createLineColumnLookup(code);
+	let index = 0;
+	const rewriteCall = (call) => {
+		const identifier = callIdentifier.get(call) ?? "";
+		const start = call.start;
+		const end = call.end;
+		const { line, column } = lineColumn(start);
+		const original = code.slice(start, end);
+		const replacement = `${COLLECT_RESULT_NAME}({\n  filePath: ${JSON.stringify(filename)},\n  index: ${index},\n  identifier: ${JSON.stringify(identifier)},\n  position: [${start}, ${end}],\n  sourceMap: {\n    line: ${line},\n    column: ${column}\n  },\n  result: () => ${original}\n})`;
+		magic.update(start, end, replacement);
+		index += 1;
+	};
+	for (const item of keptItems) walkMatched(item.node, isMatchedCall, rewriteCall);
+	const parts = [];
+	parts.push(`import { ${COLLECT_RESULT_NAME} as ${COLLECT_RESULT_NAME} } from "${ADAPTER_SOURCE}";`);
+	for (const imp of moduleImports) parts.push(magic.slice(imp.start, imp.end));
+	for (const name of leftoverLets) parts.push(`let ${name};`);
+	for (const item of keptItems) {
+		const sliced = magic.slice(item.node.start, item.node.end);
+		parts.push(item.kind === "exprCall" ? `${sliced};` : sliced);
+	}
+	return parts.join("\n");
+}
+/**
+* Depth-first visit of matched calls, NOT descending into a matched call's own
+* subtree (mirrors the swc visitor which replaces the node without recursing).
+*/
+function walkMatched(node, isMatched, fn) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const child of node) walkMatched(child, isMatched, fn);
+		return;
+	}
+	const n = node;
+	if (n.type === "CallExpression" && isMatched(n)) {
+		fn(n);
+		return;
+	}
+	for (const key in n) {
+		if (key === "type" || key === "start" || key === "end") continue;
+		const value = n[key];
+		if (value && typeof value === "object") walkMatched(value, isMatched, fn);
+	}
+}
+//#endregion
+exports.rewrite = rewrite;

package/rewrite.mjs

@@ -0,0 +1,185 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { collectArgumentIdents, createLineColumnLookup, getCalleeName, getInitCalleeName, importedName, patternNames, walk } from "./ast.mjs";
+import { getParser } from "./loadOxc.mjs";
+import MagicString from "magic-string";
+//#region src/rewrite.ts
+const COLLECT_RESULT_NAME = "collectResult";
+const ADAPTER_SOURCE = "@navita/adapter";
+/**
+* The core extraction rewrite. Produces an ES module (still TypeScript, still
+* pre-AMD) where:
+*  - every navita style call is wrapped in `collectResult({ ... })`,
+*  - the module is pruned to only the imports + statements needed to evaluate
+*    those calls (with nested style declarations hoisted to the top level),
+*  - unresolved free identifiers referenced inside style calls are synthesized
+*    as bare `let x;` declarations.
+*
+* This mirrors the behavior of the original Rust/swc-plugin transform (see the
+* `test!` fixtures in crates/extraction/src/lib.rs).
+*/
+function rewrite(code, { filename, importMap }) {
+	const { program } = getParser().parseSync(filename, code, {
+		lang: "tsx",
+		sourceType: "module"
+	});
+	const body = program.body;
+	const importCalls = /* @__PURE__ */ new Set();
+	const importBindings = /* @__PURE__ */ new Set();
+	for (const stmt of body) {
+		if (stmt.type !== "ImportDeclaration" || stmt.importKind === "type") continue;
+		const source = stmt.source.value;
+		for (const spec of stmt.specifiers || []) {
+			importBindings.add(spec.local.name);
+			if (spec.type !== "ImportSpecifier" || spec.importKind === "type") continue;
+			const imported = importedName(spec);
+			for (const entry of importMap) if (entry.source === source && entry.callee === imported) importCalls.add(spec.local.name);
+		}
+	}
+	const isMatchedCall = (node) => node.type === "CallExpression" && importCalls.has(getCalleeName(node) ?? "\0");
+	const usedIdents = /* @__PURE__ */ new Set();
+	walk(program, (node) => {
+		if (isMatchedCall(node)) collectArgumentIdents(node.arguments, usedIdents);
+	});
+	const moduleImports = [];
+	const keptItems = [];
+	const callIdentifier = /* @__PURE__ */ new Map();
+	/** Decide whether to keep a VariableDeclaration; records identifier labels. */
+	const computeVarDeclKeep = (varDecl) => {
+		let keep = false;
+		for (const decl of varDecl.declarations) {
+			const initCallee = getInitCalleeName(decl.init);
+			if (initCallee !== null && importCalls.has(initCallee)) {
+				keep = true;
+				const label = patternNames(decl.id)[0] ?? "";
+				walkMatched(decl.init, isMatchedCall, (call) => {
+					callIdentifier.set(call, label);
+				});
+			}
+			for (const name of patternNames(decl.id)) if (usedIdents.has(name)) {
+				usedIdents.delete(name);
+				keep = true;
+			}
+		}
+		return keep;
+	};
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const child of node) visit(child);
+			return;
+		}
+		const n = node;
+		switch (n.type) {
+			case "ImportDeclaration":
+				for (const spec of n.specifiers || []) usedIdents.delete(spec.local.name);
+				moduleImports.push(n);
+				return;
+			case "VariableDeclaration":
+				if (computeVarDeclKeep(n)) keptItems.push({
+					kind: "statement",
+					node: n
+				});
+				else visitChildren(n);
+				return;
+			case "ExportNamedDeclaration":
+				if (n.declaration && n.declaration.type === "VariableDeclaration") {
+					if (computeVarDeclKeep(n.declaration)) keptItems.push({
+						kind: "statement",
+						node: n
+					});
+					else visitChildren(n.declaration);
+					return;
+				}
+				visitChildren(n);
+				return;
+			case "FunctionDeclaration":
+				visitChildren(n);
+				if (n.id && usedIdents.has(n.id.name)) {
+					keptItems.push({
+						kind: "statement",
+						node: n
+					});
+					usedIdents.delete(n.id.name);
+				}
+				return;
+			case "ClassDeclaration":
+				visitChildren(n);
+				if (n.id && usedIdents.has(n.id.name)) {
+					keptItems.push({
+						kind: "statement",
+						node: n
+					});
+					usedIdents.delete(n.id.name);
+				}
+				return;
+			case "CallExpression":
+				if (isMatchedCall(n)) {
+					keptItems.push({
+						kind: "exprCall",
+						node: n
+					});
+					return;
+				}
+				visitChildren(n);
+				return;
+			default: visitChildren(n);
+		}
+	};
+	const visitChildren = (node) => {
+		for (const key in node) {
+			if (key === "type" || key === "start" || key === "end") continue;
+			const value = node[key];
+			if (value && typeof value === "object") visit(value);
+		}
+	};
+	for (const stmt of body) visit(stmt);
+	const leftoverLets = [...usedIdents];
+	const magic = new MagicString(code);
+	const lineColumn = createLineColumnLookup(code);
+	let index = 0;
+	const rewriteCall = (call) => {
+		const identifier = callIdentifier.get(call) ?? "";
+		const start = call.start;
+		const end = call.end;
+		const { line, column } = lineColumn(start);
+		const original = code.slice(start, end);
+		const replacement = `${COLLECT_RESULT_NAME}({\n  filePath: ${JSON.stringify(filename)},\n  index: ${index},\n  identifier: ${JSON.stringify(identifier)},\n  position: [${start}, ${end}],\n  sourceMap: {\n    line: ${line},\n    column: ${column}\n  },\n  result: () => ${original}\n})`;
+		magic.update(start, end, replacement);
+		index += 1;
+	};
+	for (const item of keptItems) walkMatched(item.node, isMatchedCall, rewriteCall);
+	const parts = [];
+	parts.push(`import { ${COLLECT_RESULT_NAME} as ${COLLECT_RESULT_NAME} } from "${ADAPTER_SOURCE}";`);
+	for (const imp of moduleImports) parts.push(magic.slice(imp.start, imp.end));
+	for (const name of leftoverLets) parts.push(`let ${name};`);
+	for (const item of keptItems) {
+		const sliced = magic.slice(item.node.start, item.node.end);
+		parts.push(item.kind === "exprCall" ? `${sliced};` : sliced);
+	}
+	return parts.join("\n");
+}
+/**
+* Depth-first visit of matched calls, NOT descending into a matched call's own
+* subtree (mirrors the swc visitor which replaces the node without recursing).
+*/
+function walkMatched(node, isMatched, fn) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const child of node) walkMatched(child, isMatched, fn);
+		return;
+	}
+	const n = node;
+	if (n.type === "CallExpression" && isMatched(n)) {
+		fn(n);
+		return;
+	}
+	for (const key in n) {
+		if (key === "type" || key === "start" || key === "end") continue;
+		const value = n[key];
+		if (value && typeof value === "object") walkMatched(value, isMatched, fn);
+	}
+}
+//#endregion
+export { rewrite };

package/stripTypes.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_loadOxc = require("./loadOxc.cjs");
+//#region src/stripTypes.ts
+/**
+* Strip TypeScript types (and transform JSX) from a module, leaving an ES
+* module of plain JavaScript. Module syntax (import/export) is preserved.
+*/
+function stripTypes(filename, code) {
+	return require_loadOxc.getTransform().transformSync(filename, code, {}).code;
+}
+//#endregion
+exports.stripTypes = stripTypes;

package/stripTypes.mjs

@@ -0,0 +1,14 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { getTransform } from "./loadOxc.mjs";
+//#region src/stripTypes.ts
+/**
+* Strip TypeScript types (and transform JSX) from a module, leaving an ES
+* module of plain JavaScript. Module syntax (import/export) is preserved.
+*/
+function stripTypes(filename, code) {
+	return getTransform().transformSync(filename, code, {}).code;
+}
+//#endregion
+export { stripTypes };

package/toAmd.cjs

@@ -0,0 +1,190 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_ast = require("./ast.cjs");
+const require_loadOxc = require("./loadOxc.cjs");
+//#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 } = require_loadOxc.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: require_ast.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) require_ast.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
+exports.esmToAmd = esmToAmd;