Website Structure

Frontend-Learner/node_modules/ast-walker-scope/dist/index.d.ts

@@ -0,0 +1,51 @@
+import { ParseResult, ParserPlugin } from "@babel/parser";
+import { File, Function, Identifier, Node, VariableDeclaration } from "@babel/types";
+
+//#region src/types.d.ts
+interface ParseOptions {
+  filename?: string;
+  parserPlugins?: ParserPlugin[];
+}
+type Scope = Record<string, Node>;
+interface WalkerContext {
+  skip: () => void;
+  remove: () => void;
+  replace: (node: Node) => void;
+}
+interface ScopeContext {
+  parent: Node | undefined | null;
+  key: string | undefined | null;
+  index: number | undefined | null;
+  scope: Scope;
+  scopes: Scope[];
+  level: number;
+}
+interface WalkerHooks {
+  enter?: (this: WalkerContext & ScopeContext, node: Node) => void;
+  enterAfter?: (this: ScopeContext, node: Node) => void;
+  leave?: (this: WalkerContext & ScopeContext, node: Node) => void;
+  leaveAfter?: (this: ScopeContext, node: Node) => void;
+}
+//#endregion
+//#region src/utils/babel.d.ts
+declare const isNewScope: (node: Node | undefined | null) => boolean;
+declare function walkFunctionParams(node: Function, onIdent: (id: Identifier) => void): void;
+declare function extractIdentifiers(param: Node, nodes?: Identifier[]): Identifier[];
+declare function babelParse(code: string, filename?: string, parserPlugins?: ParserPlugin[]): ParseResult<File>;
+declare function walkVariableDeclaration(stmt: VariableDeclaration, register: (id: Identifier) => void): void;
+declare function walkNewIdentifier(node: Node, register: (id: Identifier) => void): void;
+//#endregion
+//#region src/index.d.ts
+declare function walk(code: string, walkHooks: WalkerHooks, {
+  filename,
+  parserPlugins
+}?: ParseOptions): ParseResult<File>;
+declare function walkAST(node: Node | Node[], {
+  enter,
+  leave,
+  enterAfter,
+  leaveAfter
+}: WalkerHooks): void;
+declare function getRootScope(nodes: Node[]): Scope;
+//#endregion
+export { ParseOptions, Scope, ScopeContext, WalkerContext, WalkerHooks, babelParse, extractIdentifiers, getRootScope, isNewScope, walk, walkAST, walkFunctionParams, walkNewIdentifier, walkVariableDeclaration };

Frontend-Learner/node_modules/ast-walker-scope/dist/index.js

