eslint-config-agent 1.1.2 → 1.1.3

package/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file. See [Conven
 
 
 
+## [1.1.3](https://github.com/tupe12334/eslint-config/compare/v1.1.2...v1.1.3) (2025-09-10)
+
+### Features
+
+* add no-type-assertions rule to disallow TypeScript type assertions using "as" keyword ([39b708f](https://github.com/tupe12334/eslint-config/commit/39b708f9da6eb0c491b0e53248af78821f4b3598))
+* consolidate ESLint rule imports into a single index file for better organization ([37be460](https://github.com/tupe12334/eslint-config/commit/37be46083350d151a5803b9c230c538caa9eb857))
+* refactor ESLint rule imports to use a consolidated allRules object for improved organization ([47c3eea](https://github.com/tupe12334/eslint-config/commit/47c3eea5f02dd204bf86ab6150d319eed07440da))
+
 ## [1.1.2](https://github.com/tupe12334/eslint-config/compare/v1.1.1...v1.1.2) (2025-09-10)
 
 ### Features

package/index.js

@@ -9,12 +9,7 @@ import nPlugin from "eslint-plugin-n";
 import classExportPlugin from "eslint-plugin-class-export";
 import storybookPlugin from "eslint-plugin-storybook";
 import globals from "globals";
-import noTrailingSpacesConfig from "./rules/no-trailing-spaces/index.js";
-import { maxFunctionLinesWarning, maxFunctionLinesError } from "./rules/max-function-lines/index.js";
-import { maxFileLinesWarning, maxFileLinesError } from "./rules/max-file-lines/index.js";
-import { pluginRules } from "./rules/plugin/index.js";
-import { typescriptEslintRules } from "./rules/plugin/typescript-eslint/index.js";
-import { noProcessEnvPropertiesConfig } from "./rules/no-process-env-properties/index.js";
+import allRules from "./rules/index.js";
 
 // Conditionally import preact plugin if available
 let preactPlugin = null;
@@ -27,18 +22,18 @@ try {
 
 // Shared rules for both JS and TS files
 const sharedRules = {
-  ...pluginRules,
+  ...allRules.pluginRules,
   "object-curly-newline": "off",
   "no-shadow": "off",
   "comma-dangle": "off",
   "function-paren-newline": "off",
   quotes: "off",
   "no-unused-vars": "off",
-  "max-lines-per-function": maxFunctionLinesWarning,
-  "max-lines": maxFileLinesWarning,
+  "max-lines-per-function": allRules.maxFunctionLinesWarning,
+  "max-lines": allRules.maxFileLinesWarning,
   semi: "off",
   complexity: "off",
-  "no-trailing-spaces": noTrailingSpacesConfig,
+  "no-trailing-spaces": allRules.noTrailingSpacesConfig,
   "operator-linebreak": "off",
   "implicit-arrow-linebreak": "off",
   "arrow-body-style": "off",
@@ -99,7 +94,7 @@ const sharedRestrictedSyntax = [
     message:
       "Exporting from external libraries is not allowed. Only re-export from relative paths or scoped packages.",
   },
-  noProcessEnvPropertiesConfig,
+  allRules.noProcessEnvPropertiesConfig,
 ];
 
 // Required export rules (always errors)
@@ -148,11 +143,7 @@ const tsOnlyRestrictedSyntax = [
     message:
       "Class properties with literal unions should use a named type declaration.",
   },
-  {
-    selector:
-      'TSAsExpression:not(:has(TSTypeReference[typeName.name="const"]))',
-    message: 'Type assertions with "as" are not allowed except for "as const".',
-  },
+  allRules.noTypeAssertionsConfig,
   {
     selector: "TSAsExpression:has(> TSIndexedAccessType > TSTypeQuery)",
     message:
@@ -257,7 +248,7 @@ const config = [
     },
     rules: {
       ...sharedRules,
-      ...typescriptEslintRules,
+      ...allRules.typescriptEslintRules,
       "no-undef": "off", // TypeScript handles this
       "no-restricted-syntax": [
         "error",
@@ -867,7 +858,8 @@ const config = [
           message:
             'Type assertions with indexed access types like "as (typeof X)[number]" are not allowed. Use a named type instead.',
         },
-        noProcessEnvPropertiesConfig,
+        allRules.noTypeAssertionsConfig,
+        allRules.noProcessEnvPropertiesConfig,
         // Export restriction rules
         // Required export rules
         ...requiredExportRules,
@@ -897,9 +889,9 @@ const config = [
     ignores: ["**/*.stories.{js,jsx,ts,tsx}"],
     rules: {
       // Function length: error at 70+ lines
-      "max-lines-per-function": maxFunctionLinesError,
+      "max-lines-per-function": allRules.maxFunctionLinesError,
       // File length: error at 100+ lines
-      "max-lines": maxFileLinesError,
+      "max-lines": allRules.maxFileLinesError,
     },
   },
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-agent",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "ESLint configuration package with TypeScript support",
   "main": "index.js",
   "type": "module",

package/rules/index.js

@@ -0,0 +1,57 @@
+/**
+ * Aggregated exports for all custom ESLint rules
+ *
+ * This file centralizes imports from all rule modules in the rules/ directory
+ * and re-exports them for easier consumption by the main configuration.
+ */
+
+// Core rule configurations
+import noTrailingSpacesConfig from "./no-trailing-spaces/index.js";
+import { maxFunctionLinesWarning, maxFunctionLinesError } from "./max-function-lines/index.js";
+import { maxFileLinesWarning, maxFileLinesError } from "./max-file-lines/index.js";
+
+// Custom restricted syntax rules
+import { noProcessEnvPropertiesConfig } from "./no-process-env-properties/index.js";
+import { noTypeAssertionsConfig } from "./no-type-assertions/index.js";
+
+// Plugin rule configurations
+import { pluginRules } from "./plugin/index.js";
+import { typescriptEslintRules } from "./plugin/typescript-eslint/index.js";
+
+// Consolidated exports
+const allRules = {
+  // Core rule configurations
+  noTrailingSpacesConfig,
+  maxFunctionLinesWarning,
+  maxFunctionLinesError,
+  maxFileLinesWarning,
+  maxFileLinesError,
+
+  // Custom restricted syntax rules
+  noProcessEnvPropertiesConfig,
+  noTypeAssertionsConfig,
+
+  // Plugin rule configurations
+  pluginRules,
+  typescriptEslintRules,
+};
+
+export default allRules;
+
+// Named exports for backward compatibility
+export {
+  // Core rule configurations
+  noTrailingSpacesConfig,
+  maxFunctionLinesWarning,
+  maxFunctionLinesError,
+  maxFileLinesWarning,
+  maxFileLinesError,
+
+  // Custom restricted syntax rules
+  noProcessEnvPropertiesConfig,
+  noTypeAssertionsConfig,
+
+  // Plugin rule configurations
+  pluginRules,
+  typescriptEslintRules,
+};

package/rules/no-type-assertions/index.js

@@ -0,0 +1,38 @@
+/**
+ * Rule configuration for no-type-assertions
+ *
+ * This rule disallows TypeScript type assertions using the "as" keyword,
+ * except for "as const" which is allowed for creating readonly literal types.
+ *
+ * Examples:
+ * - ❌ value as string
+ * - ❌ value as User
+ * - ❌ obj as { name: string }
+ * - ✅ { mode: 'prod' } as const
+ * - ✅ ['a', 'b'] as const
+ *
+ * @see https://eslint.org/docs/latest/rules/no-restricted-syntax
+ */
+
+const rule = "error";
+
+const selector =
+  'TSAsExpression:not(:has(TSTypeReference[typeName.name="const"]))';
+
+const message =
+  'Type assertions with "as" are not allowed except for "as const".';
+
+/**
+ * Export the complete rule configuration for no-restricted-syntax
+ * Can be used in ESLint config as part of no-restricted-syntax rules:
+ * "no-restricted-syntax": ["error", ...otherRules, noTypeAssertionsConfig]
+ */
+const noTypeAssertionsConfig = {
+  selector,
+  message,
+};
+
+// Consolidated exports
+export { rule, selector, message, noTypeAssertionsConfig };
+
+export default noTypeAssertionsConfig;

package/rules/no-type-assertions/no-type-assertions.spec.js

@@ -0,0 +1,246 @@
+import { RuleTester } from "eslint";
+import { noTypeAssertionsConfig } from "./index.js";
+
+/**
+ * Test suite for no-type-assertions rule
+ *
+ * This tests the no-restricted-syntax configuration that prevents
+ * TypeScript type assertions using "as" keyword except for "as const".
+ */
+
+// Create a custom rule for testing our selector
+const noTypeAssertionsRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow type assertions except 'as const'",
+    },
+    messages: {
+      noTypeAssertions: noTypeAssertionsConfig.message,
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      [noTypeAssertionsConfig.selector](node) {
+        context.report({
+          node,
+          messageId: "noTypeAssertions",
+        });
+      },
+    };
+  },
+};
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    ecmaVersion: 2022,
+    sourceType: "module",
+    parser: (await import("@typescript-eslint/parser")).default,
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true,
+      },
+    },
+  },
+});
+
+ruleTester.run("no-type-assertions", noTypeAssertionsRule, {
+  valid: [
+    // Valid: "as const" usage
+    {
+      code: "const config = { mode: 'production' } as const;",
+      name: "object as const",
+    },
+    {
+      code: "const colors = ['red', 'green', 'blue'] as const;",
+      name: "array as const",
+    },
+    {
+      code: "const status = 'loading' as const;",
+      name: "string literal as const",
+    },
+    {
+      code: "const numbers = [1, 2, 3] as const;",
+      name: "number array as const",
+    },
+    {
+      code: "const tuple = ['name', 42, true] as const;",
+      name: "mixed tuple as const",
+    },
+    {
+      code: "const nested = { items: [{ id: 1 }] as const } as const;",
+      name: "nested as const",
+    },
+
+    // Valid: No type assertions at all
+    {
+      code: "const value: string = 'hello';",
+      name: "type annotation instead of assertion",
+    },
+    {
+      code: "function getValue(): string { return 'test'; }",
+      name: "function with return type",
+    },
+    {
+      code: "interface User { name: string; } const user: User = { name: 'John' };",
+      name: "interface with proper typing",
+    },
+    {
+      code: "const element = document.getElementById('test');",
+      name: "no type assertion on DOM access",
+    },
+  ],
+
+  invalid: [
+    // Invalid: Basic type assertions
+    {
+      code: "declare const value: unknown; const str = value as string;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "basic string assertion",
+    },
+    {
+      code: "declare const value: unknown; const num = value as number;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "basic number assertion",
+    },
+    {
+      code: "declare const value: unknown; const bool = value as boolean;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "basic boolean assertion",
+    },
+
+    // Invalid: Interface and type assertions
+    {
+      code: "interface User { name: string; } declare const value: unknown; const user = value as User;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "interface assertion",
+    },
+    {
+      code: "type Status = 'loading' | 'success'; declare const value: unknown; const status = value as Status;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "type alias assertion",
+    },
+
+    // Invalid: DOM element assertions
+    {
+      code: "const element = document.getElementById('test') as HTMLInputElement;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "DOM element assertion",
+    },
+    {
+      code: "const button = document.querySelector('.btn') as HTMLButtonElement;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "DOM querySelector assertion",
+    },
+
+    // Invalid: Object and array assertions
+    {
+      code: "declare const data: unknown; const obj = data as { name: string };",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "object literal type assertion",
+    },
+    {
+      code: "declare const data: unknown; const arr = data as string[];",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "array type assertion",
+    },
+    {
+      code: "declare const data: unknown; const tuple = data as [string, number];",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "tuple type assertion",
+    },
+
+    // Invalid: Function parameter and return assertions
+    {
+      code: "function test(param: unknown) { return param as string; }",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "return value assertion",
+    },
+    {
+      code: "const fn = (value: unknown) => value as number;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "arrow function assertion",
+    },
+
+    // Invalid: Complex expressions
+    {
+      code: "declare const api: any; const result = api.getData() as Promise<User>;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "method call assertion",
+    },
+    {
+      code: "declare const obj: any; const prop = obj.property as string;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "property access assertion",
+    },
+    {
+      code: "declare const arr: any[]; const first = arr[0] as string;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "array access assertion",
+    },
+
+    // Invalid: Generic type assertions
+    {
+      code: "declare const value: unknown; const generic = value as Array<string>;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "generic type assertion",
+    },
+    {
+      code: "declare const value: unknown; const promise = value as Promise<number>;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "Promise generic assertion",
+    },
+
+    // Invalid: Any type assertions
+    {
+      code: "declare const value: unknown; const anything = value as any;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "any type assertion",
+    },
+
+    // Invalid: Chained assertions
+    {
+      code: "declare const value: unknown; const result = (value as any).prop as string;",
+      errors: [
+        { messageId: "noTypeAssertions" },
+        { messageId: "noTypeAssertions" }
+      ],
+      name: "chained assertions",
+    },
+
+    // Invalid: Template literal expressions
+    {
+      code: "declare const id: unknown; const message = `User ID: ${id as string}`;",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "assertion in template literal",
+    },
+
+    // Invalid: Conditional expressions
+    {
+      code: "declare const value: unknown; const result = value ? value as string : 'default';",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "assertion in conditional",
+    },
+
+    // Invalid: Object property values
+    {
+      code: "declare const name: unknown; const user = { name: name as string, age: 30 };",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "assertion in object property",
+    },
+
+    // Invalid: Array elements
+    {
+      code: "declare const item: unknown; const items = [item as string, 'other'];",
+      errors: [{ messageId: "noTypeAssertions" }],
+      name: "assertion in array element",
+    },
+  ],
+});
+
+console.log("✅ All no-type-assertions tests passed!");
+console.log(`   Selector: ${noTypeAssertionsConfig.selector}`);
+console.log(`   Message: ${noTypeAssertionsConfig.message}`);
+
+export { noTypeAssertionsRule };

package/rules/plugin/typescript-eslint/index.js

@@ -1,10 +1,4 @@
 export const typescriptEslintRules = {
   "@typescript-eslint/no-explicit-any": "error",
-  "@typescript-eslint/consistent-type-assertions": [
-    "error",
-    {
-      assertionStyle: "as",
-      objectLiteralTypeAssertions: "allow-as-parameter",
-    },
-  ],
+  "@typescript-eslint/consistent-type-assertions": "off",
 };