@so1ve/eslint-plugin 4.1.8 → 4.2.0

package/dist/utils/sort-imports.mjs

@@ -0,0 +1,417 @@
+import natsort from "natsort";
+
+//#region src/utils/sort-imports.ts
+const NEWLINE = /(\r?\n)/;
+const hasNewline = (text) => NEWLINE.test(text);
+function guessNewline(sourceCode) {
+	const match = NEWLINE.exec(sourceCode.text);
+	return match == null ? "\n" : match[0];
+}
+const withCode = (token, sourceCode) => ({
+	...token,
+	code: sourceCode.getText(token)
+});
+function parseWhitespace(whitespace) {
+	const allItems = whitespace.split(NEWLINE);
+	return (allItems.length >= 5 ? [...allItems.slice(0, 2), ...allItems.slice(-1)] : allItems).map((spacesOrNewline, index) => index % 2 === 0 ? {
+		type: "Spaces",
+		code: spacesOrNewline
+	} : {
+		type: "Newline",
+		code: spacesOrNewline
+	}).filter((token) => token.code !== "");
+}
+const naturalSort = ("default" in natsort ? natsort.default : natsort)();
+function compare(path1, path2) {
+	const path1Depth = path1.split("-").filter((p) => p === "__").length;
+	const path2Depth = path2.split("-").filter((p) => p === "__").length;
+	const path1IsDot = path1 === "_-,";
+	const path2IsDot = path2 === "_-,";
+	if (path1IsDot && !path2IsDot) return 1;
+	if (path2IsDot && !path1IsDot) return -1;
+	return path1Depth === path2Depth ? naturalSort(path1, path2) : path2Depth - path1Depth;
+}
+const isIdentifier = (node) => node.type === "Identifier";
+const isKeyword = (node) => node.type === "Keyword";
+const isPunctuator = (node, value) => node.type === "Punctuator" && typeof node.value === "string" && node.value === value;
+const isBlockComment = (node) => node.type === "Block";
+const isLineComment = (node) => node.type === "Line";
+const isSpaces = (node) => node.type === "Spaces";
+const isNewline = (node) => node.type === "Newline";
+const getImportExportKind = (node) => node.importKind ?? node.exportKind ?? "value";
+function getSource(node) {
+	const source = String(node.source.value);
+	return {
+		source: source.replace(/^[./]*\.$/, "$&/").replace(/^[./]*\/$/, "$&,").replace(/[./_-]/g, (char) => {
+			switch (char) {
+				case ".": return "_";
+				case "/": return "-";
+				case "_": return ".";
+				case "-": return "/";
+				default: throw new Error(`Unknown source substitution character: ${char}`);
+			}
+		}),
+		originalSource: source,
+		kind: getImportExportKind(node)
+	};
+}
+function findLastIndex(array, fn) {
+	for (let index = array.length - 1; index >= 0; index--) if (fn(array[index], index, array)) return index;
+	return -1;
+}
+const flatMap = (array, fn) => array.flatMap((item, index) => fn(item, index));
+function getAllTokens(node, sourceCode) {
+	const tokens = sourceCode.getTokens(node);
+	const lastTokenIndex = tokens.length - 1;
+	return flatMap(tokens, (token, tokenIndex) => {
+		const newToken = withCode(token, sourceCode);
+		if (tokenIndex === lastTokenIndex) return [newToken];
+		const comments = sourceCode.getCommentsAfter(token);
+		const last = comments.length > 0 ? comments[comments.length - 1] : token;
+		const nextToken = tokens[tokenIndex + 1];
+		return [
+			newToken,
+			...flatMap(comments, (comment, commentIndex) => {
+				const previous = commentIndex === 0 ? token : comments[commentIndex - 1];
+				return [...parseWhitespace(sourceCode.text.slice(previous.range[1], comment.range[0])), withCode(comment, sourceCode)];
+			}),
+			...parseWhitespace(sourceCode.text.slice(last.range[1], nextToken.range[0]))
+		];
+	});
+}
+const printTokens = (tokens) => tokens.map((token) => token.code).join("");
+const removeBlankLines = (whitespace) => printTokens(parseWhitespace(whitespace));
+function printCommentsBefore(node, comments, sourceCode) {
+	const lastIndex = comments.length - 1;
+	return comments.map((comment, index) => {
+		const next = index === lastIndex ? node : comments[index + 1];
+		return sourceCode.getText(comment) + removeBlankLines(sourceCode.text.slice(comment.range[1], next.range[0]));
+	}).join("");
+}
+const printCommentsAfter = (node, comments, sourceCode) => comments.map((comment, index) => {
+	const previous = index === 0 ? node : comments[index - 1];
+	return removeBlankLines(sourceCode.text.slice(previous.range[1], comment.range[0])) + sourceCode.getText(comment);
+}).join("");
+function getIndentationAt(index, sourceCode) {
+	const lines = sourceCode.text.slice(0, index).split(NEWLINE);
+	const linePrefix = lines[lines.length - 1];
+	return /^\s*$/u.test(linePrefix) ? linePrefix : "";
+}
+function getTrailingSpacesAt(index, sourceCode) {
+	const { text } = sourceCode;
+	let end = index;
+	while (end < text.length) {
+		const char = text[end];
+		if (char === " " || char === "	") {
+			end++;
+			continue;
+		}
+		break;
+	}
+	return text.slice(index, end);
+}
+const sortImportExportItems = (items) => [...items].sort((itemA, itemB) => itemA.isSideEffectImport && itemB.isSideEffectImport ? itemA.index - itemB.index : itemA.isSideEffectImport ? -1 : itemB.isSideEffectImport ? 1 : compare(itemA.source.source, itemB.source.source) || compare(itemA.source.originalSource, itemB.source.originalSource) || compare(itemA.source.kind, itemB.source.kind) || itemA.index - itemB.index);
+const getSpecifierName = (node) => node.type === "Identifier" ? node.name : node.value;
+const getExternalName = (node) => getSpecifierName("imported" in node ? node.imported : node.exported);
+const getLocalName = (node) => getSpecifierName(node.local);
+function compareImportExportKind(kindA, kindB) {
+	if (kindA === kindB) return 0;
+	return kindA === "type" ? -1 : 1;
+}
+const sortSpecifierItems = (items) => [...items].sort((itemA, itemB) => compareImportExportKind(getImportExportKind(itemA.node), getImportExportKind(itemB.node)) || compare(getExternalName(itemA.node), getExternalName(itemB.node)) || compare(getLocalName(itemA.node), getLocalName(itemB.node)) || itemA.index - itemB.index);
+function extractChunks(parentNode, isPartOfChunk) {
+	const chunks = [];
+	let chunk = [];
+	let lastNode;
+	for (const node of parentNode.body) {
+		const result = isPartOfChunk(node, lastNode);
+		switch (result) {
+			case "PartOfChunk":
+				chunk.push(node);
+				break;
+			case "PartOfNewChunk":
+				if (chunk.length > 0) chunks.push(chunk);
+				chunk = [node];
+				break;
+			case "NotPartOfChunk":
+				if (chunk.length > 0) {
+					chunks.push(chunk);
+					chunk = [];
+				}
+				break;
+			default: {
+				const _never = result;
+				throw new Error(`Unknown chunk result: ${String(_never)}`);
+			}
+		}
+		lastNode = node;
+	}
+	if (chunk.length > 0) chunks.push(chunk);
+	return chunks;
+}
+function maybeReportSorting(context, sorted, start, end) {
+	const sourceCode = context.sourceCode;
+	if (sourceCode.getText().slice(start, end) !== sorted) context.report({
+		messageId: "sort",
+		loc: {
+			start: sourceCode.getLocFromIndex(start),
+			end: sourceCode.getLocFromIndex(end)
+		},
+		fix: (fixer) => fixer.replaceTextRange([start, end], sorted)
+	});
+}
+function printSortedItems(sortedItems, originalItems, sourceCode) {
+	const newline = guessNewline(sourceCode);
+	const sorted = sortedItems.map((groups) => groups.map((groupItems) => groupItems.map((item) => item.code).join(newline)).join(newline)).join(newline + newline);
+	const flattened = flatMap(sortedItems, (groups) => flatMap(groups, (g) => g));
+	const lastSortedItem = flattened[flattened.length - 1];
+	const lastOriginalItem = originalItems[originalItems.length - 1];
+	const nextToken = lastSortedItem.needsNewline ? sourceCode.getTokenAfter(lastOriginalItem.node, {
+		includeComments: true,
+		filter: (token) => token.type !== "Line" && (token.type !== "Block" || token.loc.end.line !== lastOriginalItem.node.loc.end.line)
+	}) : void 0;
+	return sorted + (nextToken != null && nextToken.loc.start.line === lastOriginalItem.node.loc.end.line ? newline : "");
+}
+const makeEmptyItem = () => ({
+	state: "before",
+	before: [],
+	after: [],
+	specifier: [],
+	hadComma: false
+});
+function getSpecifierItems(tokens) {
+	const result = {
+		before: [],
+		after: [],
+		items: []
+	};
+	let current = makeEmptyItem();
+	for (const token of tokens) switch (current.state) {
+		case "before":
+			switch (token.type) {
+				case "Newline":
+					current.before.push(token);
+					if (result.before.length === 0 && result.items.length === 0) {
+						result.before = current.before;
+						current = makeEmptyItem();
+					}
+					break;
+				case "Spaces":
+				case "Block":
+				case "Line":
+					current.before.push(token);
+					break;
+				default:
+					if (result.before.length === 0 && result.items.length === 0) {
+						result.before = current.before;
+						current = makeEmptyItem();
+					}
+					current.state = "specifier";
+					current.specifier.push(token);
+			}
+			break;
+		case "specifier":
+			switch (token.type) {
+				case "Punctuator":
+					if (isPunctuator(token, ",")) {
+						current.hadComma = true;
+						current.state = "after";
+					} else current.specifier.push(token);
+					break;
+				default: current.specifier.push(token);
+			}
+			break;
+		case "after":
+			switch (token.type) {
+				case "Newline":
+					current.after.push(token);
+					result.items.push(current);
+					current = makeEmptyItem();
+					break;
+				case "Spaces":
+				case "Line":
+					current.after.push(token);
+					break;
+				case "Block":
+					if (hasNewline(token.code)) {
+						result.items.push(current);
+						current = makeEmptyItem();
+						current.before.push(token);
+					} else current.after.push(token);
+					break;
+				default:
+					result.items.push(current);
+					current = makeEmptyItem();
+					current.state = "specifier";
+					current.specifier.push(token);
+			}
+			break;
+		default: {
+			const _never = current.state;
+			throw new Error(`Unknown state: ${String(_never)}`);
+		}
+	}
+	switch (current.state) {
+		case "before":
+			result.after = current.before;
+			break;
+		case "specifier": {
+			const lastIdentifierIndex = findLastIndex(current.specifier, (t) => isIdentifier(t) || isKeyword(t));
+			const specifier = current.specifier.slice(0, lastIdentifierIndex + 1);
+			const after = current.specifier.slice(lastIdentifierIndex + 1);
+			const newlineIndexRaw = after.findIndex((t) => isNewline(t));
+			const newlineIndex = newlineIndexRaw === -1 ? -1 : newlineIndexRaw + 1;
+			const multilineBlockCommentIndex = after.findIndex((t) => isBlockComment(t) && hasNewline(t.code));
+			const sliceIndex = newlineIndex >= 0 && multilineBlockCommentIndex !== -1 ? Math.min(newlineIndex, multilineBlockCommentIndex) : newlineIndex >= 0 ? newlineIndex : multilineBlockCommentIndex === -1 ? endsWithSpaces(after) ? after.length - 1 : -1 : multilineBlockCommentIndex;
+			current.specifier = specifier;
+			current.after = sliceIndex === -1 ? after : after.slice(0, sliceIndex);
+			result.items.push(current);
+			result.after = sliceIndex === -1 ? [] : after.slice(sliceIndex);
+			break;
+		}
+		case "after":
+			if (endsWithSpaces(current.after)) {
+				const last = current.after.pop();
+				if (last) result.after = [last];
+			}
+			result.items.push(current);
+			break;
+		default: {
+			const _never = current.state;
+			throw new Error(`Unknown state: ${String(_never)}`);
+		}
+	}
+	return {
+		before: result.before,
+		after: result.after,
+		items: result.items.map((item) => ({
+			before: item.before,
+			after: item.after,
+			specifier: item.specifier,
+			hadComma: item.hadComma
+		}))
+	};
+}
+function needsStartingNewline(tokens) {
+	const before = tokens.filter((token) => !isSpaces(token));
+	if (before.length === 0) return false;
+	const firstToken = before[0];
+	return isLineComment(firstToken) || isBlockComment(firstToken) && !hasNewline(firstToken.code);
+}
+function endsWithSpaces(tokens) {
+	const last = tokens.length > 0 ? tokens[tokens.length - 1] : void 0;
+	return last == null ? false : isSpaces(last);
+}
+function printWithSortedSpecifiers(node, sourceCode, getSpecifiers) {
+	const allTokens = getAllTokens(node, sourceCode);
+	const openBraceIndex = allTokens.findIndex((token) => isPunctuator(token, "{"));
+	const closeBraceIndex = allTokens.findIndex((token) => isPunctuator(token, "}"));
+	const specifiers = getSpecifiers(node);
+	if (openBraceIndex === -1 || closeBraceIndex === -1 || specifiers.length <= 1) return printTokens(allTokens);
+	const itemsResult = getSpecifierItems(allTokens.slice(openBraceIndex + 1, closeBraceIndex));
+	const sortedItems = sortSpecifierItems(itemsResult.items.map((originalItem, index) => ({
+		...originalItem,
+		node: specifiers[index],
+		index
+	})));
+	const newline = guessNewline(sourceCode);
+	const hasTrailingComma = (() => {
+		for (let index = closeBraceIndex - 1; index > openBraceIndex; index--) {
+			const token = allTokens[index];
+			if (token.type === "Spaces" || token.type === "Newline" || token.type === "Block" || token.type === "Line") continue;
+			return isPunctuator(token, ",");
+		}
+		return false;
+	})();
+	const lastIndex = sortedItems.length - 1;
+	const sorted = flatMap(sortedItems, (item, index) => {
+		const previous = index === 0 ? void 0 : sortedItems[index - 1];
+		const maybeNewline$1 = previous != null && needsStartingNewline(item.before) && (previous.after.length <= 0 || !isNewline(previous.after[previous.after.length - 1])) ? [{
+			type: "Newline",
+			code: newline
+		}] : [];
+		if (index < lastIndex || hasTrailingComma) return [
+			...maybeNewline$1,
+			...item.before,
+			...item.specifier,
+			{
+				type: "Comma",
+				code: ","
+			},
+			...item.after
+		];
+		const nonBlankIndex = item.after.findIndex((token) => !isNewline(token) && !isSpaces(token));
+		const after = item.hadComma ? nonBlankIndex === -1 ? [] : item.after.slice(nonBlankIndex) : item.after;
+		return [
+			...maybeNewline$1,
+			...item.before,
+			...item.specifier,
+			...after
+		];
+	});
+	const maybeNewline = needsStartingNewline(itemsResult.after) && !isNewline(sorted[sorted.length - 1]) ? [{
+		type: "Newline",
+		code: newline
+	}] : [];
+	return printTokens([
+		...allTokens.slice(0, openBraceIndex + 1),
+		...itemsResult.before,
+		...sorted,
+		...maybeNewline,
+		...itemsResult.after,
+		...allTokens.slice(closeBraceIndex)
+	]);
+}
+function handleLastSemicolon(chunk, sourceCode) {
+	const lastIndex = chunk.length - 1;
+	const lastNode = chunk[lastIndex];
+	const tokens = sourceCode.getLastTokens(lastNode, { count: 2 });
+	if (tokens.length < 2) return [...chunk];
+	const [nextToLastToken, lastToken] = tokens;
+	if (!(lastToken.type === "Punctuator" && lastToken.value === ";")) return [...chunk];
+	if (nextToLastToken.loc.end.line === lastToken.loc.start.line || sourceCode.getTokenAfter(lastToken) == null) return [...chunk];
+	const newLastNode = {
+		...lastNode,
+		range: [lastNode.range[0], nextToLastToken.range[1]],
+		loc: {
+			start: lastNode.loc.start,
+			end: nextToLastToken.loc.end
+		}
+	};
+	return [...chunk.slice(0, lastIndex), newLastNode];
+}
+function getImportExportItems(passedChunk, sourceCode, isSideEffectImport, getSpecifiers) {
+	const chunk = handleLastSemicolon(passedChunk, sourceCode);
+	return chunk.map((node, nodeIndex) => {
+		const lastLine = nodeIndex === 0 ? node.loc.start.line - 1 : chunk[nodeIndex - 1].loc.end.line;
+		const commentsBefore = sourceCode.getCommentsBefore(node).filter((comment) => comment.loc.start.line <= node.loc.start.line && comment.loc.end.line > lastLine && (nodeIndex > 0 || comment.loc.start.line > lastLine));
+		const commentsAfter = sourceCode.getCommentsAfter(node).filter((comment) => comment.loc.end.line === node.loc.end.line);
+		const before = printCommentsBefore(node, commentsBefore, sourceCode);
+		const after = printCommentsAfter(node, commentsAfter, sourceCode);
+		const indentation = getIndentationAt((commentsBefore.length > 0 ? commentsBefore[0] : node).range[0], sourceCode);
+		const trailingSpaces = getTrailingSpacesAt((commentsAfter.length > 0 ? commentsAfter[commentsAfter.length - 1] : node).range[1], sourceCode);
+		const code = indentation + before + printWithSortedSpecifiers(node, sourceCode, getSpecifiers) + after + trailingSpaces;
+		const all = [
+			...commentsBefore,
+			node,
+			...commentsAfter
+		];
+		const [start] = all[0].range;
+		const [, end] = all[all.length - 1].range;
+		const source = getSource(node);
+		const lastAfter = commentsAfter.length > 0 ? commentsAfter[commentsAfter.length - 1] : void 0;
+		return {
+			node,
+			code,
+			start: start - indentation.length,
+			end: end + trailingSpaces.length,
+			isSideEffectImport: isSideEffectImport(node, sourceCode),
+			source,
+			index: nodeIndex,
+			needsNewline: lastAfter?.type === "Line"
+		};
+	});
+}
+
+//#endregion
+export { extractChunks, getImportExportItems, isPunctuator, maybeReportSorting, printSortedItems, printWithSortedSpecifiers, sortImportExportItems };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@so1ve/eslint-plugin",
-  "version": "4.1.8",
+  "version": "4.2.0",
   "author": "Ray <i@mk1.io> (https://github.com/so1ve/)",
   "type": "module",
   "keywords": [