eslint-plugin-flawless 0.1.2 → 0.1.4

package/README.md

@@ -176,11 +176,15 @@ 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     |     | 💭  |
-| [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 | 🔧  |     |
+| 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          |     | 💭  |
+| [no-unnecessary-use-callback](src/rules/no-unnecessary-use-callback/documentation.md) | Disallow unnecessary usage of 'useCallback'                          |     |     |
+| [no-unnecessary-use-memo](src/rules/no-unnecessary-use-memo/documentation.md)         | Disallow unnecessary usage of 'useMemo'                              |     |     |
+| [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;
@@ -115,9 +118,19 @@ interface NamingSelector {
 }
 //#endregion
 //#region src/rules/naming-convention/rule.d.ts
-type MessageIds = "doesNotMatchFormat" | "doesNotMatchFormatTrimmed" | "missingAffix" | "missingUnderscore" | "satisfyCustom" | "unexpectedUnderscore";
+type MessageIds$2 = "doesNotMatchFormat" | "doesNotMatchFormatTrimmed" | "missingAffix" | "missingUnderscore" | "satisfyCustom" | "unexpectedUnderscore";
 type Options$1 = Array<NamingSelector>;
 //#endregion
+//#region src/rules/no-unnecessary-use-callback/rule.d.ts
+declare const MESSAGE_ID_DEFAULT$1 = "default";
+declare const MESSAGE_ID_INSIDE_USE_EFFECT$1 = "noUnnecessaryUseCallbackInsideUseEffect";
+type MessageIds$1 = typeof MESSAGE_ID_DEFAULT$1 | typeof MESSAGE_ID_INSIDE_USE_EFFECT$1;
+//#endregion
+//#region src/rules/no-unnecessary-use-memo/rule.d.ts
+declare const MESSAGE_ID_DEFAULT = "default";
+declare const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
+type MessageIds = typeof MESSAGE_ID_DEFAULT | typeof MESSAGE_ID_INSIDE_USE_EFFECT;
+//#endregion
 //#region src/rules/toml-sort-keys/rule.d.ts
 type Options = Array<SortSpec>;
 interface SortOrderObject {
@@ -138,7 +151,19 @@ declare const plugin: {
     version: string;
   };
   rules: {
-    "naming-convention": TSESLint.RuleModule<MessageIds, Options$1, 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$2, Options$1, PluginDocumentation, TSESLint.RuleListener> & {
+      name: string;
+    };
+    "no-unnecessary-use-callback": TSESLint.RuleModule<MessageIds$1, [], PluginDocumentation, TSESLint.RuleListener> & {
+      name: string;
+    };
+    "no-unnecessary-use-memo": TSESLint.RuleModule<MessageIds, [], PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
     "toml-sort-keys": TSESLint.RuleModule<"unsorted", Options, PluginDocumentation, TSESLint.RuleListener> & {
@@ -161,7 +186,19 @@ declare const _default: {
             version: string;
           };
           rules: {
-            "naming-convention": import("${configDir}").RuleModule<MessageIds, Options$1, 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$2, Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
+              name: string;
+            };
+            "no-unnecessary-use-callback": import("${configDir}").RuleModule<MessageIds$1, [], PluginDocumentation, import("${configDir}").RuleListener> & {
+              name: string;
+            };
+            "no-unnecessary-use-memo": import("${configDir}").RuleModule<MessageIds, [], PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
             "toml-sort-keys": import("${configDir}").RuleModule<"unsorted", Options, PluginDocumentation, import("${configDir}").RuleListener> & {
@@ -181,7 +218,19 @@ declare const _default: {
     version: string;
   };
   rules: {
-    "naming-convention": import("${configDir}").RuleModule<MessageIds, Options$1, 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$2, Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
+      name: string;
+    };
+    "no-unnecessary-use-callback": import("${configDir}").RuleModule<MessageIds$1, [], PluginDocumentation, import("${configDir}").RuleListener> & {
+      name: string;
+    };
+    "no-unnecessary-use-memo": import("${configDir}").RuleModule<MessageIds, [], PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
     "toml-sort-keys": import("${configDir}").RuleModule<"unsorted", Options, PluginDocumentation, import("${configDir}").RuleListener> & {

package/dist/index.mjs

@@ -1,12 +1,14 @@
+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 * as core from "@eslint-react/core";
+import { findVariable } from "@typescript-eslint/utils/ast-utils";
 import { getStaticTOMLValue } from "toml-eslint-parser";
 //#region package.json
 var name = "eslint-plugin-flawless";
-var version = "0.1.2";
+var version = "0.1.4";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
@@ -32,6 +34,82 @@ function createEslintRule(rule) {
 	return createRule(rule);
 }
 //#endregion
+//#region src/rules/jsx-shorthand-boolean/rule.ts
+const RULE_NAME$6 = "jsx-shorthand-boolean";
+const MESSAGE_ID$2 = "setAttributeValue";
+const messages$6 = { [MESSAGE_ID$2]: "Set an explicit value for boolean attribute '{{name}}'." };
+function create$6(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$6,
+	create: create$6,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Disallow shorthand boolean JSX attributes",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$6,
+		schema: [],
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/rules/jsx-shorthand-fragment/rule.ts
+const RULE_NAME$5 = "jsx-shorthand-fragment";
+const MESSAGE_ID$1 = "useNamedFragment";
+const DEFAULT_FRAGMENT_NAME = "Fragment";
+const messages$5 = { [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$5(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$5,
+	create: create$5,
+	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$5,
+		schema: schema$1,
+		type: "suggestion"
+	}
+});
+//#endregion
 //#region src/utils/is-type-import.ts
 /**
 * Determine whether a variable definition is a type import. E.g.:.
@@ -1191,8 +1269,8 @@ const SCHEMA = {
 };
 //#endregion
 //#region src/rules/naming-convention/rule.ts
-const RULE_NAME$2 = "naming-convention";
-const messages$2 = {
+const RULE_NAME$4 = "naming-convention";
+const messages$4 = {
 	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}}",
@@ -1222,7 +1300,7 @@ const camelCaseNamingConfig = [
 		selector: "typeLike"
 	}
 ];
-function create$2(contextWithoutDefaults) {
+function create$4(contextWithoutDefaults) {
 	const context = contextWithoutDefaults.options.length > 0 ? contextWithoutDefaults : Object.setPrototypeOf({ options: camelCaseNamingConfig }, contextWithoutDefaults);
 	const validators = parseOptions(context);
 	const compilerOptions = getParserServices(context, true).program?.getCompilerOptions() ?? {};
@@ -1542,8 +1620,8 @@ function create$2(contextWithoutDefaults) {
 	}));
 }
 const namingConvention = createEslintRule({
-	name: RULE_NAME$2,
-	create: create$2,
+	name: RULE_NAME$4,
+	create: create$4,
 	defaultOptions: camelCaseNamingConfig,
 	meta: {
 		docs: {
@@ -1553,7 +1631,7 @@ const namingConvention = createEslintRule({
 		},
 		fixable: void 0,
 		hasSuggestions: false,
-		messages: messages$2,
+		messages: messages$4,
 		schema: SCHEMA,
 		type: "suggestion"
 	}
@@ -1583,6 +1661,305 @@ 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/utils/nested-expressions.ts
+/**
+* Determines whether the given AST subtree contains a call or `new`
+* expression.
+*
+* Replaces `@eslint-react/ast`'s `getNestedCallExpressions` /
+* `getNestedNewExpressions` (not exposed by `@eslint-react/kit`). The `useMemo`
+* rule uses this to avoid flagging a factory that performs real computation.
+* The walk descends into every child node (skipping the `parent` back-link to
+* avoid cycles), so calls nested in awaits, tagged templates, computed member
+* expressions, call targets and the like are all detected.
+*
+* @param root - The subtree root to inspect (typically a function body).
+* @returns `true` if a `CallExpression` or `NewExpression` is present.
+*/
+function hasNestedCallOrNew(root) {
+	const stack = [root];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (current === void 0) break;
+		if (current.type === AST_NODE_TYPES.CallExpression || current.type === AST_NODE_TYPES.NewExpression) return true;
+		pushChildNodes(current, stack);
+	}
+	return false;
+}
+/**
+* Type guard for an AST node value encountered while walking arbitrary
+* properties of a parent node.
+*
+* @param value - The candidate value.
+* @returns `true` if the value looks like a `TSESTree.Node`.
+*/
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+/**
+* Pushes every child node of `node` onto the traversal stack, skipping the
+* `parent` back-link.
+*
+* @param node - The node whose children to enqueue.
+* @param stack - The traversal stack to push onto.
+*/
+function pushChildNodes(node, stack) {
+	for (const key of Object.keys(node)) {
+		if (key === "parent") continue;
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) stack.push(item);
+		} else if (isNode(value)) stack.push(value);
+	}
+}
+//#endregion
+//#region src/utils/resolve.ts
+/**
+* Resolves an identifier to the AST node that represents its value.
+*
+* This is a focused re-implementation of `@eslint-react/var`'s `resolve`
+* covering only the cases the unnecessary-hook rules need: variable
+* initializers and function/class declarations. Every other definition kind
+* (imports, parameters, catch bindings, ...) resolves to `null`.
+*
+* @param sourceCode - Provides the scope used to look up the binding.
+* @param node - The identifier to resolve.
+* @returns The resolved value node, or `null` when it cannot be determined.
+*/
+function resolve(sourceCode, node) {
+	const variable = findVariable(sourceCode.getScope(node), node);
+	if (variable === null) return null;
+	const definition = variable.defs.at(0);
+	if (definition === void 0) return null;
+	if (definition.type === DefinitionType.ClassName || definition.type === DefinitionType.FunctionName) return definition.node;
+	if (definition.type === DefinitionType.Variable) return definition.node.init;
+	return null;
+}
+//#endregion
+//#region src/utils/unnecessary-hook.ts
+/**
+* Builds the `create` for the `no-unnecessary-use-memo` /
+* `no-unnecessary-use-callback` rules.
+*
+* Faithfully ports the rules removed from `eslint-plugin-react-x` (they were
+* dropped because the React Compiler makes them redundant; the Roblox /
+* `@rbxts/react` ecosystem has no Compiler). Hook detection is delegated to
+* `@eslint-react/core` so it matches the upstream semantics (fully-qualified
+* name resolution across imports, namespaces and `require`).
+*
+* @param config - The hook-specific configuration.
+* @returns A rule `create` function.
+* @template MessageIds - The rule's message identifiers.
+*/
+function createUnnecessaryHookRule(config) {
+	const { hook, messageIds } = config;
+	const skipComputation = hook === "useMemo";
+	return (context) => {
+		const { sourceCode } = context;
+		const reactContext = context;
+		const detectHookCall = hook === "useMemo" ? core.isUseMemoCall : core.isUseCallbackCall;
+		return { VariableDeclarator(node) {
+			const { id, init } = node;
+			if (id.type !== AST_NODE_TYPES.Identifier || init?.type !== AST_NODE_TYPES.CallExpression || !detectHookCall(reactContext, init)) return;
+			const [variable, ...rest] = sourceCode.getDeclaredVariables(node);
+			if (variable === void 0 || rest.length > 0) return;
+			const insideEffectReport = checkForUsageInsideUseEffect(sourceCode, init, messageIds.insideUseEffect);
+			const component = sourceCode.getScope(init).block;
+			if (!ASTUtils.isFunction(component)) return;
+			const [argument0, argument1] = init.arguments;
+			if (argument0 === void 0 || argument1 === void 0) return;
+			if (skipComputation && ASTUtils.isFunction(argument0) && hasNestedCallOrNew(argument0.body)) {
+				reportIf(context, insideEffectReport);
+				return;
+			}
+			if (!hasEmptyDeps(sourceCode, argument1)) {
+				reportIf(context, insideEffectReport);
+				return;
+			}
+			const factory = resolveFactory(sourceCode, argument0);
+			if (factory === null) return;
+			if (!referencesComponentScope(sourceCode, factory, component)) {
+				context.report({
+					messageId: messageIds.default,
+					node
+				});
+				return;
+			}
+			reportIf(context, insideEffectReport);
+		} };
+	};
+}
+/**
+* Finds the nearest ancestor that is a `useEffect`-like call.
+*
+* @param node - The node to search upward from.
+* @returns The enclosing effect call, or `null` when there is none.
+*/
+function findEnclosingEffect(node) {
+	let current = node.parent;
+	while (current !== void 0) {
+		if (core.isUseEffectLikeCall(current)) return current;
+		if (current.type === AST_NODE_TYPES.Program) return null;
+		current = current.parent;
+	}
+	return null;
+}
+/**
+* Reports the "used inside a single useEffect" case when applicable.
+*
+* @param sourceCode - Provides declared-variable and text lookups.
+* @param node - The hook call expression.
+* @param messageId - The message id to report.
+* @returns A report descriptor, or `null` when the case does not apply.
+* @template MessageIds - The rule's message identifiers.
+*/
+function checkForUsageInsideUseEffect(sourceCode, node, messageId) {
+	if (!/use\w*Effect/u.test(sourceCode.text)) return null;
+	const { parent } = node;
+	if (parent.type !== AST_NODE_TYPES.VariableDeclarator || parent.id.type !== AST_NODE_TYPES.Identifier) return null;
+	const usages = (sourceCode.getDeclaredVariables(parent).at(0)?.references ?? []).filter((reference) => reference.init !== true);
+	if (usages.length === 0) return null;
+	const effects = /* @__PURE__ */ new Set();
+	for (const usage of usages) {
+		const effect = findEnclosingEffect(usage.identifier);
+		if (effect === null) return null;
+		effects.add(effect);
+		if (effects.size > 1) return null;
+	}
+	return {
+		data: { name: parent.id.name },
+		messageId,
+		node
+	};
+}
+/**
+* Determines whether a dependency argument is an empty array (directly or via a
+* resolvable identifier).
+*
+* @param sourceCode - Provides scope lookup to resolve identifiers.
+* @param node - The dependency argument node.
+* @returns `true` if the dependencies are empty.
+*/
+function hasEmptyDeps(sourceCode, node) {
+	if (node.type === AST_NODE_TYPES.ArrayExpression) return node.elements.length === 0;
+	if (node.type === AST_NODE_TYPES.Identifier) {
+		const resolved = resolve(sourceCode, node);
+		return resolved?.type === AST_NODE_TYPES.ArrayExpression && resolved.elements.length === 0;
+	}
+	return false;
+}
+/**
+* Collects a scope together with all of its descendant scopes.
+*
+* @param scope - The root scope.
+* @returns The scope and every nested child scope.
+*/
+function flattenScopes(scope) {
+	return scope.childScopes.reduce((accumulator, child) => [...accumulator, ...flattenScopes(child)], [scope]);
+}
+/**
+* Determines whether any reference inside the factory resolves to a binding
+* declared in the component's scope.
+*
+* @param sourceCode - Provides scope lookup for the factory.
+* @param factory - The memoized factory function node.
+* @param component - The enclosing component function node.
+* @returns `true` if the factory reads from the component scope.
+*/
+function referencesComponentScope(sourceCode, factory, component) {
+	return flattenScopes(sourceCode.getScope(factory)).flatMap((scope) => scope.references).some((reference) => reference.resolved?.scope.block === component);
+}
+/**
+* Reports the descriptor when it is present.
+*
+* @param context - The rule context.
+* @param descriptor - The descriptor to report, or `null` to skip.
+* @template MessageIds - The rule's message identifiers.
+*/
+function reportIf(context, descriptor) {
+	if (descriptor !== null) context.report(descriptor);
+}
+/**
+* Resolves the first argument of the hook call to the underlying factory
+* function node, unwrapping a curried arrow (`() => () => ...`) and resolving
+* identifiers to their initializer.
+*
+* @param sourceCode - Provides scope lookup to resolve identifiers.
+* @param node - The first hook argument.
+* @returns The factory function node, or `null` when it is not a function.
+*/
+function resolveFactory(sourceCode, node) {
+	if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) return node.body.type === AST_NODE_TYPES.ArrowFunctionExpression ? node.body : node;
+	if (node.type === AST_NODE_TYPES.FunctionExpression) return node;
+	if (node.type === AST_NODE_TYPES.Identifier) {
+		const resolved = resolve(sourceCode, node);
+		if (resolved?.type === AST_NODE_TYPES.ArrowFunctionExpression || resolved?.type === AST_NODE_TYPES.FunctionExpression) return resolved;
+	}
+	return null;
+}
+//#endregion
+//#region src/rules/no-unnecessary-use-callback/rule.ts
+const RULE_NAME$3 = "no-unnecessary-use-callback";
+const MESSAGE_ID_DEFAULT$1 = "default";
+const MESSAGE_ID_INSIDE_USE_EFFECT$1 = "noUnnecessaryUseCallbackInsideUseEffect";
+const messages$3 = {
+	[MESSAGE_ID_DEFAULT$1]: "An 'useCallback' with empty deps and no references to the component scope may be unnecessary.",
+	[MESSAGE_ID_INSIDE_USE_EFFECT$1]: "'{{name}}' is only used inside 1 useEffect, which may be unnecessary. You can move the computation into useEffect directly and merge the dependency arrays."
+};
+const noUnnecessaryUseCallback = createEslintRule({
+	name: RULE_NAME$3,
+	create: createUnnecessaryHookRule({
+		hook: "useCallback",
+		messageIds: {
+			default: MESSAGE_ID_DEFAULT$1,
+			insideUseEffect: MESSAGE_ID_INSIDE_USE_EFFECT$1
+		}
+	}),
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Disallow unnecessary usage of 'useCallback'",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		hasSuggestions: false,
+		messages: messages$3,
+		schema: [],
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/rules/no-unnecessary-use-memo/rule.ts
+const RULE_NAME$2 = "no-unnecessary-use-memo";
+const MESSAGE_ID_DEFAULT = "default";
+const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
+const messages$2 = {
+	[MESSAGE_ID_DEFAULT]: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary.",
+	[MESSAGE_ID_INSIDE_USE_EFFECT]: "'{{name}}' is only used inside 1 useEffect, which may be unnecessary. You can move the computation into useEffect directly and merge the dependency arrays."
+};
+const noUnnecessaryUseMemo = createEslintRule({
+	name: RULE_NAME$2,
+	create: createUnnecessaryHookRule({
+		hook: "useMemo",
+		messageIds: {
+			default: MESSAGE_ID_DEFAULT,
+			insideUseEffect: MESSAGE_ID_INSIDE_USE_EFFECT
+		}
+	}),
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Disallow unnecessary usage of 'useMemo'",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		hasSuggestions: false,
+		messages: messages$2,
+		schema: [],
+		type: "suggestion"
+	}
+});
+//#endregion
 //#region src/rules/toml-sort-keys/rule.ts
 const RULE_NAME$1 = "toml-sort-keys";
 const MESSAGE_ID = "unsorted";
@@ -1878,7 +2255,11 @@ const plugin = {
 		version
 	},
 	rules: {
+		"jsx-shorthand-boolean": jsxShorthandBoolean,
+		"jsx-shorthand-fragment": jsxShorthandFragment,
 		"naming-convention": namingConvention,
+		"no-unnecessary-use-callback": noUnnecessaryUseCallback,
+		"no-unnecessary-use-memo": noUnnecessaryUseMemo,
 		"toml-sort-keys": tomlSortKeys,
 		"yaml-block-key-blank-lines": yamlBlockKeyBlankLines
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-flawless",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Your ESLint plugin description",
   "keywords": [
     "eslint",
@@ -34,6 +34,7 @@
     "*": "eslint --fix --cache"
   },
   "dependencies": {
+    "@eslint-react/core": "5.10.0",
     "@typescript-eslint/scope-manager": "8.62.1",
     "@typescript-eslint/type-utils": "8.62.1",
     "@typescript-eslint/utils": "8.62.1",