@pobammer-ts/eslint-cease-nonsense-rules 1.15.0 → 1.17.1

package/README.md

@@ -53,6 +53,7 @@ export default [
 			"cease-nonsense/no-print": "error",
 			"cease-nonsense/prefer-enum-item": "error",
 			"cease-nonsense/no-shorthand-names": "error",
+			"cease-nonsense/no-unused-imports": "error",
 			"cease-nonsense/no-useless-use-spring": "error",
 			"cease-nonsense/no-warn": "error",
 			"cease-nonsense/prefer-class-properties": "error",
@@ -64,10 +65,12 @@ export default [
 			"cease-nonsense/prefer-singular-enums": "error",
 			"cease-nonsense/prefer-udim2-shorthand": "error",
 			"cease-nonsense/react-hooks-strict-return": "error",
+			"cease-nonsense/require-module-level-instantiation": "error",
 			"cease-nonsense/require-named-effect-functions": "error",
 			"cease-nonsense/require-paired-calls": "error",
 			"cease-nonsense/require-react-component-keys": "error",
 			"cease-nonsense/require-react-display-names": "error",
+			"cease-nonsense/prefer-read-only-props": "error",
 			"cease-nonsense/strict-component-boundaries": "error",
 			"cease-nonsense/use-exhaustive-dependencies": "error",
 			"cease-nonsense/use-hook-at-top-level": "error",
@@ -171,7 +174,50 @@ const props: ImageProps = { ScaleType: 1 };
 <uiflexitem FlexMode={Enum.UIFlexMode.Fill} />
 
 // Explicit enum in object
-const props: ImageProps = { ScaleType: Enum.ScaleType.Slice };
+	const props: ImageProps = { ScaleType: Enum.ScaleType.Slice };
+```
+
+#### `no-unused-imports`
+
+Disallow unused imports. Uses ESLint's scope analysis to detect unused imports and optionally checks JSDoc comments for references.
+
+**Configuration**
+
+```typescript
+{
+  "cease-nonsense/no-unused-imports": ["error", {
+    "checkJSDoc": true  // Check if imports are referenced in JSDoc comments
+  }]
+}
+```
+
+**Features**
+
+- ✨ Has auto-fix
+- Cached JSDoc comment parsing per file
+- Pre-compiled regex patterns
+- Efficient scope analysis using ESLint's built-in mechanisms
+
+**❌ Bad**
+
+```typescript
+import { unusedFunction } from "./utils";
+import { AnotherUnused } from "./types";
+
+// unusedFunction and AnotherUnused are never used
+```
+
+**✅ Good**
+
+```typescript
+import { usedFunction } from "./utils";
+
+usedFunction();
+
+// Or used in JSDoc
+/**
+ * @see {usedFunction}
+ */
 ```
 
 ### React
@@ -594,6 +640,43 @@ ErrorBoundaryContext.displayName = "ErrorBoundaryContext";
 export default ErrorBoundaryContext;
 ```
 
+#### `prefer-read-only-props`
+
+Enforce that React component props are typed as `readonly` in TypeScript, preventing accidental mutation of props.
+
+**Features**
+
+- ✨ Has auto-fix
+- Direct AST pattern matching (no global component analysis)
+- Component detection caching
+- Focused on common React component patterns
+
+**❌ Bad**
+
+```typescript
+interface Props {
+  name: string;
+  age: number;
+}
+
+function Component({ name, age }: Props) {
+  // ...
+}
+```
+
+**✅ Good**
+
+```typescript
+interface Props {
+  readonly name: string;
+  readonly age: number;
+}
+
+function Component({ name, age }: Props) {
+  // ...
+}
+```
+
 #### `react-hooks-strict-return`
 
 React hooks must return a tuple of ≤2 elements or a single object. Prevents unwieldy hook return types.
@@ -1001,6 +1084,48 @@ const doubled = items.map((x) => x * 2);
 }
 ```
 
+#### `prevent-abbreviations`
+
+Prevent abbreviations in variable and property names. Provides suggestions for replacements and can automatically fix single-replacement cases.
+
+**Configuration**
+
+```typescript
+{
+  "cease-nonsense/prevent-abbreviations": ["error", {
+    "checkFilenames": true,
+    "checkProperties": false,
+    "checkVariables": true,
+    "replacements": {},
+    "allowList": {},
+    "ignore": []
+  }]
+}
+```
+
+**Features**
+
+- ✨ Has auto-fix (for single replacements)
+- Aggressive caching of word and name replacements
+- Pre-compiled regex patterns
+- Early exits for constants and allow-listed names
+
+**❌ Bad**
+
+```typescript
+const err = new Error();
+const fn = () => {};
+const dist = calculateDistance();
+```
+
+**✅ Good**
+
+```typescript
+const error = new Error();
+const func = () => {};
+const distance = calculateDistance();
+```
+
 #### `no-shorthand-names`
 
 Bans shorthand variable names in favor of descriptive full names.
@@ -1408,6 +1533,48 @@ class MyClass {
 }
 ```
 
+#### `require-module-level-instantiation`
+
+Require certain classes to be instantiated at module level rather than inside functions.
+
+Classes like Log should be instantiated once at module scope, not recreated on every function call.
+
+**Configuration**
+
+```typescript
+{
+  "cease-nonsense/require-module-level-instantiation": ["error", {
+    "classes": {
+      "Log": "@rbxts/rbxts-sleitnick-log",
+      "Server": "@rbxts/net"
+    }
+  }]
+}
+```
+
+**❌ Bad**
+
+```typescript
+import Log from "@rbxts/rbxts-sleitnick-log";
+
+function useStoryModesState() {
+	const log = new Log(); // Recreated on every call!
+	log.Info("Create Match clicked");
+}
+```
+
+**✅ Good**
+
+```typescript
+import Log from "@rbxts/rbxts-sleitnick-log";
+
+const log = new Log(); // Module level - created once
+
+function useStoryModesState() {
+	log.Info("Create Match clicked");
+}
+```
+
 ### Module Boundaries
 
 #### `strict-component-boundaries`
@@ -1450,6 +1617,83 @@ import { Foo } from "./components/Foo";
 
 ### TypeScript
 
+#### `naming-convention`
+
+Enforce naming conventions for TypeScript constructs. Optimized for common use cases like interface prefix checking without requiring type checking.
+
+**Configuration**
+
+```typescript
+{
+  "cease-nonsense/naming-convention": ["error", {
+    "custom": {
+      "match": false,
+      "regex": "^I[A-Z]"
+    },
+    "format": ["PascalCase"],
+    "selector": "interface"
+  }]
+}
+```
+
+**Features**
+
+- No type checking required (fast AST-only analysis)
+- Pre-compiled regex patterns
+- Focused on common use cases
+
+**❌ Bad**
+
+```typescript
+// With custom: { match: false, regex: "^I[A-Z]" }
+interface IUser {
+  name: string;
+}
+```
+
+**✅ Good**
+
+```typescript
+interface User {
+  name: string;
+}
+```
+
+#### `misleading-lua-tuple-checks`
+
+Disallow the use of `LuaTuple` types directly in conditional expressions, which can be misleading. Requires explicit indexing (`[0]`) or array destructuring.
+
+**Features**
+
+- ✨ Has auto-fix
+- Cached type queries per node
+- WeakMap-based caching for `isLuaTuple` checks
+- Cached constrained type lookups
+
+**❌ Bad**
+
+```typescript
+// Direct LuaTuple in conditional
+if (getLuaTuple()) {
+  // ...
+}
+
+// LuaTuple in variable declaration
+const result = getLuaTuple();
+```
+
+**✅ Good**
+
+```typescript
+// Explicit indexing
+if (getLuaTuple()[0]) {
+  // ...
+}
+
+// Array destructuring
+const [result] = getLuaTuple();
+```
+
 #### `prefer-pascal-case-enums`
 
 Enum names and members must be PascalCase.

package/dist/build-metadata.json

@@ -1,5 +1,5 @@
 {
-  "commit": "02202d06fed3e5ad1ec4ef66f32874643bcbaa18",
-  "time": "2026-01-11T20:59:08.304Z",
-  "version": "1.15.0"
+  "commit": "d246a17b975b5254d9495f55653c413b52eccfde",
+  "time": "2026-01-17T10:14:55.964Z",
+  "version": "1.17.1"
 }

package/dist/index.d.ts

@@ -2,20 +2,24 @@ import type { LooseRuleDefinition } from "@typescript-eslint/utils/ts-eslint";
 import type { ReadonlyRecord } from "./types/utility-types.d";
 export type { BanInstancesOptions } from "./rules/ban-instances";
 export type { ComplexityConfiguration } from "./rules/enforce-ianitor-check-type";
+export type { NamingConventionOptions } from "./rules/naming-convention";
 export type { NoGodComponentsOptions } from "./rules/no-god-components";
 export type { NoIdentityMapOptions } from "./rules/no-identity-map";
 export type { NoInstanceMethodsOptions } from "./rules/no-instance-methods-without-this";
 export type { NoMemoChildrenOptions } from "./rules/no-memo-children";
 export type { NoShorthandOptions } from "./rules/no-shorthand-names";
+export type { NoUnusedImportsOptions } from "./rules/no-unused-imports";
 export type { NoUselessUseSpringOptions } from "./rules/no-useless-use-spring";
 export type { PreferEnumItemOptions } from "./rules/prefer-enum-item";
+export type { PreventAbbreviationsOptions } from "./rules/prevent-abbreviations";
+export type { RequireModuleLevelInstantiationOptions } from "./rules/require-module-level-instantiation";
 export type { EffectFunctionOptions, HookConfiguration } from "./rules/require-named-effect-functions";
 export type { PairConfiguration, RequirePairedCallsOptions } from "./rules/require-paired-calls";
 export type { ReactKeysOptions } from "./rules/require-react-component-keys";
 export type { RequireReactDisplayNamesOptions } from "./rules/require-react-display-names";
 export type { HookEntry, UseExhaustiveDependenciesOptions } from "./rules/use-exhaustive-dependencies";
 export type { EnvironmentMode } from "./types/environment-mode";
-export { createBanInstancesOptions, createComplexityConfiguration, createEffectFunctionOptions, createHookConfiguration, createNoGodComponentsOptions, createNoInstanceMethodsOptions, createNoMemoChildrenOptions, createNoShorthandOptions, createNoUselessUseSpringOptions, createPairConfiguration, createPreferPatternReplacementsOptions, createReactKeysOptions, createRequirePairedCallsOptions, createRequireReactDisplayNamesOptions, createUseExhaustiveDependenciesOptions, createUseHookAtTopLevelOptions, defaultRobloxProfilePair, } from "./utilities/configure-utilities";
+export { createBanInstancesOptions, createComplexityConfiguration, createEffectFunctionOptions, createHookConfiguration, createNamingConventionOptions, createNoGodComponentsOptions, createNoInstanceMethodsOptions, createNoMemoChildrenOptions, createNoShorthandOptions, createNoUnusedImportsOptions, createNoUselessUseSpringOptions, createPairConfiguration, createPreferEnumItemOptions, createPreferPatternReplacementsOptions, createPreventAbbreviationsOptions, createReactKeysOptions, createRequireModuleLevelInstantiationOptions, createRequirePairedCallsOptions, createRequireReactDisplayNamesOptions, createUseExhaustiveDependenciesOptions, createUseHookAtTopLevelOptions, defaultRobloxProfilePair, } from "./utilities/configure-utilities";
 export type { Pattern, PreferPatternReplacementsOptions } from "./utilities/pattern-replacement";
 export { pattern } from "./utilities/pattern-replacement";
 /**
@@ -44,6 +48,7 @@ declare const recommended: {
         readonly "cease-nonsense/ban-react-fc": "error";
         readonly "cease-nonsense/enforce-ianitor-check-type": "error";
         readonly "cease-nonsense/fast-format": "error";
+        readonly "cease-nonsense/misleading-lua-tuple-checks": "error";
         readonly "cease-nonsense/no-async-constructor": "error";
         readonly "cease-nonsense/no-color3-constructor": "error";
         readonly "cease-nonsense/no-god-components": "error";
@@ -52,7 +57,9 @@ declare const recommended: {
         readonly "cease-nonsense/no-memo-children": "error";
         readonly "cease-nonsense/no-print": "error";
         readonly "cease-nonsense/no-shorthand-names": "error";
+        readonly "cease-nonsense/no-unused-imports": "error";
         readonly "cease-nonsense/no-warn": "error";
+        readonly "cease-nonsense/prefer-read-only-props": "error";
         readonly "cease-nonsense/prefer-sequence-overloads": "error";
         readonly "cease-nonsense/prefer-udim2-shorthand": "error";
         readonly "cease-nonsense/require-named-effect-functions": "error";