@@ -0,0 +1,175 @@
+import { isFunctionType, walkAST as walkAST$1 } from "ast-kit";
+import { parse } from "@babel/parser";
+
+//#region src/utils/babel.ts
+const NEW_SCOPE = new Set([
+	"CatchClause",
+	"ForInStatement",
+	"ForOfStatement"
+]);
+const isNewScope = (node) => node && NEW_SCOPE.has(node.type) || isFunctionType(node);
+function walkFunctionParams(node, onIdent) {
+	for (const p of node.params) for (const id of extractIdentifiers(p)) onIdent(id);
+}
+function extractIdentifiers(param, nodes = []) {
+	switch (param.type) {
+		case "Identifier":
+			nodes.push(param);
+			break;
+		case "MemberExpression": {
+			let object = param;
+			while (object.type === "MemberExpression") object = object.object;
+			nodes.push(object);
+			break;
+		}
+		case "ObjectPattern":
+			for (const prop of param.properties) if (prop.type === "RestElement") extractIdentifiers(prop.argument, nodes);
+			else extractIdentifiers(prop.value, nodes);
+			break;
+		case "ArrayPattern":
+			param.elements.forEach((element) => {
+				if (element) extractIdentifiers(element, nodes);
+			});
+			break;
+		case "RestElement":
+			extractIdentifiers(param.argument, nodes);
+			break;
+		case "AssignmentPattern":
+			extractIdentifiers(param.left, nodes);
+			break;
+	}
+	return nodes;
+}
+function babelParse(code, filename, parserPlugins = []) {
+	const plugins = parserPlugins || [];
+	if (filename) {
+		if (/\.tsx?$/.test(filename)) plugins.push("typescript");
+		if (filename.endsWith("x")) plugins.push("jsx");
+	}
+	return parse(code, {
+		sourceType: "module",
+		plugins
+	});
+}
+function walkVariableDeclaration(stmt, register) {
+	if (stmt.declare) return;
+	for (const decl of stmt.declarations) for (const id of extractIdentifiers(decl.id)) register(id);
+}
+function walkNewIdentifier(node, register) {
+	if (node.type === "ExportNamedDeclaration" && node.declaration) node = node.declaration;
+	if (node.type === "VariableDeclaration") walkVariableDeclaration(node, register);
+	else if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
+		if (node.declare || !node.id) return;
+		register(node.id);
+	} else if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration") walkVariableDeclaration(node.declaration, register);
+}
+
+//#endregion
+//#region src/index.ts
+function walk(code, walkHooks, { filename, parserPlugins } = {}) {
+	const ast = babelParse(code, filename, parserPlugins);
+	walkAST(ast.program, walkHooks);
+	return ast;
+}
+function walkAST(node, { enter, leave, enterAfter, leaveAfter }) {
+	let currentScope = {};
+	const scopeStack = [currentScope];
+	walkAST$1(Array.isArray(node) ? {
+		type: "Program",
+		body: node
+	} : node, {
+		enter(node$1, parent, ...args) {
+			const { scopeCtx, walkerCtx, isSkip, isRemoved, getNode } = getHookContext(this, node$1, [parent, ...args]);
+			enter?.call({
+				...scopeCtx(),
+				...walkerCtx
+			}, node$1);
+			node$1 = getNode();
+			if (!isSkip() && !isRemoved()) {
+				enterNode(node$1, parent);
+				enterAfter?.call(scopeCtx(), node$1);
+			}
+		},
+		leave(node$1, parent, ...args) {
+			const { scopeCtx, walkerCtx, isSkip, isRemoved, getNode } = getHookContext(this, node$1, [parent, ...args]);
+			leave?.call({
+				...scopeCtx(),
+				...walkerCtx
+			}, node$1);
+			node$1 = getNode();
+			if (!isSkip() && !isRemoved()) {
+				leaveNode(node$1, parent);
+				leaveAfter?.call(scopeCtx(), node$1);
+			}
+		}
+	});
+	function getHookContext(ctx, node$1, [parent, key, index]) {
+		const scopeCtx = () => ({
+			parent,
+			key,
+			index,
+			scope: scopeStack.reduce((prev, curr) => ({
+				...prev,
+				...curr
+			}), {}),
+			scopes: scopeStack,
+			level: scopeStack.length
+		});
+		let isSkip = false;
+		let isRemoved = false;
+		let newNode = node$1;
+		return {
+			scopeCtx,
+			walkerCtx: {
+				skip() {
+					isSkip = true;
+					ctx.skip();
+				},
+				replace(node$2) {
+					newNode = node$2;
+				},
+				remove() {
+					isRemoved = true;
+				}
+			},
+			isSkip: () => isSkip,
+			isRemoved: () => isRemoved,
+			getNode: () => newNode
+		};
+	}
+	function enterNode(node$1, parent) {
+		if (isNewScope(node$1) || node$1.type === "BlockStatement" && !isNewScope(parent)) scopeStack.push(currentScope = {});
+		if (isFunctionType(node$1)) walkFunctionParams(node$1, registerBinding);
+		else if (node$1.type === "CatchClause" && node$1.param && node$1.param.type === "Identifier") registerBinding(node$1.param);
+		if (node$1.type === "BlockStatement" || node$1.type === "Program") {
+			for (const stmt of node$1.body) if (stmt.type === "VariableDeclaration" && stmt.kind === "var") walkVariableDeclaration(stmt, registerBinding);
+			else if (stmt.type === "FunctionDeclaration" && stmt.id) registerBinding(stmt.id);
+		}
+	}
+	function leaveNode(node$1, parent) {
+		if (isNewScope(node$1) || node$1.type === "BlockStatement" && !isNewScope(parent)) {
+			scopeStack.pop();
+			currentScope = scopeStack.at(-1);
+		}
+		walkNewIdentifier(node$1, registerBinding);
+	}
+	function registerBinding(id) {
+		if (currentScope) currentScope[id.name] = id;
+		else error("registerBinding called without active scope, something is wrong.", id);
+	}
+	function error(msg, node$1) {
+		const e = new Error(msg);
+		e.node = node$1;
+		throw e;
+	}
+}
+function getRootScope(nodes) {
+	const scope = {};
+	for (const node of nodes) walkNewIdentifier(node, (id) => {
+		scope[id.name] = id;
+	});
+	return scope;
+}
+
+//#endregion
+export { babelParse, extractIdentifiers, getRootScope, isNewScope, walk, walkAST, walkFunctionParams, walkNewIdentifier, walkVariableDeclaration };