@so1ve/eslint-plugin 4.1.8 → 4.2.0

package/dist/rules/require-async-with-await.d.mts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/rules/require-async-with-await.d.ts
+type MessageIds = "requireAsyncWithAwait";
+type Options = [];
+declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
+//#endregion
+export { rule };

package/dist/rules/require-async-with-await.mjs

@@ -0,0 +1,51 @@
+import { createEslintRule } from "../utils/index.mjs";
+import { TSESTree } from "@typescript-eslint/types";
+
+//#region src/rules/require-async-with-await.ts
+const RULE_NAME = "require-async-with-await";
+const rule = createEslintRule({
+	name: RULE_NAME,
+	meta: {
+		type: "problem",
+		docs: { description: "Require using async keyword with await." },
+		fixable: "code",
+		schema: [],
+		messages: { requireAsyncWithAwait: "Expect using async keyword with await." }
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const functionNodeStack = [];
+		function setupNode(node) {
+			functionNodeStack.push(node);
+		}
+		function clearNode() {
+			functionNodeStack.pop();
+		}
+		return {
+			"FunctionExpression": setupNode,
+			"FunctionExpression:exit": clearNode,
+			"FunctionDeclaration": setupNode,
+			"FunctionDeclaration:exit": clearNode,
+			"ArrowFunctionExpression": setupNode,
+			"ArrowFunctionExpression:exit": clearNode,
+			AwaitExpression() {
+				const node = functionNodeStack[functionNodeStack.length - 1];
+				if (!node || node.async) return;
+				let fixRange;
+				if (node.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression) fixRange = node.range;
+				if (node.type === TSESTree.AST_NODE_TYPES.FunctionDeclaration || node.type === TSESTree.AST_NODE_TYPES.FunctionExpression) if (node.parent.type === TSESTree.AST_NODE_TYPES.Property || node.parent.type === TSESTree.AST_NODE_TYPES.MethodDefinition) {
+					if (node.parent.kind === "method" || node.parent.kind === "init") fixRange = node.parent.key.range;
+				} else fixRange = node.range;
+				if (fixRange) context.report({
+					node,
+					messageId: "requireAsyncWithAwait",
+					fix: (fixer) => fixer.insertTextBeforeRange(fixRange, "async ")
+				});
+			}
+		};
+	}
+});
+var require_async_with_await_default = rule;
+
+//#endregion
+export { require_async_with_await_default as default };

package/dist/rules/sort-exports.d.mts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/rules/sort-exports.d.ts
+type MessageIds = "sort";
+type Options = [];
+declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
+//#endregion
+export { rule };

package/dist/rules/sort-exports.mjs

@@ -0,0 +1,68 @@
+import { createEslintRule } from "../utils/index.mjs";
+import { extractChunks, getImportExportItems, maybeReportSorting, printSortedItems, printWithSortedSpecifiers, sortImportExportItems } from "../utils/sort-imports.mjs";
+
+//#region src/rules/sort-exports.ts
+const RULE_NAME = "sort-exports";
+function isParentWithBody(node) {
+	if (!node) return false;
+	if (!("body" in node)) return false;
+	const maybe = node;
+	return Array.isArray(maybe.body);
+}
+const isExportFrom = (node) => node.type === "ExportNamedDeclaration" && node.source != null || node.type === "ExportAllDeclaration" && node.source != null;
+function isPartOfChunk(node, lastNode, sourceCode) {
+	if (!isExportFrom(node)) return "NotPartOfChunk";
+	return sourceCode.getCommentsBefore(node).some((comment) => (lastNode == null || comment.loc.start.line > lastNode.loc.end.line) && comment.loc.end.line < node.loc.start.line) ? "PartOfNewChunk" : "PartOfChunk";
+}
+const getSpecifiers = (exportNode) => exportNode.type === "ExportNamedDeclaration" ? exportNode.specifiers : [];
+function maybeReportChunkSorting(chunk, context) {
+	const sourceCode = context.sourceCode;
+	const items = getImportExportItems(chunk.filter(isExportFrom), sourceCode, () => false, getSpecifiers);
+	const sorted = printSortedItems([[sortImportExportItems(items)]], items, sourceCode);
+	const start = items[0].start;
+	const end = items[items.length - 1].end;
+	maybeReportSorting(context, sorted, start, end);
+}
+function maybeReportExportSpecifierSorting(node, context) {
+	const sorted = printWithSortedSpecifiers(node, context.sourceCode, (n) => n.specifiers);
+	const [start, end] = node.range;
+	maybeReportSorting(context, sorted, start, end);
+}
+const rule = createEslintRule({
+	name: RULE_NAME,
+	meta: {
+		type: "layout",
+		docs: {
+			description: "Sort export declarations.",
+			url: "https://github.com/lydell/eslint-plugin-simple-import-sort#sort-order"
+		},
+		fixable: "code",
+		schema: [],
+		messages: { sort: "Run autofix to sort these exports!" }
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const parents = /* @__PURE__ */ new Set();
+		function addParent(node) {
+			if (isExportFrom(node) && isParentWithBody(node.parent)) parents.add(node.parent);
+		}
+		return {
+			ExportNamedDeclaration(node) {
+				if (node.source == null && node.declaration == null) maybeReportExportSpecifierSorting(node, context);
+				else addParent(node);
+			},
+			ExportAllDeclaration(node) {
+				addParent(node);
+			},
+			"Program:exit"() {
+				const sourceCode = context.sourceCode;
+				for (const parent of parents) for (const chunk of extractChunks(parent, (node, lastNode) => isPartOfChunk(node, lastNode, sourceCode))) maybeReportChunkSorting(chunk, context);
+				parents.clear();
+			}
+		};
+	}
+});
+var sort_exports_default = rule;
+
+//#endregion
+export { sort_exports_default as default };

