eslint-plugin-flawless 0.1.5 → 0.1.7

package/README.md

@@ -176,16 +176,17 @@ pnpm eslint-docs
 💭
 Requires [type information](https://typescript-eslint.io/linting/typed-linting).
 
-| 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'                              |     |     |
-| [prefer-destructuring-assignment](src/rules/prefer-destructuring-assignment/documentation.md) | Enforce destructuring assignment for component props                 | 🔧  |     |
-| [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)                   | Enforce a consistent fragment form: the shorthand `<>...</>` or 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'                                          |     |     |
+| [prefer-destructuring-assignment](src/rules/prefer-destructuring-assignment/documentation.md) | Enforce destructuring assignment for component props                             | 🔧  |     |
+| [purity](src/rules/purity/documentation.md)                                                   | Disallow impure calls such as `math.random` or `os.clock` during render          |     |     |
+| [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

@@ -9,7 +9,23 @@ interface PluginDocumentation {
 }
 //#endregion
 //#region src/rules/jsx-shorthand-fragment/rule.d.ts
-type Options$2 = [fragmentName?: string];
+declare const MESSAGE_ID_NAMED = "useNamedFragment";
+declare const MESSAGE_ID_SHORTHAND = "useShorthandFragment";
+type MessageIds$3 = typeof MESSAGE_ID_NAMED | typeof MESSAGE_ID_SHORTHAND;
+interface JsxShorthandFragmentOptions {
+  /**
+   * The identifier used for the named fragment element in `"element"` mode
+   * (e.g. `"Fragment"` or `"React.Fragment"`). Defaults to `"Fragment"`.
+   */
+  readonly fragmentName?: string;
+  /**
+   * Which form to enforce: `"syntax"` (shorthand `<>...</>`, the default) or
+   * `"element"` (a named fragment such as `<Fragment>...</Fragment>`).
+   */
+  readonly mode?: Mode;
+}
+type Options$3 = [JsxShorthandFragmentOptions?];
+type Mode = "element" | "syntax";
 //#endregion
 //#region src/rules/naming-convention/utils/enums.d.ts
 declare const Selector: {
@@ -119,7 +135,7 @@ interface NamingSelector {
 //#endregion
 //#region src/rules/naming-convention/rule.d.ts
 type MessageIds$2 = "doesNotMatchFormat" | "doesNotMatchFormatTrimmed" | "missingAffix" | "missingUnderscore" | "satisfyCustom" | "unexpectedUnderscore";
-type Options$1 = Array<NamingSelector>;
+type Options$2 = Array<NamingSelector>;
 //#endregion
 //#region src/rules/no-unnecessary-use-callback/rule.d.ts
 declare const MESSAGE_ID_DEFAULT$1 = "default";
@@ -131,6 +147,18 @@ 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/purity/rule.d.ts
+interface PurityOptions {
+  /**
+   * Extra dotted call signatures to treat as impure, added to the defaults
+   * (e.g. `"Math.random"` when using a Luau `Math` polyfill).
+   */
+  readonly additionalFunctions?: ReadonlyArray<string>;
+  /** Default signatures to exclude (e.g. `"os.date"`). */
+  readonly ignore?: ReadonlyArray<string>;
+}
+type Options$1 = [PurityOptions?];
+//#endregion
 //#region src/rules/toml-sort-keys/rule.d.ts
 type Options = Array<SortSpec>;
 interface SortOrderObject {
@@ -154,10 +182,10 @@ declare const plugin: {
     "jsx-shorthand-boolean": TSESLint.RuleModule<"setAttributeValue", [], PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
-    "jsx-shorthand-fragment": TSESLint.RuleModule<"useNamedFragment", Options$2, PluginDocumentation, TSESLint.RuleListener> & {
+    "jsx-shorthand-fragment": TSESLint.RuleModule<MessageIds$3, Options$3, PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
-    "naming-convention": TSESLint.RuleModule<MessageIds$2, Options$1, PluginDocumentation, TSESLint.RuleListener> & {
+    "naming-convention": TSESLint.RuleModule<MessageIds$2, Options$2, PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
     "no-unnecessary-use-callback": TSESLint.RuleModule<MessageIds$1, [], PluginDocumentation, TSESLint.RuleListener> & {
@@ -169,6 +197,9 @@ declare const plugin: {
     "prefer-destructuring-assignment": TSESLint.RuleModule<"default", [], PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
+    purity: TSESLint.RuleModule<"impureCall", Options$1, PluginDocumentation, TSESLint.RuleListener> & {
+      name: string;
+    };
     "toml-sort-keys": TSESLint.RuleModule<"unsorted", Options, PluginDocumentation, TSESLint.RuleListener> & {
       name: string;
     };
@@ -192,10 +223,10 @@ declare const _default: {
             "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> & {
+            "jsx-shorthand-fragment": import("${configDir}").RuleModule<MessageIds$3, Options$3, PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
-            "naming-convention": import("${configDir}").RuleModule<MessageIds$2, Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
+            "naming-convention": import("${configDir}").RuleModule<MessageIds$2, Options$2, PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
             "no-unnecessary-use-callback": import("${configDir}").RuleModule<MessageIds$1, [], PluginDocumentation, import("${configDir}").RuleListener> & {
@@ -207,6 +238,9 @@ declare const _default: {
             "prefer-destructuring-assignment": import("${configDir}").RuleModule<"default", [], PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
+            purity: import("${configDir}").RuleModule<"impureCall", Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
+              name: string;
+            };
             "toml-sort-keys": import("${configDir}").RuleModule<"unsorted", Options, PluginDocumentation, import("${configDir}").RuleListener> & {
               name: string;
             };
@@ -227,10 +261,10 @@ declare const _default: {
     "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> & {
+    "jsx-shorthand-fragment": import("${configDir}").RuleModule<MessageIds$3, Options$3, PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
-    "naming-convention": import("${configDir}").RuleModule<MessageIds$2, Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
+    "naming-convention": import("${configDir}").RuleModule<MessageIds$2, Options$2, PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
     "no-unnecessary-use-callback": import("${configDir}").RuleModule<MessageIds$1, [], PluginDocumentation, import("${configDir}").RuleListener> & {
@@ -242,6 +276,9 @@ declare const _default: {
     "prefer-destructuring-assignment": import("${configDir}").RuleModule<"default", [], PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };
+    purity: import("${configDir}").RuleModule<"impureCall", Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
+      name: string;
+    };
     "toml-sort-keys": import("${configDir}").RuleModule<"unsorted", Options, PluginDocumentation, import("${configDir}").RuleListener> & {
       name: string;
     };

package/dist/index.mjs

@@ -1,14 +1,14 @@
 import { RuleCreator, getParserServices } from "@typescript-eslint/utils/eslint-utils";
+import { ASTUtils, AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-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 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.5";
+var version = "0.1.7";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
@@ -35,10 +35,10 @@ function createEslintRule(rule) {
 }
 //#endregion
 //#region src/rules/jsx-shorthand-boolean/rule.ts
-const RULE_NAME$7 = "jsx-shorthand-boolean";
+const RULE_NAME$8 = "jsx-shorthand-boolean";
 const MESSAGE_ID$3 = "setAttributeValue";
-const messages$7 = { [MESSAGE_ID$3]: "Set an explicit value for boolean attribute '{{name}}'." };
-function create$7(context) {
+const messages$8 = { [MESSAGE_ID$3]: "Set an explicit value for boolean attribute '{{name}}'." };
+function create$8(context) {
 	const { sourceCode } = context;
 	return { JSXAttribute(node) {
 		if (node.value !== null) return;
@@ -51,8 +51,8 @@ function create$7(context) {
 	} };
 }
 const jsxShorthandBoolean = createEslintRule({
-	name: RULE_NAME$7,
-	create: create$7,
+	name: RULE_NAME$8,
+	create: create$8,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -62,50 +62,112 @@ const jsxShorthandBoolean = createEslintRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$7,
+		messages: messages$8,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/jsx-shorthand-fragment/rule.ts
-const RULE_NAME$6 = "jsx-shorthand-fragment";
-const MESSAGE_ID$2 = "useNamedFragment";
+const RULE_NAME$7 = "jsx-shorthand-fragment";
+const MESSAGE_ID_NAMED = "useNamedFragment";
+const MESSAGE_ID_SHORTHAND = "useShorthandFragment";
+const DEFAULT_MODE = "syntax";
 const DEFAULT_FRAGMENT_NAME = "Fragment";
-const messages$6 = { [MESSAGE_ID$2]: "Use the '{{name}}' component instead of fragment shorthand syntax." };
-const schema$1 = [{
-	description: "The identifier to use for the named fragment element.",
-	type: "string"
+const messages$7 = {
+	[MESSAGE_ID_NAMED]: "Use the '{{name}}' component instead of fragment shorthand syntax.",
+	[MESSAGE_ID_SHORTHAND]: "Use the fragment shorthand syntax '<>...</>' instead of the '{{name}}' component."
+};
+const schema$2 = [{
+	additionalProperties: false,
+	properties: {
+		fragmentName: {
+			description: "The identifier to use for the named fragment element in \"element\" mode.",
+			type: "string"
+		},
+		mode: {
+			description: "Which form to enforce: \"syntax\" (shorthand `<>...</>`, default) or \"element\" (a named fragment).",
+			enum: ["element", "syntax"],
+			type: "string"
+		}
+	},
+	type: "object"
 }];
-function create$6(context) {
-	const name = context.options[0] ?? DEFAULT_FRAGMENT_NAME;
-	return { JSXFragment(node) {
+/**
+* Flattens a JSX element name into a dotted string, e.g. `Fragment` or
+* `React.Fragment`. Returns `null` for namespaced names (`<a:b>`) which cannot
+* be a fragment.
+*
+* @param node - The JSX element name node.
+* @returns The dotted name, or `null` when it is not a plain identifier chain.
+*/
+function jsxNameToString(node) {
+	if (node.type === AST_NODE_TYPES.JSXIdentifier) return node.name;
+	if (node.type === AST_NODE_TYPES.JSXMemberExpression) {
+		const object = jsxNameToString(node.object);
+		if (object === null) return null;
+		return `${object}.${node.property.name}`;
+	}
+	return null;
+}
+function create$7(context) {
+	const options = context.options[0] ?? {};
+	const mode = options.mode ?? DEFAULT_MODE;
+	const fragmentName = options.fragmentName ?? DEFAULT_FRAGMENT_NAME;
+	if (mode === "element") return { JSXFragment(node) {
 		const { closingFragment, openingFragment } = node;
+		context.report({
+			data: { name: fragmentName },
+			fix: (fixer) => {
+				return [fixer.replaceText(openingFragment, `<${fragmentName}>`), fixer.replaceText(closingFragment, `</${fragmentName}>`)];
+			},
+			messageId: MESSAGE_ID_NAMED,
+			node
+		});
+	} };
+	const namedFragments = /* @__PURE__ */ new Set([
+		"Fragment",
+		fragmentName,
+		"React.Fragment"
+	]);
+	return { JSXElement(node) {
+		const { openingElement } = node;
+		const name = jsxNameToString(openingElement.name);
+		if (name === null || !namedFragments.has(name)) return;
+		if (openingElement.attributes.length > 0) return;
 		context.report({
 			data: { name },
 			fix: (fixer) => {
-				return [fixer.replaceText(openingFragment, `<${name}>`), fixer.replaceText(closingFragment, `</${name}>`)];
+				const { closingElement } = node;
+				if (closingElement === null) return fixer.replaceText(node, "<></>");
+				return [fixer.replaceText(openingElement, "<>"), fixer.replaceText(closingElement, "</>")];
 			},
-			messageId: MESSAGE_ID$2,
+			messageId: MESSAGE_ID_SHORTHAND,
 			node
 		});
 	} };
 }
 const jsxShorthandFragment = createEslintRule({
-	name: RULE_NAME$6,
-	create: create$6,
-	defaultOptions: [DEFAULT_FRAGMENT_NAME],
+	name: RULE_NAME$7,
+	create: create$7,
+	defaultOptions: [{
+		fragmentName: DEFAULT_FRAGMENT_NAME,
+		mode: DEFAULT_MODE
+	}],
 	meta: {
-		defaultOptions: [DEFAULT_FRAGMENT_NAME],
+		defaultOptions: [{
+			fragmentName: DEFAULT_FRAGMENT_NAME,
+			mode: DEFAULT_MODE
+		}],
 		docs: {
-			description: "Disallow the shorthand fragment syntax in favour of a named fragment",
+			description: "Enforce a consistent fragment form: the shorthand `<>...</>` or a named fragment",
 			recommended: false,
 			requiresTypeChecking: false
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$6,
-		schema: schema$1,
+		messages: messages$7,
+		schema: schema$2,
 		type: "suggestion"
 	}
 });
@@ -1269,8 +1331,8 @@ const SCHEMA = {
 };
 //#endregion
 //#region src/rules/naming-convention/rule.ts
-const RULE_NAME$5 = "naming-convention";
-const messages$5 = {
+const RULE_NAME$6 = "naming-convention";
+const messages$6 = {
 	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}}",
@@ -1300,7 +1362,7 @@ const camelCaseNamingConfig = [
 		selector: "typeLike"
 	}
 ];
-function create$5(contextWithoutDefaults) {
+function create$6(contextWithoutDefaults) {
 	const context = contextWithoutDefaults.options.length > 0 ? contextWithoutDefaults : Object.setPrototypeOf({ options: camelCaseNamingConfig }, contextWithoutDefaults);
 	const validators = parseOptions(context);
 	const compilerOptions = getParserServices(context, true).program?.getCompilerOptions() ?? {};
@@ -1620,8 +1682,8 @@ function create$5(contextWithoutDefaults) {
 	}));
 }
 const namingConvention = createEslintRule({
-	name: RULE_NAME$5,
-	create: create$5,
+	name: RULE_NAME$6,
+	create: create$6,
 	defaultOptions: camelCaseNamingConfig,
 	meta: {
 		docs: {
@@ -1631,7 +1693,7 @@ const namingConvention = createEslintRule({
 		},
 		fixable: void 0,
 		hasSuggestions: false,
-		messages: messages$5,
+		messages: messages$6,
 		schema: SCHEMA,
 		type: "suggestion"
 	}
@@ -1899,15 +1961,15 @@ function resolveFactory(sourceCode, node) {
 }
 //#endregion
 //#region src/rules/no-unnecessary-use-callback/rule.ts
-const RULE_NAME$4 = "no-unnecessary-use-callback";
+const RULE_NAME$5 = "no-unnecessary-use-callback";
 const MESSAGE_ID_DEFAULT$1 = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT$1 = "noUnnecessaryUseCallbackInsideUseEffect";
-const messages$4 = {
+const messages$5 = {
 	[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$4,
+	name: RULE_NAME$5,
 	create: createUnnecessaryHookRule({
 		hook: "useCallback",
 		messageIds: {
@@ -1923,22 +1985,22 @@ const noUnnecessaryUseCallback = createEslintRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$4,
+		messages: messages$5,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/no-unnecessary-use-memo/rule.ts
-const RULE_NAME$3 = "no-unnecessary-use-memo";
+const RULE_NAME$4 = "no-unnecessary-use-memo";
 const MESSAGE_ID_DEFAULT = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
-const messages$3 = {
+const messages$4 = {
 	[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$3,
+	name: RULE_NAME$4,
 	create: createUnnecessaryHookRule({
 		hook: "useMemo",
 		messageIds: {
@@ -1954,16 +2016,16 @@ const noUnnecessaryUseMemo = createEslintRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$3,
+		messages: messages$4,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/prefer-destructuring-assignment/rule.ts
-const RULE_NAME$2 = "prefer-destructuring-assignment";
-const MESSAGE_ID$1 = "default";
-const messages$2 = { [MESSAGE_ID$1]: "Use destructuring assignment for component props." };
+const RULE_NAME$3 = "prefer-destructuring-assignment";
+const MESSAGE_ID$2 = "default";
+const messages$3 = { [MESSAGE_ID$2]: "Use destructuring assignment for component props." };
 /**
 * Identifiers that cannot be used as a binding name in strict-mode module code.
 * A property may be accessed with such a name (`props.default`), but a shorthand
@@ -2089,7 +2151,7 @@ function reportComponent(context, scope, propsParameter, propertyVariable) {
 	const propertyNames = collectPropertyNames(memberReferences);
 	if (!(!hasNonMemberReference && propertyNames !== null && !wouldShadowExistingBinding(context.sourceCode, scope, propertyVariable, memberReferences))) {
 		for (const { member } of memberReferences) context.report({
-			messageId: MESSAGE_ID$1,
+			messageId: MESSAGE_ID$2,
 			node: member
 		});
 		return;
@@ -2106,7 +2168,7 @@ function reportComponent(context, scope, propsParameter, propertyVariable) {
 				if (index === 0) return [fixer.replaceTextRange([propsParameter.range[0], nameEnd], pattern), replaceAccess];
 				return replaceAccess;
 			},
-			messageId: MESSAGE_ID$1,
+			messageId: MESSAGE_ID$2,
 			node: member
 		});
 	}
@@ -2125,7 +2187,7 @@ function reportComponent(context, scope, propsParameter, propertyVariable) {
 * @param context - The rule context.
 * @returns The rule listener.
 */
-function create$2(context) {
+function create$3(context) {
 	const { api, visitor } = core.getFunctionComponentCollector(context);
 	return {
 		...visitor,
@@ -2143,8 +2205,8 @@ function create$2(context) {
 	};
 }
 const preferDestructuringAssignment = createEslintRule({
-	name: RULE_NAME$2,
-	create: create$2,
+	name: RULE_NAME$3,
+	create: create$3,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -2154,12 +2216,194 @@ const preferDestructuringAssignment = createEslintRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$2,
+		messages: messages$3,
 		schema: [],
 		type: "problem"
 	}
 });
 //#endregion
+//#region src/rules/purity/rule.ts
+const RULE_NAME$2 = "purity";
+const MESSAGE_ID$1 = "impureCall";
+/**
+* Non-deterministic Luau / Roblox calls, written as dotted paths matching how
+* they appear in roblox-ts source. `new Random()` is normalized to
+* `"Random.new"` (see the `NewExpression` visitor).
+*/
+const DEFAULT_SIGNATURES = [
+	"DateTime.now",
+	"HttpService.GenerateGUID",
+	"Random.new",
+	"Workspace.GetServerTimeNow",
+	"elapsedTime",
+	"math.random",
+	"math.randomseed",
+	"os.clock",
+	"os.date",
+	"os.time",
+	"tick",
+	"time"
+];
+/**
+* Bare Luau globals for which a matching local binding means the reference is
+* shadowed rather than the ambient global. Service objects are intentionally
+* excluded because they are impure even when imported from `@rbxts/services`.
+*/
+const GUARDED_GLOBALS = /* @__PURE__ */ new Set([
+	"elapsedTime",
+	"math",
+	"os",
+	"tick",
+	"time"
+]);
+const messages$2 = { [MESSAGE_ID$1]: "Do not call '{{name}}' during render. Components and hooks must be pure. Move this call into an event handler, effect, or state initializer." };
+const schema$1 = [{
+	additionalProperties: false,
+	properties: {
+		additionalFunctions: {
+			description: "Extra dotted call signatures to treat as impure (e.g. \"Math.random\").",
+			items: { type: "string" },
+			type: "array",
+			uniqueItems: true
+		},
+		ignore: {
+			description: "Default signatures to exclude (e.g. \"os.date\").",
+			items: { type: "string" },
+			type: "array",
+			uniqueItems: true
+		}
+	},
+	type: "object"
+}];
+/**
+* Strips wrappers that are irrelevant to the callee identity so that
+* `a.b?.()` and `a.b!()` still match.
+*
+* @param node - The node to unwrap.
+* @returns The unwrapped node.
+*/
+function unwrap(node) {
+	let current = node;
+	while (current.type === AST_NODE_TYPES.ChainExpression || current.type === AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
+	return current;
+}
+/**
+* Builds the dotted path for a callee, e.g. `math.random` or `tick`.
+*
+* @param callee - The callee expression.
+* @returns The match, or `null` when the callee cannot be represented as a
+*   simple dotted path (computed access, or an object that is an expression).
+*/
+function dottedCalleePath(callee) {
+	let current = unwrap(callee);
+	const parts = [];
+	while (current.type === AST_NODE_TYPES.MemberExpression) {
+		if (current.computed || current.property.type !== AST_NODE_TYPES.Identifier) return null;
+		parts.unshift(current.property.name);
+		current = unwrap(current.object);
+	}
+	if (current.type !== AST_NODE_TYPES.Identifier) return null;
+	parts.unshift(current.name);
+	return {
+		path: parts.join("."),
+		root: current
+	};
+}
+/**
+* Determines whether an identifier resolves to a real user binding (import,
+* parameter, or local declaration) rather than the ambient Luau global.
+*
+* @param sourceCode - Provides scope lookup.
+* @param node - The identifier node.
+* @returns `true` when the identifier is a user binding rather than the ambient
+*   global.
+*/
+function isUserBinding(sourceCode, node) {
+	let scope = sourceCode.getScope(node);
+	while (scope !== null) {
+		const variable = scope.variables.find((candidate) => candidate.name === node.name);
+		if (variable !== void 0) return variable.defs.length > 0;
+		scope = scope.upper;
+	}
+	return false;
+}
+/**
+* Finds the immediate enclosing function of a node, stopping at the program.
+*
+* @param node - The node to search upward from.
+* @returns The enclosing function, or `null` when the node is at module level.
+*/
+function enclosingFunction(node) {
+	let current = node.parent;
+	while (current !== void 0) {
+		if (ASTUtils.isFunction(current)) return current;
+		if (current.type === AST_NODE_TYPES.Program) return null;
+		current = current.parent;
+	}
+	return null;
+}
+/**
+* Determines whether a function executes during render: a component body, a
+* custom/builtin hook body, or a `useMemo` callback.
+*
+* @param reactContext - The context `@eslint-react/core` predicates expect.
+* @param func - The enclosing function node.
+* @returns `true` when the function runs during render.
+*/
+function isRenderContext(reactContext, func) {
+	if (core.isFunctionComponentDefinition(reactContext, func, core.DEFAULT_COMPONENT_DETECTION_HINT)) return true;
+	if (core.isHookDefinition(func)) return true;
+	const { parent } = func;
+	return parent.type === AST_NODE_TYPES.CallExpression && parent.arguments[0] === func && core.isUseMemoCall(reactContext, parent);
+}
+function create$2(context) {
+	const { sourceCode } = context;
+	const reactContext = context;
+	const options = context.options[0] ?? {};
+	const signatures = new Set(DEFAULT_SIGNATURES);
+	for (const signature of options.additionalFunctions ?? []) signatures.add(signature);
+	for (const signature of options.ignore ?? []) signatures.delete(signature);
+	function handle(node, match, path) {
+		if (!signatures.has(path)) return;
+		if (path === "Random.new" && node.arguments.length > 0) return;
+		if (GUARDED_GLOBALS.has(match.root.name) && isUserBinding(sourceCode, match.root)) return;
+		const func = enclosingFunction(node);
+		if (func === null || !isRenderContext(reactContext, func)) return;
+		context.report({
+			data: { name: path },
+			messageId: MESSAGE_ID$1,
+			node
+		});
+	}
+	return {
+		CallExpression(node) {
+			const match = dottedCalleePath(node.callee);
+			if (match !== null) handle(node, match, match.path);
+		},
+		NewExpression(node) {
+			const match = dottedCalleePath(node.callee);
+			if (match !== null) handle(node, match, `${match.path}.new`);
+		}
+	};
+}
+const purity = createEslintRule({
+	name: RULE_NAME$2,
+	create: create$2,
+	defaultOptions: [{}],
+	meta: {
+		defaultOptions: [{}],
+		docs: {
+			description: "Disallow impure calls such as `math.random` or `os.clock` during render",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		hasSuggestions: false,
+		messages: messages$2,
+		schema: schema$1,
+		type: "problem"
+	}
+});
+//#endregion
 //#region src/rules/toml-sort-keys/rule.ts
 const RULE_NAME$1 = "toml-sort-keys";
 const MESSAGE_ID = "unsorted";
@@ -2461,6 +2705,7 @@ const plugin = {
 		"no-unnecessary-use-callback": noUnnecessaryUseCallback,
 		"no-unnecessary-use-memo": noUnnecessaryUseMemo,
 		"prefer-destructuring-assignment": preferDestructuringAssignment,
+		"purity": purity,
 		"toml-sort-keys": tomlSortKeys,
 		"yaml-block-key-blank-lines": yamlBlockKeyBlankLines
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-flawless",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Your ESLint plugin description",
   "keywords": [
     "eslint",