@pobammer-ts/eslint-cease-nonsense-rules 1.12.0 → 1.13.0

package/dist/build-metadata.json

@@ -1,5 +1,5 @@
 {
-  "commit": "0c941c22d06cca23db96491078c85d1b80fb0191",
-  "time": "2026-01-01T05:26:31.863Z",
-  "version": "1.12.0"
+  "commit": "f33c0a297afd84a62ae94883352f3473b4ff25de",
+  "time": "2026-01-01T07:48:21.692Z",
+  "version": "1.13.0"
 }

package/dist/index.js

@@ -16350,7 +16350,7 @@ var ban_instances_default = createRule({
       description: "Ban specified Roblox Instance classes in new Instance() calls and JSX elements."
     },
     messages: {
-      bannedInstance: "Instance class '{{className}}' is banned.",
+      bannedInstance: "Instance class '{{className}}' is banned by project configuration. This class may cause performance issues, is deprecated, or has a better alternative. Check project guidelines for the recommended replacement.",
       bannedInstanceCustom: "{{customMessage}}"
     },
     schema: [
@@ -18176,7 +18176,7 @@ var noCommentedCode = {
     },
     hasSuggestions: true,
     messages: {
-      commentedCode: "Remove this commented out code."
+      commentedCode: "Commented-out code creates confusion about intent and clutters the codebase. Version control preserves history, making dead code comments unnecessary. Delete the commented code entirely. If needed later, retrieve it from git history."
     },
     schema: [],
     type: "suggestion"
@@ -18833,7 +18833,7 @@ var no_print_default = createRule({
       description: "Ban print() function calls. Use Log instead."
     },
     messages: {
-      useLog: "Use Log instead of print()"
+      useLog: "print() is a raw output function lacking log levels, timestamps, and filtering. Production systems require structured logging for debugging and monitoring. Replace print(...) with something from the logging package."
     },
     schema: [],
     type: "problem"
@@ -19129,7 +19129,7 @@ var noShorthandNames = {
       recommended: true
     },
     messages: {
-      useReplacement: "Use '{{replacement}}' instead of '{{shorthand}}' shorthand"
+      useReplacement: "'{{shorthand}}' is a shorthand abbreviation that reduces code readability. Abbreviated names force readers to mentally expand them and can mean different things in different contexts. Rename to '{{replacement}}' for clarity and self-documenting code."
     },
     schema: [
       {
@@ -19561,7 +19561,7 @@ var no_warn_default = createRule({
       description: "Ban warn() function calls. Use Log instead."
     },
     messages: {
-      useLog: "Use Log instead of warn()"
+      useLog: "warn() is a raw output function lacking log levels, timestamps, and filtering. Production systems require structured logging for debugging and monitoring. Replace warn(...) with something from the logging package."
     },
     schema: [],
     type: "problem"
@@ -19670,8 +19670,8 @@ var prefer_class_properties_default = createRule({
       description: "Prefer class properties to assignment of literals in constructors."
     },
     messages: {
-      unexpectedAssignment: "Unexpected assignment of literal instance member.",
-      unexpectedClassProperty: "Unexpected class property."
+      unexpectedAssignment: "Constructor assigns a literal value to this.property. Literals are static and known at class definition time. Move to a class property declaration: propertyName = value; at class level. This clarifies intent and reduces constructor complexity.",
+      unexpectedClassProperty: "Class property declarations are disabled by rule configuration (mode: 'never'). Move initialization into the constructor: this.propertyName = value; inside constructor()."
     },
     schema: [{ enum: ["always", "never"], type: "string" }],
     type: "suggestion"
@@ -19722,7 +19722,7 @@ var prefer_early_return_default = createRule({
       description: "Prefer early returns over full-body conditional wrapping in function declarations."
     },
     messages: {
-      preferEarlyReturn: "Prefer an early return to a conditionally-wrapped function body"
+      preferEarlyReturn: "Function body is wrapped in a single conditional without an else branch. This increases nesting depth and cognitive load. Invert the condition and return early: if (!condition) return; then place the main logic at the top level."
     },
     schema: [
       {
@@ -19876,7 +19876,7 @@ var prefer_pascal_case_enums_default = createRule({
       description: "Enforce Pascal case when naming enums."
     },
     messages: {
-      notPascalCase: "Enum '{{ identifier }}' should use Pascal case."
+      notPascalCase: "Enum '{{ identifier }}' uses non-standard casing. TypeScript convention requires PascalCase for enum names and members to distinguish them from variables (camelCase) and constants (UPPER_CASE). Rename to PascalCase: capitalize first letter of each word, no underscores."
     },
     schema: [],
     type: "suggestion"
@@ -20541,7 +20541,7 @@ var prefer_singular_enums_default = createRule({
       description: "Prefer singular TypeScript enums."
     },
     messages: {
-      notSingular: "Enum '{{ name }}' should be singular."
+      notSingular: "Enum '{{ name }}' uses plural naming. Enums define a type of which only ONE value is selected at a time, so singular naming is semantically correct. Use 'Status' not 'Statuses', 'Color' not 'Colors'. Rename the enum to its singular form."
     },
     schema: [],
     type: "suggestion"
@@ -20838,7 +20838,7 @@ var react_hooks_strict_return_default = createRule({
       description: "Restrict the number of returned items from React hooks."
     },
     messages: {
-      hooksStrictReturn: "React hooks must return a tuple of two or fewer values or a single object."
+      hooksStrictReturn: "Hook returns more than 2 tuple elements. Destructuring large tuples causes positional errors and breaks when adding values. Return an object with named properties instead: `return { value, setValue, isLoading };`"
     },
     schema: [],
     type: "suggestion"
@@ -21126,17 +21126,17 @@ var requireNamedEffectFunctions = {
       recommended: false
     },
     messages: {
-      anonymousFunction: "Use a named function instead of an anonymous function for better debuggability",
-      arrowFunction: "Use a named function instead of an arrow function for better debuggability",
-      asyncAnonymousFunction: "Async anonymous functions are not allowed in {{ hook }}. Use an async function declaration instead",
-      asyncArrowFunction: "Async arrow functions are not allowed in {{ hook }}. Use an async function declaration instead",
-      asyncFunctionDeclaration: "Async function declarations are not allowed in {{ hook }}. Set allowAsync: true for this hook to enable",
-      asyncFunctionExpression: "Async function expressions are not allowed in {{ hook }}. Use an async function declaration instead",
-      functionExpression: "Use a named function reference instead of a function expression for better debuggability",
-      identifierReferencesArrow: "{{ hook }} called with identifier that references an arrow function. Use a named function declaration instead",
-      identifierReferencesAsyncArrow: "{{ hook }} called with identifier that references an async arrow function. Set allowAsync: true for this hook to enable",
-      identifierReferencesAsyncFunction: "{{ hook }} called with identifier that references an async function. Set allowAsync: true for this hook to enable",
-      identifierReferencesCallback: "{{ hook }} called with identifier that references a useCallback/useMemo result. Use a named function declaration instead"
+      anonymousFunction: "Anonymous function passed to {{hook}}. debug.info returns empty string for anonymous functions, making stack traces useless for debugging. Extract to: function effectName() { ... } then pass effectName.",
+      arrowFunction: "Arrow function passed to {{hook}}. Arrow functions have no debug name and create new instances each render. Extract to: function effectName() { ... } then pass effectName.",
+      asyncAnonymousFunction: "Async anonymous function in {{hook}}. Two issues: (1) no debug name makes stack traces useless, (2) async effects require cancellation logic for unmount. Extract to: async function effectName() { ... } with cleanup.",
+      asyncArrowFunction: "Async arrow function in {{hook}}. Two issues: (1) arrow functions have no debug name, (2) async effects require cancellation logic. Extract to: async function effectName() { ... } with cleanup.",
+      asyncFunctionDeclaration: "Async function declaration passed to {{hook}}. Async effects require cancellation logic to handle component unmount. Implement cleanup or set allowAsync: true if cancellation is handled.",
+      asyncFunctionExpression: "Async function expression in {{hook}}. Async effects require cancellation logic for unmount. Extract to a named async function declaration with cleanup, then pass the reference.",
+      functionExpression: "Function expression passed to {{hook}}. Function expressions create new instances each render, breaking referential equality. Extract to: function effectName() { ... } at module or component top-level.",
+      identifierReferencesArrow: "{{hook}} receives identifier pointing to arrow function. Arrow functions have no debug name and lack referential stability. Convert to: function effectName() { ... } then pass effectName.",
+      identifierReferencesAsyncArrow: "{{hook}} receives identifier pointing to async arrow function. Two issues: (1) no debug name, (2) async effects require cancellation logic. Convert to: async function effectName() { ... } with cleanup.",
+      identifierReferencesAsyncFunction: "{{hook}} receives identifier pointing to async function. Async effects require cancellation logic for unmount. Implement cleanup or set allowAsync: true if cancellation is handled.",
+      identifierReferencesCallback: "{{hook}} receives identifier from useCallback/useMemo. These hooks return new references when dependencies change, causing unexpected effect re-runs. Use a stable function declaration: function effectName() { ... }"
     },
     schema: [
       {
@@ -22318,8 +22318,8 @@ var require_react_component_keys_default = createRule({
       description: "Require keys on React components when used in lists or iteration."
     },
     messages: {
-      missingKey: "All React elements except top-level returns require a key prop",
-      rootComponentWithKey: "Root component returns should not have key props"
+      missingKey: "JSX element in list/callback lacks key prop. React Luau warns about missing keys in _G.__DEV__ mode. Add a unique `key` prop using a stable identifier (not array index).",
+      rootComponentWithKey: "Root return has unnecessary key prop. The key gets overwritten by the parent anyway. Remove the `key` prop."
     },
     schema: [
       {
@@ -23946,4 +23946,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=A19451816DAA8A5E64756E2164756E21
+//# debugId=2B2944174D0F631464756E2164756E21