package/dist/rules/sort-imports.d.mts

@@ -0,0 +1,10 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/rules/sort-imports.d.ts
+type MessageIds = "sort";
+type Options = [{
+  groups?: string[][];
+}];
+declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
+//#endregion
+export { rule };

package/dist/rules/sort-imports.mjs

@@ -0,0 +1,104 @@
+import { createEslintRule } from "../utils/index.mjs";
+import { extractChunks, getImportExportItems, isPunctuator, maybeReportSorting, printSortedItems, sortImportExportItems } from "../utils/sort-imports.mjs";
+
+//#region src/rules/sort-imports.ts
+const RULE_NAME = "sort-imports";
+function isParentWithBody(node) {
+	if (!node) return false;
+	if (!("body" in node)) return false;
+	const maybe = node;
+	return Array.isArray(maybe.body);
+}
+const defaultGroups = [
+	["^node:"],
+	["^@?\\w"],
+	["^"],
+	["^\\."],
+	["^\\u0000"]
+];
+const isImportSpecifier = (node) => node.type === "ImportSpecifier";
+const getSpecifiers = (importNode) => importNode.specifiers.filter(isImportSpecifier);
+const isImport = (node) => node.type === "ImportDeclaration";
+function isSideEffectImport(importNode, sourceCode) {
+	const token = sourceCode.getFirstToken(importNode, { skip: 1 });
+	const startsWithBrace = token != null && isPunctuator(token, "{");
+	return importNode.specifiers.length === 0 && (!importNode.importKind || importNode.importKind === "value") && !startsWithBrace;
+}
+const rule = createEslintRule({
+	name: RULE_NAME,
+	meta: {
+		type: "layout",
+		docs: {
+			description: "Sort import declarations.",
+			url: "https://github.com/lydell/eslint-plugin-simple-import-sort#sort-order"
+		},
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: { groups: {
+				type: "array",
+				items: {
+					type: "array",
+					items: { type: "string" }
+				}
+			} },
+			additionalProperties: false
+		}],
+		messages: { sort: "Run autofix to sort these imports!" }
+	},
+	defaultOptions: [{ groups: defaultGroups }],
+	create: (context) => {
+		const outerGroups = (context.options[0]?.groups ?? defaultGroups).map((groups) => groups.map((item) => new RegExp(item, "u")));
+		const parents = /* @__PURE__ */ new Set();
+		return {
+			ImportDeclaration(node) {
+				if (isParentWithBody(node.parent)) parents.add(node.parent);
+			},
+			"Program:exit"() {
+				const sourceCode = context.sourceCode;
+				for (const parent of parents) for (const chunk of extractChunks(parent, (node, lastNode) => {
+					if (!isImport(node)) return "NotPartOfChunk";
+					return lastNode != null && isImport(lastNode) && lastNode.loc.end.line === node.loc.start.line ? "PartOfNewChunk" : "PartOfChunk";
+				})) maybeReportChunkSorting(chunk, context, outerGroups, sourceCode);
+				parents.clear();
+			}
+		};
+	}
+});
+var sort_imports_default = rule;
+function maybeReportChunkSorting(chunk, context, outerGroups, sourceCode) {
+	const items = getImportExportItems(chunk.filter(isImport), sourceCode, isSideEffectImport, getSpecifiers);
+	const sorted = printSortedItems(makeSortedItems(items, outerGroups), items, sourceCode);
+	const start = items[0].start;
+	const end = items[items.length - 1].end;
+	maybeReportSorting(context, sorted, start, end);
+}
+function makeSortedItems(items, outerGroups) {
+	const itemGroups = outerGroups.map((groups) => groups.map((regex) => ({
+		regex,
+		items: []
+	})));
+	const rest = [];
+	for (const item of items) {
+		const { originalSource } = item.source;
+		const source = item.isSideEffectImport ? `\0${originalSource}` : item.source.kind === "value" ? originalSource : `${originalSource}\0`;
+		let matchedGroup;
+		let longestMatchLength = -1;
+		for (const groups of itemGroups) for (const group of groups) {
+			const match = group.regex.exec(source);
+			if (match != null && match[0].length > longestMatchLength) {
+				matchedGroup = group;
+				longestMatchLength = match[0].length;
+			}
+		}
+		if (matchedGroup == null) rest.push(item);
+		else matchedGroup.items.push(item);
+	}
+	return [...itemGroups, [{
+		regex: /^/,
+		items: rest
+	}]].map((groups) => groups.filter((group) => group.items.length > 0)).filter((groups) => groups.length > 0).map((groups) => groups.map((group) => sortImportExportItems(group.items)));
+}
+
+//#endregion
+export { sort_imports_default as default };

