refactor: remove the need of having adapters for parser (yagni)

Author: adbayb

packages/core/src/index.ts

@@ -1,24 +1,33 @@
 import { readFileSync } from "fs";
 
 import { scan } from "./scanner";
+import { createItem } from "./entities/item";
 import type { Item } from "./entities/item";
 import { parse } from "./parser";
+import { createLocation } from "./entities/location";
 
 export const esonar = async () => {
 	const projects = scan();
 	const items: Item[] = [];
 
 	for (const project of projects) {
 		for (const file of project.files) {
-			const content = readFileSync(file, "utf-8");
+			const code = readFileSync(file, "utf-8");
 			const module = project.metadata.name;
 
-			const projectItems = await parse(content, {
-				file,
-				module,
+			await parse(code, (item) => {
+				items.push(
+					createItem({
+						...item,
+						location: createLocation({
+							code,
+							file,
+							module,
+							offset: item.offset,
+						}),
+					}),
+				);
 			});
-
-			items.push(...projectItems);
 		}
 	}
 

packages/core/src/parser/adapters/swc.ts

@@ -1,41 +1,156 @@
+import type {
+	ImportDeclaration,
+	JSXAttrValue,
+	JSXOpeningElement,
+	Module,
+	TsType,
+} from "@swc/core";
+import { parse as swcParse } from "@swc/core";
+import { walk } from "astray";
+
 import type { Import } from "../entities/import";
 import type { Item } from "../entities/item";
-import { createItem } from "../entities/item";
-import type { Location } from "../entities/location";
-import { createLocation } from "../entities/location";
+import type { Primitive } from "../types";
+
+export const parse = async (
+	code: string,
+	addCallback: (
+		item: Pick<Item, "args" | "module" | "name" | "type"> & {
+			offset: number;
+		},
+	) => void,
+) => {
+	const imports = new Map<Import["alias"], Import>();
 
-import { parser } from "./adapters/swc";
+	const ast = await swcParse(code, {
+		syntax: "typescript",
+		tsx: true,
+	});
 
-type Context = Pick<Location, "file" | "module">;
+	/**
+	 * Traverse method using the visitor design pattern.
+	 * SWC traverser (`import { Visitor } from "@swc/core/Visitor"`) is not used since it doesn't traverse recursively nodes
+	 * (at least, recursive `JSXOpeningElement`s are not retrieved)
+	 */
+	// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+	walk<Module, void, AST>(ast, {
+		ImportDeclaration(node) {
+			const module = node.source.value;
 
-export const parse = async (code: string, context: Context) => {
-	const items: Item[] = [];
-	const imports = new Map<Import["alias"], Import>();
+			node.specifiers.forEach((specifier) => {
+				const specifierValue = specifier.local.value;
 
-	await parser.execute(code, {
-		onAddingItem: ({ name, args, module, offset, type }) => {
-			items.push(
-				createItem({
-					name,
-					args,
-					location: createLocation({
-						code,
-						file: context.file,
-						module: context.module,
-						offset,
-					}),
+				imports.set(specifierValue, {
+					name:
+						// @ts-expect-error `imported` field is exposed by `ImportSpecifier` node (@todo: fix the typing issue in @swc/core)
+						// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+						(specifier.imported?.value || specifierValue) as string,
+					alias: specifierValue,
 					module,
-					type,
-				}),
-			);
+				});
+			});
 		},
-		onGettingImport(name) {
-			return imports.get(name);
+		JSXOpeningElement(node) {
+			if (node.name.type !== "Identifier") return;
+
+			const name = node.name.value;
+			const importMetadata = imports.get(name);
+
+			if (!importMetadata) return;
+
+			addCallback({
+				name: importMetadata.name,
+				args: {
+					data: node.attributes.reduce<Record<string, unknown>>(
+						(props, prop) => {
+							if (
+								prop.type !== "JSXAttribute" ||
+								prop.name.type !== "Identifier"
+							)
+								return props;
+
+							props[prop.name.value] = getLiteralValue(
+								prop.value,
+							);
+
+							return props;
+						},
+						{},
+					),
+					isSpread: false,
+				},
+				module: importMetadata.module,
+				offset: node.span.start,
+				type: "component",
+			});
 		},
-		onSettingImport(data) {
-			imports.set(data.alias, data);
+		TsType(node) {
+			let typeValue = "";
+
+			if (
+				node.type === "TsTypeReference" &&
+				node.typeName.type === "Identifier"
+			) {
+				typeValue = node.typeName.value;
+			}
+
+			if (
+				node.type === "TsIndexedAccessType" &&
+				node.objectType.type === "TsTypeReference" &&
+				node.objectType.typeName.type === "Identifier"
+			) {
+				typeValue = node.objectType.typeName.value;
+			}
+
+			const importMetadata = imports.get(typeValue);
+
+			if (!importMetadata) return;
+
+			addCallback({
+				name: importMetadata.name,
+				module: importMetadata.module,
+				offset: node.span.start,
+				type: "type",
+			});
 		},
 	});
+};
+
+type AST = {
+	ImportDeclaration: ImportDeclaration;
+	JSXOpeningElement: JSXOpeningElement;
+	TsType: TsType;
+};
+
+/**
+ * Helper to unify the way unknown AST token are persisted
+ * @param token AST token value
+ * @returns Formatted AST token
+ */
+const getUnknownValue = (token: string) => `#${token}`;
+
+const getLiteralValue = (node: JSXAttrValue | undefined): Primitive => {
+	if (!node) {
+		return true;
+	}
+
+	if (node.type === "NullLiteral") {
+		return null;
+	}
+
+	if (
+		node.type === "StringLiteral" ||
+		node.type === "NumericLiteral" ||
+		node.type === "BigIntLiteral" ||
+		node.type === "BooleanLiteral" ||
+		node.type === "JSXText"
+	) {
+		return node.value;
+	}
+
+	if (node.type === "JSXExpressionContainer") {
+		return getLiteralValue(node.expression as JSXAttrValue);
+	}
 
-	return items;
+	return getUnknownValue(node.type);
 };