@alint-js/core 0.1.4 → 0.1.5

package/dist/extract-BVbjWXMC.mjs

@@ -0,0 +1,676 @@
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { clamp } from "es-toolkit";
+import { createHash } from "node:crypto";
+import { parseSync } from "oxc-parser";
+//#region src/core/hash.ts
+function createStableHasher() {
+	const hash = createHash("sha256");
+	const api = {
+		digest: () => hash.digest("hex"),
+		update: (value) => {
+			const serialized = stableStringify(value);
+			hash.update(`${serialized.length}:`);
+			hash.update(serialized);
+			return api;
+		}
+	};
+	return api;
+}
+function hashText(text) {
+	return createHash("sha256").update(text).digest("hex");
+}
+function stableHash(value) {
+	return hashText(stableStringify(value));
+}
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+	if (typeof value === "object" && value !== null) {
+		const record = value;
+		return `{${Object.keys(record).sort().flatMap((key) => {
+			const property = record[key];
+			return property === void 0 ? [] : [`${JSON.stringify(key)}:${stableStringify(property)}`];
+		}).join(",")}}`;
+	}
+	return JSON.stringify(value);
+}
+//#endregion
+//#region src/core/source/runtime.ts
+var SourceChangedError = class extends Error {
+	path;
+	expectedHash;
+	actualHash;
+	constructor(path, expectedHash, actualHash) {
+		super(`Source changed after planning: "${path}" (expected ${expectedHash}, read ${actualHash}).`);
+		this.path = path;
+		this.expectedHash = expectedHash;
+		this.actualHash = actualHash;
+		this.name = "SourceChangedError";
+	}
+};
+function createSourceFile(path, text) {
+	return {
+		contentHash: hashText(text),
+		language: inferLanguage(path),
+		lines: text.split(/\r?\n/),
+		path,
+		text
+	};
+}
+function createSourceRuntime(options = {}) {
+	return {
+		extract: options.extract ?? extractThrowUndefined,
+		getText,
+		readFile: options.readFile ?? readSourceFile,
+		sliceLines,
+		sliceRange
+	};
+}
+function getText(file) {
+	return file.text;
+}
+function sliceLines(file, range) {
+	const startLine = clampLine(range.startLine, file.lines.length);
+	const endLine = clampLine(range.endLine, file.lines.length);
+	const orderedStartLine = Math.min(startLine, endLine);
+	const orderedEndLine = Math.max(startLine, endLine);
+	const text = file.lines.slice(orderedStartLine - 1, orderedEndLine).join("\n");
+	return {
+		filePath: file.path,
+		loc: {
+			end: {
+				column: file.lines[orderedEndLine - 1]?.length ?? 0,
+				line: orderedEndLine
+			},
+			start: {
+				column: 0,
+				line: orderedStartLine
+			}
+		},
+		text
+	};
+}
+function sliceRange(file, range) {
+	const start = clampOffset(range.start, file.text.length);
+	const end = clampOffset(range.end, file.text.length);
+	const orderedStart = Math.min(start, end);
+	const orderedEnd = Math.max(start, end);
+	return {
+		filePath: file.path,
+		loc: {
+			end: getPosition(file.text, orderedEnd),
+			start: getPosition(file.text, orderedStart)
+		},
+		text: file.text.slice(orderedStart, orderedEnd)
+	};
+}
+function withLanguage(file, language) {
+	if (file.language === language) return file;
+	return {
+		...file,
+		language
+	};
+}
+function clampLine(line, lineCount) {
+	if (lineCount === 0) return 1;
+	return clamp(Math.trunc(line), 1, lineCount);
+}
+function clampOffset(offset, textLength) {
+	return clamp(Math.trunc(offset), 0, textLength);
+}
+/** Throws a TypeError indicating that the extractor is not defined. */
+function extractThrowUndefined(filePath) {
+	return Promise.reject(/* @__PURE__ */ new TypeError(`Cannot extract "${filePath}": this source runtime was created without an extractor, so there is no config to resolve the file's language against. Only the runtime a run hands to rules (ctx.src) can extract.`));
+}
+function getPosition(text, offset) {
+	let line = 1;
+	let column = 0;
+	let index = 0;
+	while (index < offset) {
+		const character = text[index];
+		if (character === "\r") {
+			if (text[index + 1] === "\n" && index + 1 < offset) index += 1;
+			line += 1;
+			column = 0;
+		} else if (character === "\n") {
+			line += 1;
+			column = 0;
+		} else column += 1;
+		index += 1;
+	}
+	return {
+		column,
+		line
+	};
+}
+function inferLanguage(path) {
+	switch (extname(path)) {
+		case ".cjs":
+		case ".js":
+		case ".jsx":
+		case ".mjs": return "javascript";
+		case ".cts":
+		case ".mts":
+		case ".ts":
+		case ".tsx": return "typescript";
+		default: return "unknown";
+	}
+}
+async function readSourceFile(input) {
+	const path = typeof input === "string" ? input : input.path;
+	const file = createSourceFile(path, await readFile(path, "utf8"));
+	if (typeof input !== "string") {
+		if (file.contentHash !== input.contentHash) throw new SourceChangedError(input.path, input.contentHash, file.contentHash);
+	}
+	return file;
+}
+//#endregion
+//#region src/core/source/identity.ts
+/** A target's identity from its position. */
+function targetIdentity(kind, name, range) {
+	return `${kind}:${name ?? "anonymous"}:${range.start}:${range.end}`;
+}
+/**
+* Swaps a target's positional identity for its name, where that name is unique among these targets.
+*
+* Identities key caches, so a function that only moved should keep the identity it had. Two targets
+* sharing a name cannot be told apart that way, so both keep the positional form.
+*
+* Run every function and class target through this. Skip it in one producer and the same function
+* ends up with a different identity depending on which language read it.
+*/
+function withStableIdentities(targets) {
+	const nameCounts = /* @__PURE__ */ new Map();
+	for (const target of targets) {
+		const identity = nameIdentity(target);
+		if (identity) nameCounts.set(identity, (nameCounts.get(identity) ?? 0) + 1);
+	}
+	return targets.map((target) => {
+		const identity = nameIdentity(target);
+		if (!identity || nameCounts.get(identity) !== 1) return target;
+		return {
+			...target,
+			identity
+		};
+	});
+}
+function nameIdentity(target) {
+	if (target.kind !== "class" && target.kind !== "function" || !target.name) return;
+	return `${target.kind}:${target.name}`;
+}
+//#endregion
+//#region src/core/languages/js/ast.ts
+function asAstNode(value) {
+	return isAstNode(value) ? value : void 0;
+}
+function childNodes(node) {
+	const children = [];
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "type" || key === "start" || key === "end" || key === "range") continue;
+		if (Array.isArray(value)) children.push(...value.filter(isAstNode));
+		else if (isAstNode(value)) children.push(value);
+	}
+	return children;
+}
+function getRange(node) {
+	if (typeof node.start === "number" && typeof node.end === "number") return {
+		end: node.end,
+		start: node.start
+	};
+	if (Array.isArray(node.range) && node.range.length === 2) return {
+		end: node.range[1],
+		start: node.range[0]
+	};
+}
+function isAstNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+//#endregion
+//#region src/core/languages/js/info.ts
+/**
+* A `TS…` node is a type, and a type is never renameable, so the subtree is skipped — that drops
+* annotations, interfaces and type aliases under one rule. tree-sitter needs no such rule: its
+* grammar gives type names their own node type, `type_identifier`, separate from `identifier`.
+*
+* These few `TS…` nodes wrap real code, so they are walked at the named field and nowhere else.
+*/
+const TS_INNER_FIELD = {
+	TSAsExpression: "expression",
+	TSInstantiationExpression: "expression",
+	TSNonNullExpression: "expression",
+	TSParameterProperty: "parameter",
+	TSSatisfiesExpression: "expression",
+	TSTypeAnnotation: "typeAnnotation",
+	TSTypeAssertion: "expression"
+};
+function collectSourceInfo(program, comments) {
+	const info = {
+		calls: [],
+		commentRanges: [],
+		declaredNames: /* @__PURE__ */ new Map(),
+		identifierRanges: /* @__PURE__ */ new Map()
+	};
+	for (const comment of comments) {
+		const range = isAstNode(comment) ? getRange(comment) : void 0;
+		if (range) info.commentRanges.push(range);
+	}
+	walk(program, info);
+	info.calls.sort((left, right) => left.range.start - right.range.start);
+	return info;
+}
+/**
+* `name` is resolved by the caller, because a function may be named by something outside itself:
+* `const trim = () => {}` names the arrow from its declarator.
+*/
+function functionInfo(node, range, name, exported, info) {
+	const { arrowExpression, statements } = bodyOf(node);
+	const declaredNames = new Set([...info.declaredNames].filter(([start]) => start >= range.start && start < range.end).sort(([left], [right]) => left - right).map(([, name]) => name));
+	if (name !== void 0) declaredNames.add(name);
+	return {
+		bodyIsSingleExpression: arrowExpression || statements.length === 1 && !holdsBlock(statements[0]),
+		bodyStatements: statements.length,
+		commentRanges: rangesInside(info.commentRanges, range),
+		declaredNames: [...declaredNames],
+		exported,
+		identifierRanges: withOwnName(rangesInside([...info.identifierRanges.values()], range), node, range)
+	};
+}
+function asNodeList(value) {
+	return Array.isArray(value) ? value.filter(isAstNode) : [];
+}
+function bodyOf(node) {
+	const callable = (node.type === "MethodDefinition" ? asAstNode(node.value) : void 0) ?? node;
+	const body = asAstNode(callable.body);
+	if (!body) return {
+		arrowExpression: false,
+		statements: []
+	};
+	if (callable.type === "ArrowFunctionExpression" && body.type !== "BlockStatement") return {
+		arrowExpression: true,
+		statements: [body]
+	};
+	return {
+		arrowExpression: false,
+		statements: asNodeList(body.body)
+	};
+}
+function callSiteOf(node) {
+	const callee = asAstNode(node.callee);
+	if (!callee) return;
+	if (callee.type === "Identifier") {
+		const range = nameRangeOf(callee);
+		return range && callee.name !== void 0 ? {
+			name: callee.name,
+			range
+		} : void 0;
+	}
+	if (callee.type !== "MemberExpression" || callee.computed === true) return;
+	const property = asAstNode(callee.property);
+	const range = property ? nameRangeOf(property) : void 0;
+	return range && property?.name !== void 0 ? {
+		name: property.name,
+		range
+	} : void 0;
+}
+/** A nested block is how a branch or a loop is written, so it disqualifies a single-expression body. */
+function holdsBlock(node) {
+	if (!node) return false;
+	const pending = childNodes(node);
+	while (pending.length > 0) {
+		const next = pending.pop();
+		if (next === void 0) continue;
+		if (next.type === "BlockStatement") return true;
+		pending.push(...childNodes(next));
+	}
+	return false;
+}
+/**
+* An identifier node spans its type annotation: `entry: Entry` is one `Identifier` whose `name` is
+* `entry`. The annotation has to be cut back off, or replacing the identifier would take the type
+* with it and a copy that renamed nothing but its parameter would stop matching.
+*
+* NOTICE: `name` is the DECODED identifier, so one written with a unicode escape measures shorter
+* than the token it came from and this range cuts inside it, where tree-sitter reports the whole
+* token — the two extractors disagree for such identifiers. Left as is because a correct fix needs
+* the parser to report the name's own span. Removal condition: oxc exposes that span.
+*/
+function nameRangeOf(node) {
+	const range = getRange(node);
+	if (!range || typeof node.name !== "string") return;
+	return {
+		end: Math.min(range.end, range.start + node.name.length),
+		start: range.start
+	};
+}
+function rangesInside(ranges, outer) {
+	return ranges.filter((range) => range.start >= outer.start && range.end <= outer.end).map((range) => ({
+		end: range.end - outer.start,
+		start: range.start - outer.start
+	})).sort((left, right) => left.start - right.start);
+}
+function recordDeclared(node, info) {
+	const range = nameRangeOf(node);
+	if (range && node.name !== void 0) info.declaredNames.set(range.start, node.name);
+}
+function recordIdentifier(node, info) {
+	const range = nameRangeOf(node);
+	if (range) info.identifierRanges.set(range.start, range);
+}
+function recordPatternNames(node, info) {
+	if (!node) return;
+	switch (node.type) {
+		case "ArrayPattern":
+			for (const element of asNodeList(node.elements)) recordPatternNames(element, info);
+			break;
+		case "AssignmentPattern":
+			recordPatternNames(asAstNode(node.left), info);
+			break;
+		case "Identifier":
+			recordDeclared(node, info);
+			break;
+		case "ObjectPattern":
+			for (const property of asNodeList(node.properties)) if (property.type === "RestElement") recordPatternNames(asAstNode(property.argument), info);
+			else if (!property.shorthand) recordPatternNames(asAstNode(property.value), info);
+			break;
+		case "RestElement":
+			recordPatternNames(asAstNode(node.argument), info);
+			break;
+	}
+}
+function walk(node, info) {
+	const type = node.type ?? "";
+	if (type === "TSTypePredicate") {
+		const parameterName = asAstNode(node.parameterName);
+		if (parameterName) recordIdentifier(parameterName, info);
+		return;
+	}
+	if (type.startsWith("TS")) {
+		const inner = asAstNode(node[TS_INNER_FIELD[type] ?? ""]);
+		if (inner) walk(inner, info);
+		return;
+	}
+	switch (type) {
+		case "ArrowFunctionExpression":
+		case "FunctionDeclaration":
+		case "FunctionExpression":
+			recordPatternNames(asAstNode(node.id), info);
+			for (const parameter of asNodeList(node.params)) recordPatternNames(parameter, info);
+			break;
+		case "CallExpression": {
+			const call = callSiteOf(node);
+			if (call) info.calls.push(call);
+			break;
+		}
+		case "CatchClause":
+			recordPatternNames(asAstNode(node.param), info);
+			break;
+		case "Identifier":
+			recordIdentifier(node, info);
+			return;
+		case "MemberExpression": {
+			const object = asAstNode(node.object);
+			if (object) walk(object, info);
+			if (node.computed === true) {
+				const property = asAstNode(node.property);
+				if (property) walk(property, info);
+			}
+			return;
+		}
+		case "MethodDefinition":
+		case "Property":
+		case "PropertyDefinition": {
+			if (node.shorthand === true) return;
+			if (node.computed === true) {
+				const key = asAstNode(node.key);
+				if (key) walk(key, info);
+			}
+			const value = asAstNode(node.value);
+			if (value) walk(value, info);
+			return;
+		}
+		case "VariableDeclarator":
+			recordPatternNames(asAstNode(node.id), info);
+			break;
+	}
+	for (const child of childNodes(node)) walk(child, info);
+}
+/**
+* A method's name is a key, which the walk keeps out of the identifier set, so it is put back here.
+* A declared function's name is already there, hence the dedupe by start offset.
+*/
+function withOwnName(ranges, node, outer) {
+	const nameNode = asAstNode(node.id) ?? (node.type === "MethodDefinition" ? asAstNode(node.key) : void 0);
+	const name = nameNode ? nameRangeOf(nameNode) : void 0;
+	if (!name || name.start < outer.start || name.end > outer.end) return ranges;
+	const rebased = {
+		end: name.end - outer.start,
+		start: name.start - outer.start
+	};
+	if (ranges.some((range) => range.start === rebased.start)) return ranges;
+	return [...ranges, rebased].sort((left, right) => left.start - right.start);
+}
+//#endregion
+//#region src/core/languages/js/parser.ts
+function parseSync$1(filename, sourceText, options) {
+	return parseSync(filename, sourceText, options);
+}
+//#endregion
+//#region src/core/languages/js/extract.ts
+function extractJsSourceTargets(file) {
+	const result = parseSync$1(file.path, file.text, { sourceType: "module" });
+	const program = result.program;
+	const state = {
+		bindingNodes: /* @__PURE__ */ new Map(),
+		exportedNodes: /* @__PURE__ */ new Set(),
+		file,
+		inferredNames: /* @__PURE__ */ new Map(),
+		info: collectSourceInfo(program, result.comments),
+		seenClasses: /* @__PURE__ */ new Set(),
+		seenFunctions: /* @__PURE__ */ new Set(),
+		targets: [],
+		visited: /* @__PURE__ */ new Set()
+	};
+	collectModuleBindings(program, state);
+	collectExportedBindings(program, state);
+	visit(program, state);
+	const sortedTargets = [...state.targets].sort((left, right) => (left.range?.start ?? 0) - (right.range?.start ?? 0));
+	return [createFileTarget(file, state.info), ...withStableIdentities(sortedTargets)];
+}
+function addClassTarget(node, state) {
+	if (state.seenClasses.has(node)) return;
+	const target = createClassTarget(node, state);
+	if (!target) return;
+	state.seenClasses.add(node);
+	state.targets.push(target);
+}
+function addFunctionTarget(node, state) {
+	if (state.seenFunctions.has(node)) return;
+	const target = createFunctionTarget(node, state);
+	if (!target) return;
+	state.seenFunctions.add(node);
+	state.targets.push(target);
+}
+function collectDeclarationBindings(node, state) {
+	const name = getNodeName(node);
+	if (name && (isClassNode(node) || isFunctionNode(node))) {
+		state.bindingNodes.set(name, node);
+		return;
+	}
+	if (node.type !== "VariableDeclaration" || !Array.isArray(node.declarations)) return;
+	for (const declarator of node.declarations) {
+		if (!isAstNode(declarator)) continue;
+		const id = asAstNode(declarator.id);
+		const initializer = asAstNode(declarator.init);
+		if (typeof id?.name === "string" && initializer && (isClassNode(initializer) || isFunctionNode(initializer))) state.bindingNodes.set(id.name, initializer);
+	}
+}
+function collectExportedBindings(node, state) {
+	if (!node) return;
+	if (Array.isArray(node)) {
+		for (const child of node) collectExportedBindings(child, state);
+		return;
+	}
+	if (node.type === "ExportNamedDeclaration" && !node.source && Array.isArray(node.specifiers)) for (const specifier of node.specifiers) {
+		if (!isAstNode(specifier) || specifier.type !== "ExportSpecifier") continue;
+		const local = asAstNode(specifier.local);
+		if (typeof local?.name === "string") markExportedBinding(local.name, state);
+	}
+	else if (node.type === "ExportDefaultDeclaration") {
+		const declaration = asAstNode(node.declaration);
+		if (typeof declaration?.name === "string") markExportedBinding(declaration.name, state);
+	}
+	for (const value of Object.values(node)) if (Array.isArray(value)) collectExportedBindings(value.filter(isAstNode), state);
+	else if (isAstNode(value)) collectExportedBindings(value, state);
+}
+function collectModuleBindings(program, state) {
+	if (!Array.isArray(program.body)) return;
+	for (const statement of program.body) {
+		if (!isAstNode(statement)) continue;
+		const declaration = isExportDeclaration(statement) ? asAstNode(statement.declaration) : statement;
+		if (declaration) collectDeclarationBindings(declaration, state);
+	}
+}
+function createClassTarget(node, state) {
+	const range = getRange(node);
+	if (!range) return;
+	const source = sliceRange(state.file, range);
+	const name = getNodeName(node) ?? state.inferredNames.get(node);
+	return {
+		file: state.file,
+		identity: targetIdentity("class", name, range),
+		kind: "class",
+		language: state.file.language,
+		loc: source.loc,
+		metadata: { exported: isExportedTarget(node, state) },
+		name,
+		origin: {
+			physicalPath: state.file.path,
+			range
+		},
+		range,
+		text: source.text
+	};
+}
+function createFileTarget(file, info) {
+	return {
+		file,
+		identity: "file",
+		kind: "file",
+		language: file.language,
+		metadata: { calls: info.calls },
+		origin: { physicalPath: file.path },
+		text: file.text
+	};
+}
+function createFunctionTarget(node, state) {
+	const range = getRange(node);
+	if (!range) return;
+	const source = sliceRange(state.file, range);
+	const functionNode = node.type === "MethodDefinition" ? asAstNode(node.value) : node;
+	const name = getNodeName(node) ?? getNodeName(functionNode) ?? state.inferredNames.get(node);
+	const exported = isExportedTarget(node, state);
+	return {
+		file: state.file,
+		identity: targetIdentity("function", name, range),
+		kind: "function",
+		language: state.file.language,
+		loc: source.loc,
+		metadata: {
+			async: functionNode?.async === true,
+			exported,
+			function: functionInfo(node, range, name, exported, state.info)
+		},
+		name,
+		origin: {
+			physicalPath: state.file.path,
+			range
+		},
+		range,
+		text: source.text
+	};
+}
+function getNodeName(node) {
+	if (!node) return;
+	if (typeof node.name === "string") return node.name;
+	const id = asAstNode(node.id);
+	if (typeof id?.name === "string") return id.name;
+	const key = asAstNode(node.key);
+	if (typeof key?.name === "string") return key.name;
+	if (typeof key?.value === "string" || typeof key?.value === "number") return String(key.value);
+}
+function inferChildName(parent, key, child, state) {
+	if (state.inferredNames.has(child)) return;
+	if (parent.type === "VariableDeclarator" && key === "init") {
+		const id = asAstNode(parent.id);
+		if (typeof id?.name === "string") state.inferredNames.set(child, id.name);
+	}
+	if (parent.type === "Property" && key === "value") {
+		const name = getNodeName(parent);
+		if (name) state.inferredNames.set(child, name);
+	}
+}
+function isClassNode(node) {
+	return node.type === "ClassDeclaration" || node.type === "ClassExpression";
+}
+function isExportDeclaration(node) {
+	return node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration";
+}
+function isExportedTarget(node, state) {
+	return state.exportedNodes.has(node);
+}
+function isFunctionNode(node) {
+	return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
+}
+function markExportedBinding(name, state) {
+	const bindingNode = state.bindingNodes.get(name);
+	if (bindingNode) state.exportedNodes.add(bindingNode);
+}
+function markExportedDeclaration(node, state) {
+	state.exportedNodes.add(node);
+	if (node.type !== "VariableDeclaration" || !Array.isArray(node.declarations)) return;
+	for (const declarator of node.declarations) {
+		if (!isAstNode(declarator)) continue;
+		const initializer = asAstNode(declarator.init);
+		if (initializer && (isClassNode(initializer) || isFunctionNode(initializer))) state.exportedNodes.add(initializer);
+	}
+}
+function visit(node, state) {
+	if (!node) return;
+	if (Array.isArray(node)) {
+		for (const child of node) visit(child, state);
+		return;
+	}
+	if (state.visited.has(node)) return;
+	state.visited.add(node);
+	if (node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration") {
+		if (node.declaration) {
+			markExportedDeclaration(node.declaration, state);
+			visit(node.declaration, state);
+		}
+		visitChildren(node, state, /* @__PURE__ */ new Set(["declaration"]));
+		return;
+	}
+	if (isClassNode(node)) addClassTarget(node, state);
+	else if (isFunctionNode(node) || node.type === "MethodDefinition") {
+		addFunctionTarget(node, state);
+		const methodValue = node.type === "MethodDefinition" ? asAstNode(node.value) : void 0;
+		if (methodValue) state.seenFunctions.add(methodValue);
+	}
+	visitChildren(node, state);
+}
+function visitChildren(node, state, skippedKeys = /* @__PURE__ */ new Set()) {
+	for (const [key, value] of Object.entries(node)) {
+		if (skippedKeys.has(key) || key === "type" || key === "start" || key === "end" || key === "range") continue;
+		if (Array.isArray(value)) {
+			for (const child of value) if (isAstNode(child)) {
+				inferChildName(node, key, child, state);
+				visit(child, state);
+			}
+		} else if (isAstNode(value)) {
+			inferChildName(node, key, value, state);
+			visit(value, state);
+		}
+	}
+}
+//#endregion
+export { createSourceFile as a, sliceRange as c, stableHash as d, SourceChangedError as i, withLanguage as l, targetIdentity as n, createSourceRuntime as o, withStableIdentities as r, sliceLines as s, extractJsSourceTargets as t, createStableHasher as u };