package/dist/rules/vue-root-element-sort-attributes.d.mts

@@ -0,0 +1,11 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/rules/vue-root-element-sort-attributes.d.ts
+type MessageIds = "wrongOrder";
+type Options = [{
+  script?: string[];
+  [otherElement: string]: string[] | undefined;
+}];
+declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
+//#endregion
+export { rule };

package/dist/rules/vue-root-element-sort-attributes.mjs

@@ -0,0 +1,66 @@
+import { createEslintRule } from "../utils/index.mjs";
+
+//#region src/rules/vue-root-element-sort-attributes.ts
+const RULE_NAME = "vue-root-element-sort-attributes";
+const defaultOptions = { script: ["setup", "lang"] };
+const rule = createEslintRule({
+	name: RULE_NAME,
+	meta: {
+		type: "layout",
+		docs: { description: "Sort attributes of root <script>, <template>, and <style> elements in Vue files." },
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: { script: {
+				type: "array",
+				items: { type: "string" }
+			} },
+			additionalProperties: true
+		}],
+		messages: { wrongOrder: "Attributes of root element should be sorted in a specific order." }
+	},
+	defaultOptions: [defaultOptions],
+	create(context, [options]) {
+		const order = {
+			...options,
+			script: options.script ?? defaultOptions.script
+		};
+		const sourceCode = context.sourceCode;
+		const documentFragment = sourceCode.parserServices.getDocumentFragment?.();
+		function getTopLevelHTMLElements() {
+			if (documentFragment) return documentFragment.children.filter((n) => n.type === "VElement");
+			return [];
+		}
+		return { Program: (_node) => {
+			const topLevelElements = getTopLevelHTMLElements();
+			for (const element of topLevelElements) {
+				if (!(element.name in order)) continue;
+				const expectedOrder = order[element.name];
+				const attributesToCheck = [];
+				let reprintAttributes = false;
+				for (const attribute of element.startTag.attributes) {
+					if (attribute.key.type !== "VIdentifier" || attribute.directive) continue;
+					if (expectedOrder.includes(attribute.key.name)) attributesToCheck.push(attribute);
+				}
+				const currentOrder = attributesToCheck.map((attr) => attr.key.name);
+				const expectedFilteredOrder = expectedOrder.filter((name) => currentOrder.includes(name));
+				if (JSON.stringify(currentOrder) !== JSON.stringify(expectedFilteredOrder)) reprintAttributes = true;
+				if (reprintAttributes) context.report({
+					node: element.startTag,
+					messageId: "wrongOrder",
+					*fix(fixer) {
+						const sortedAttributes = [...attributesToCheck].sort((a, b) => expectedOrder.indexOf(a.key.name) - expectedOrder.indexOf(b.key.name));
+						for (const [i, originalAttr] of attributesToCheck.entries()) {
+							const sortedAttr = sortedAttributes[i];
+							if (originalAttr.key.name !== sortedAttr.key.name) yield fixer.replaceText(originalAttr, sourceCode.getText(sortedAttr));
+						}
+					}
+				});
+			}
+		} };
+	}
+});
+var vue_root_element_sort_attributes_default = rule;
+
+//#endregion
+export { vue_root_element_sort_attributes_default as default };

package/dist/utils/index.mjs

@@ -0,0 +1,19 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/utils/index.ts
+const createEslintRule = ESLintUtils.RuleCreator((ruleName) => ruleName);
+function getSiblingNode(node, offset) {
+	if (!node) return;
+	const { parent } = node;
+	if (parent && "body" in parent) {
+		const { body } = parent;
+		if (!Array.isArray(body)) return;
+		const targetIndex = body.indexOf(node) + offset;
+		if (targetIndex >= 0 && targetIndex < body.length) return body[targetIndex];
+	}
+}
+const getPreviousNode = (node) => getSiblingNode(node, -1);
+const getNextNode = (node) => getSiblingNode(node, 1);
+
+//#endregion
+export { createEslintRule, getNextNode, getPreviousNode };