eslint-plugin-flawless 0.1.1 → 0.1.3

package/README.md

@@ -176,10 +176,13 @@ pnpm eslint-docs
 💭
 Requires [type information](https://typescript-eslint.io/linting/typed-linting).
 
-| Name                                                                                | Description                                                     | 🔧  | 💭  |
-| :---------------------------------------------------------------------------------- | :-------------------------------------------------------------- | :-- | :-- |
-| [naming-convention](src/rules/naming-convention/documentation.md)                   | Enforce naming conventions for everything across a codebase     |     | 💭  |
-| [yaml-block-key-blank-lines](src/rules/yaml-block-key-blank-lines/documentation.md) | Enforce blank lines around top-level YAML block collection keys | 🔧  |     |
+| Name                                                                                | Description                                                          | 🔧  | 💭  |
+| :---------------------------------------------------------------------------------- | :------------------------------------------------------------------- | :-- | :-- |
+| [jsx-shorthand-boolean](src/rules/jsx-shorthand-boolean/documentation.md)           | Disallow shorthand boolean JSX attributes                            | 🔧  |     |
+| [jsx-shorthand-fragment](src/rules/jsx-shorthand-fragment/documentation.md)         | Disallow the shorthand fragment syntax in favour of a named fragment | 🔧  |     |
+| [naming-convention](src/rules/naming-convention/documentation.md)                   | Enforce naming conventions for everything across a codebase          |     | 💭  |
+| [toml-sort-keys](src/rules/toml-sort-keys/documentation.md)                         | Enforce a configured sort order for TOML keys and tables             | 🔧  |     |
+| [yaml-block-key-blank-lines](src/rules/yaml-block-key-blank-lines/documentation.md) | Enforce blank lines around top-level YAML block collection keys      | 🔧  |     |
 
 <!-- end auto-generated rules list -->
 

package/dist/index.d.mts

@@ -8,6 +8,9 @@ interface PluginDocumentation {
   requiresTypeChecking: boolean;
 }
 //#endregion
+//#region src/rules/jsx-shorthand-fragment/rule.d.ts
+type Options$2 = [fragmentName?: string];
+//#endregion
 //#region src/rules/naming-convention/utils/enums.d.ts
 declare const Selector: {
   readonly variable: 1;
@@ -116,7 +119,20 @@ interface NamingSelector {
 //#endregion
 //#region src/rules/naming-convention/rule.d.ts
 type MessageIds = "doesNotMatchFormat" | "doesNotMatchFormatTrimmed" | "missingAffix" | "missingUnderscore" | "satisfyCustom" | "unexpectedUnderscore";
-type Options = Array<NamingSelector>;
+type Options$1 = Array<NamingSelector>;
+//#endregion
+//#region src/rules/toml-sort-keys/rule.d.ts
+type Options = Array<SortSpec>;
+interface SortOrderObject {
+  caseSensitive?: boolean;
+  natural?: boolean;
+  type?: "asc" | "desc";
+}
+type SortOrder = Array<string> | SortOrderObject;
+interface SortSpec {
+  order: SortOrder;
+  pathPattern: string;
+}
 //#endregion
 //#region src/plugin.d.ts
 declare const plugin: {
@@ -125,7 +141,16 @@ declare const plugin: {
     version: string;
   };
   rules: {
-    "naming-convention": TSESLint.RuleModule<MessageIds, Options, PluginDocumentation, TSESLint.RuleListener> & {
+    "jsx-shorthand-boolean": TSESLint.RuleModule<"setAttributeValue", [], PluginDocumentation, TSESLint.RuleListener> & {
+      name: string;
+    };
+    "jsx-shorthand-fragment": TSESLint.RuleModule<"useNamedFragment", Options$2, PluginDocumentation, TSESLint.RuleListener> & {
+      name: string;
+    };
+    "naming-convention": TSESLint.RuleModule<MessageIds, Options$1, PluginDocumentation, TSESLint.RuleListener> & {
+      name: string;
+    };
+    "toml-sort-keys": TSESLint.RuleModule<"unsorted", Options, PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
     "yaml-block-key-blank-lines": TSESLint.RuleModule<"blankLine", [], PluginDocumentation, TSESLint.RuleListener> & {
@@ -145,7 +170,16 @@ declare const _default: {
             version: string;
           };
           rules: {
-            "naming-convention": import("${configDir}").RuleModule<MessageIds, Options, PluginDocumentation, import("${configDir}").RuleListener> & {
+            "jsx-shorthand-boolean": import("${configDir}").RuleModule<"setAttributeValue", [], PluginDocumentation, import("${configDir}").RuleListener> & {
+              name: string;
+            };
+            "jsx-shorthand-fragment": import("${configDir}").RuleModule<"useNamedFragment", Options$2, PluginDocumentation, import("${configDir}").RuleListener> & {
+              name: string;
+            };
+            "naming-convention": import("${configDir}").RuleModule<MessageIds, Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
+              name: string;
+            };
+            "toml-sort-keys": import("${configDir}").RuleModule<"unsorted", Options, PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
             "yaml-block-key-blank-lines": import("${configDir}").RuleModule<"blankLine", [], PluginDocumentation, import("${configDir}").RuleListener> & {
@@ -162,7 +196,16 @@ declare const _default: {
     version: string;
   };
   rules: {
-    "naming-convention": import("${configDir}").RuleModule<MessageIds, Options, PluginDocumentation, import("${configDir}").RuleListener> & {
+    "jsx-shorthand-boolean": import("${configDir}").RuleModule<"setAttributeValue", [], PluginDocumentation, import("${configDir}").RuleListener> & {
+      name: string;
+    };
+    "jsx-shorthand-fragment": import("${configDir}").RuleModule<"useNamedFragment", Options$2, PluginDocumentation, import("${configDir}").RuleListener> & {
+      name: string;
+    };
+    "naming-convention": import("${configDir}").RuleModule<MessageIds, Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
+      name: string;
+    };
+    "toml-sort-keys": import("${configDir}").RuleModule<"unsorted", Options, PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
     "yaml-block-key-blank-lines": import("${configDir}").RuleModule<"blankLine", [], PluginDocumentation, import("${configDir}").RuleListener> & {

package/dist/index.mjs

@@ -1,11 +1,12 @@
+import { RuleCreator, getParserServices } from "@typescript-eslint/utils/eslint-utils";
 import { DefinitionType, ImplicitLibVariable, PatternVisitor, ScopeType, Visitor } from "@typescript-eslint/scope-manager";
 import { requiresQuoting } from "@typescript-eslint/type-utils";
 import { ASTUtils, AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
-import { RuleCreator, getParserServices } from "@typescript-eslint/utils/eslint-utils";
 import assert from "node:assert";
+import { getStaticTOMLValue } from "toml-eslint-parser";
 //#region package.json
 var name = "eslint-plugin-flawless";
-var version = "0.1.1";
+var version = "0.1.3";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
@@ -31,6 +32,82 @@ function createEslintRule(rule) {
 	return createRule(rule);
 }
 //#endregion
+//#region src/rules/jsx-shorthand-boolean/rule.ts
+const RULE_NAME$4 = "jsx-shorthand-boolean";
+const MESSAGE_ID$2 = "setAttributeValue";
+const messages$4 = { [MESSAGE_ID$2]: "Set an explicit value for boolean attribute '{{name}}'." };
+function create$4(context) {
+	const { sourceCode } = context;
+	return { JSXAttribute(node) {
+		if (node.value !== null) return;
+		context.report({
+			data: { name: sourceCode.getText(node.name) },
+			fix: (fixer) => fixer.insertTextAfter(node.name, "={true}"),
+			messageId: MESSAGE_ID$2,
+			node
+		});
+	} };
+}
+const jsxShorthandBoolean = createEslintRule({
+	name: RULE_NAME$4,
+	create: create$4,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Disallow shorthand boolean JSX attributes",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$4,
+		schema: [],
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/rules/jsx-shorthand-fragment/rule.ts
+const RULE_NAME$3 = "jsx-shorthand-fragment";
+const MESSAGE_ID$1 = "useNamedFragment";
+const DEFAULT_FRAGMENT_NAME = "Fragment";
+const messages$3 = { [MESSAGE_ID$1]: "Use the '{{name}}' component instead of fragment shorthand syntax." };
+const schema$1 = [{
+	description: "The identifier to use for the named fragment element.",
+	type: "string"
+}];
+function create$3(context) {
+	const name = context.options[0] ?? DEFAULT_FRAGMENT_NAME;
+	return { JSXFragment(node) {
+		const { closingFragment, openingFragment } = node;
+		context.report({
+			data: { name },
+			fix: (fixer) => {
+				return [fixer.replaceText(openingFragment, `<${name}>`), fixer.replaceText(closingFragment, `</${name}>`)];
+			},
+			messageId: MESSAGE_ID$1,
+			node
+		});
+	} };
+}
+const jsxShorthandFragment = createEslintRule({
+	name: RULE_NAME$3,
+	create: create$3,
+	defaultOptions: [DEFAULT_FRAGMENT_NAME],
+	meta: {
+		defaultOptions: [DEFAULT_FRAGMENT_NAME],
+		docs: {
+			description: "Disallow the shorthand fragment syntax in favour of a named fragment",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$3,
+		schema: schema$1,
+		type: "suggestion"
+	}
+});
+//#endregion
 //#region src/utils/is-type-import.ts
 /**
 * Determine whether a variable definition is a type import. E.g.:.
@@ -1190,8 +1267,8 @@ const SCHEMA = {
 };
 //#endregion
 //#region src/rules/naming-convention/rule.ts
-const RULE_NAME$1 = "naming-convention";
-const messages$1 = {
+const RULE_NAME$2 = "naming-convention";
+const messages$2 = {
 	doesNotMatchFormat: "{{type}} name `{{name}}` must match one of the following formats: {{formats}}",
 	doesNotMatchFormatTrimmed: "{{type}} name `{{name}}` trimmed as `{{processedName}}` must match one of the following formats: {{formats}}",
 	missingAffix: "{{type}} name `{{name}}` must have one of the following {{position}}es: {{affixes}}",
@@ -1221,7 +1298,7 @@ const camelCaseNamingConfig = [
 		selector: "typeLike"
 	}
 ];
-function create$1(contextWithoutDefaults) {
+function create$2(contextWithoutDefaults) {
 	const context = contextWithoutDefaults.options.length > 0 ? contextWithoutDefaults : Object.setPrototypeOf({ options: camelCaseNamingConfig }, contextWithoutDefaults);
 	const validators = parseOptions(context);
 	const compilerOptions = getParserServices(context, true).program?.getCompilerOptions() ?? {};
@@ -1541,8 +1618,8 @@ function create$1(contextWithoutDefaults) {
 	}));
 }
 const namingConvention = createEslintRule({
-	name: RULE_NAME$1,
-	create: create$1,
+	name: RULE_NAME$2,
+	create: create$2,
 	defaultOptions: camelCaseNamingConfig,
 	meta: {
 		docs: {
@@ -1552,7 +1629,7 @@ const namingConvention = createEslintRule({
 		},
 		fixable: void 0,
 		hasSuggestions: false,
-		messages: messages$1,
+		messages: messages$2,
 		schema: SCHEMA,
 		type: "suggestion"
 	}
@@ -1582,6 +1659,225 @@ function requiresQuoting$1(node, target) {
 	return requiresQuoting(node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier ? node.name : `${node.value}`, target);
 }
 //#endregion
+//#region src/rules/toml-sort-keys/rule.ts
+const RULE_NAME$1 = "toml-sort-keys";
+const MESSAGE_ID = "unsorted";
+const messages$1 = { [MESSAGE_ID]: "Expected {{target}} to follow the configured order." };
+const schema = {
+	items: {
+		additionalProperties: false,
+		properties: {
+			order: { oneOf: [{
+				items: { type: "string" },
+				type: "array"
+			}, {
+				additionalProperties: false,
+				properties: {
+					caseSensitive: { type: "boolean" },
+					natural: { type: "boolean" },
+					type: {
+						enum: ["asc", "desc"],
+						type: "string"
+					}
+				},
+				type: "object"
+			}] },
+			pathPattern: { type: "string" }
+		},
+		required: ["order", "pathPattern"],
+		type: "object"
+	},
+	type: "array"
+};
+function isTable(entry) {
+	return entry.type === "TOMLTable";
+}
+/**
+* The dotted name of an entry, e.g. `settings`, `settings.node`, `_.path`.
+*
+* @param entry - The table header or key-value entry.
+* @returns The dotted key path as a string.
+*/
+function nameOf(entry) {
+	return getStaticTOMLValue(entry.key).join(".");
+}
+/**
+* Builds a rank function from an explicit order list. An entry matches an order
+* item when it equals it or is a dotted child of it (`settings.node` matches
+* `settings`), which keeps sub-tables grouped under their parent's slot.
+*
+* @param order - The configured names in their desired order.
+* @returns A function giving a name's rank, or `Infinity` when unlisted.
+*/
+function makeRank(order) {
+	return (name) => {
+		for (const [index, item] of order.entries()) if (name === item || name.startsWith(`${item}.`)) return index;
+		return Number.POSITIVE_INFINITY;
+	};
+}
+function makeFallback(config) {
+	const { caseSensitive = true, natural = false, type = "asc" } = config;
+	const sensitivity = caseSensitive ? "variant" : "accent";
+	return (a, b) => {
+		const result = a.localeCompare(b, "en", {
+			numeric: natural,
+			sensitivity
+		});
+		return type === "desc" ? -result : result;
+	};
+}
+/**
+* Builds a comparator for one table body. Explicit-order entries sort first by
+* their listed position, then unlisted entries fall back to a natural/asc sort
+* (mirroring `yaml/sort-keys`). At the top level, bare key-values are always
+* kept before any `[table]` header, since TOML would otherwise re-scope them.
+*
+* @param order - The order configuration for this table's path.
+* @param isTopLevel - Whether the body is the top-level table.
+* @returns A comparator over two entries.
+*/
+function makeComparator(order, isTopLevel) {
+	const rank = Array.isArray(order) ? makeRank(order) : void 0;
+	const fallback = makeFallback(Array.isArray(order) ? {
+		natural: true,
+		type: "asc"
+	} : order);
+	return (a, b) => {
+		if (isTopLevel) {
+			const aRank = isTable(a) ? 1 : 0;
+			const bRank = isTable(b) ? 1 : 0;
+			if (aRank !== bRank) return aRank - bRank;
+		}
+		if (rank !== void 0) {
+			const aRank = rank(nameOf(a));
+			const bRank = rank(nameOf(b));
+			if (aRank !== bRank) {
+				if (aRank === Number.POSITIVE_INFINITY) return 1;
+				if (bRank === Number.POSITIVE_INFINITY) return -1;
+				return aRank - bRank;
+			}
+		}
+		return fallback(nameOf(a), nameOf(b));
+	};
+}
+function create$1(context) {
+	const { options, sourceCode } = context;
+	if (sourceCode.parserServices.isTOML !== true) return {};
+	const specs = options.map(({ order, pathPattern }) => {
+		return {
+			order,
+			pattern: new RegExp(pathPattern, "u")
+		};
+	});
+	if (specs.length === 0) return {};
+	function resolveOrder(path) {
+		for (const spec of specs) if (spec.pattern.test(path)) return spec.order;
+	}
+	/**
+	* A comment counts as attached to an entry when it sits on its own line
+	* directly above it (no blank line, no trailing code). Such comments travel
+	* with the entry when it moves.
+	*
+	* @param comment - The comment to classify.
+	* @returns Whether the comment stands alone on its line.
+	*/
+	function isOwnLineComment(comment) {
+		const before = sourceCode.getTokenBefore(comment, { includeComments: true });
+		return before === null || before.loc.end.line < comment.loc.start.line;
+	}
+	function leadingStart(entry) {
+		const comments = sourceCode.getCommentsBefore(entry);
+		let start = entry.range[0];
+		let boundaryLine = entry.loc.start.line;
+		for (let index = comments.length - 1; index >= 0; index -= 1) {
+			const comment = comments[index];
+			if (comment === void 0) break;
+			if (comment.loc.end.line !== boundaryLine - 1 || !isOwnLineComment(comment)) break;
+			start = comment.range[0];
+			boundaryLine = comment.loc.start.line;
+		}
+		return start;
+	}
+	function trailingEnd(entry) {
+		const [comment] = sourceCode.getCommentsAfter(entry);
+		if (comment?.loc.start.line === entry.loc.end.line) return comment.range[1];
+		return entry.range[1];
+	}
+	function buildFix(entries, target) {
+		const text = sourceCode.getText();
+		const blocks = entries.map((entry) => {
+			return {
+				end: trailingEnd(entry),
+				entry,
+				start: leadingStart(entry)
+			};
+		});
+		for (let index = 1; index < blocks.length; index += 1) {
+			const previous = blocks[index - 1];
+			const current = blocks[index];
+			if (previous === void 0 || current === void 0) return;
+			if (/\S/u.test(text.slice(previous.end, current.start))) return;
+		}
+		const first = blocks[0];
+		const last = blocks[blocks.length - 1];
+		if (first === void 0 || last === void 0) return;
+		const textByEntry = new Map(blocks.map((block) => [block.entry, text.slice(block.start, block.end)]));
+		const parts = [];
+		for (const [index, entry] of target.entries()) {
+			const previous = target[index - 1];
+			if (previous !== void 0) parts.push(isTable(entry) || isTable(previous) ? "\n\n" : "\n");
+			parts.push(textByEntry.get(entry) ?? "");
+		}
+		const sortedText = parts.join("");
+		return (fixer) => fixer.replaceTextRange([first.start, last.end], sortedText);
+	}
+	function verify(path, body, isTopLevel) {
+		if (body.length < 2) return;
+		const order = resolveOrder(path);
+		if (order === void 0) return;
+		const entries = [...body];
+		const target = [...entries].sort(makeComparator(order, isTopLevel));
+		let outOfPlace;
+		for (const [index, entry] of entries.entries()) if (entry !== target[index]) {
+			outOfPlace = entry;
+			break;
+		}
+		if (outOfPlace === void 0) return;
+		context.report({
+			data: { target: path === "" ? "top-level tables" : `keys in "${path}"` },
+			fix: buildFix(entries, target),
+			loc: outOfPlace.key.loc,
+			messageId: MESSAGE_ID
+		});
+	}
+	return {
+		TOMLTable(node) {
+			verify(getStaticTOMLValue(node.key).join("."), node.body, false);
+		},
+		TOMLTopLevelTable(node) {
+			verify("", node.body, true);
+		}
+	};
+}
+const tomlSortKeys = createEslintRule({
+	name: RULE_NAME$1,
+	create: create$1,
+	defaultOptions: [],
+	meta: {
+		defaultOptions: [],
+		docs: {
+			description: "Enforce a configured sort order for TOML keys and tables",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$1,
+		schema,
+		type: "layout"
+	}
+});
+//#endregion
 //#region src/rules/yaml-block-key-blank-lines/rule.ts
 const RULE_NAME = "yaml-block-key-blank-lines";
 const messages = { blankLine: "Expected {{count}} blank line(s) around this top-level key." };
@@ -1658,7 +1954,10 @@ const plugin = {
 		version
 	},
 	rules: {
+		"jsx-shorthand-boolean": jsxShorthandBoolean,
+		"jsx-shorthand-fragment": jsxShorthandFragment,
 		"naming-convention": namingConvention,
+		"toml-sort-keys": tomlSortKeys,
 		"yaml-block-key-blank-lines": yamlBlockKeyBlankLines
 	}
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-flawless",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Your ESLint plugin description",
   "keywords": [
     "eslint",
@@ -36,7 +36,8 @@
   "dependencies": {
     "@typescript-eslint/scope-manager": "8.62.1",
     "@typescript-eslint/type-utils": "8.62.1",
-    "@typescript-eslint/utils": "8.62.1"
+    "@typescript-eslint/utils": "8.62.1",
+    "toml-eslint-parser": "1.0.3"
   },
   "devDependencies": {
     "@antfu/ni": "30.2.0",
@@ -52,6 +53,7 @@
     "eslint-plugin-eslint-plugin": "7.4.1",
     "eslint-plugin-n": "18.2.1",
     "eslint-plugin-pnpm": "1.6.1",
+    "eslint-plugin-toml": "1.4.0",
     "eslint-plugin-yml": "3.5.0",
     "eslint-vitest-rule-tester": "3.1.0",
     "jiti": "2.7.0",