eslint-config-agent 1.1.2 → 1.1.4

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to this project will be documented in this file. See [Conven
 
 
 
+## [1.1.4](https://github.com/tupe12334/eslint-config/compare/v1.1.3...v1.1.4) (2025-09-10)
+
+### Features
+
+* add no-empty-exports rule to prevent empty export specifiers and include test cases ([7757007](https://github.com/tupe12334/eslint-config/commit/77570076e41bdab64dbed53ca7a40a935eda7e3a))
+* enhance export specifier rules and update test configurations for improved validation ([fe64b9c](https://github.com/tupe12334/eslint-config/commit/fe64b9cb7f1bdf80b16a97db75a5fd04901c2e7f))
+* remove package-specific ignores from ESLint config for cleaner configuration ([03cef75](https://github.com/tupe12334/eslint-config/commit/03cef75a6ad6d682ede5f4c5dc5d5e1a8d0a9aaa))
+
+## [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;
@@ -24,21 +19,20 @@ try {
   // eslint-plugin-preact is not available
 }
 
-
 // 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,13 +93,15 @@ const sharedRestrictedSyntax = [
     message:
       "Exporting from external libraries is not allowed. Only re-export from relative paths or scoped packages.",
   },
-  noProcessEnvPropertiesConfig,
+  allRules.noProcessEnvPropertiesConfig,
+  allRules.noExportSpecifiersConfig,
 ];
 
 // Required export rules (always errors)
 const requiredExportRules = [
   {
-    selector: "ClassDeclaration:not(ExportNamedDeclaration > ClassDeclaration):not(ExportDefaultDeclaration > ClassDeclaration)",
+    selector:
+      "ClassDeclaration:not(ExportNamedDeclaration > ClassDeclaration):not(ExportDefaultDeclaration > ClassDeclaration)",
     message:
       "Classes must be exported. Use 'export class' or 'export default class'.",
   },
@@ -148,11 +144,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:
@@ -208,9 +200,6 @@ const config = [
     },
   },
   reactHooks.configs["recommended-latest"],
-  {
-    ignores: ["packages/auth-service-sdk/**"],
-  },
   js.configs.recommended,
 
   // TypeScript and TSX files
@@ -221,10 +210,6 @@ const config = [
       "**/dist/**",
       "**/build/**",
       "pnpm-lock.yaml",
-      "packages/auth-service-sdk/**",
-      "packages/auth-service-sdk/src/core/**",
-      "packages/auth-service-sdk/src/client/**",
-      "packages/auth-service-sdk/src/*.gen.ts",
       "**/*.stories.{js,jsx,ts,tsx}",
     ],
     languageOptions: {
@@ -257,7 +242,7 @@ const config = [
     },
     rules: {
       ...sharedRules,
-      ...typescriptEslintRules,
+      ...allRules.typescriptEslintRules,
       "no-undef": "off", // TypeScript handles this
       "no-restricted-syntax": [
         "error",
@@ -434,11 +419,11 @@ const config = [
       "**/dist/**",
       "**/build/**",
       "pnpm-lock.yaml",
-      "packages/auth-service-sdk/**",
       "**/*.umd.js",
       "**/*.cjs",
       "**/*.mjs",
       "**/*.stories.{js,jsx,ts,tsx}",
+      "**/rules/**",
     ],
     languageOptions: {
       parserOptions: {
@@ -504,7 +489,6 @@ const config = [
       "**/dist/**",
       "**/build/**",
       "pnpm-lock.yaml",
-      "packages/auth-service-sdk/**",
       "**/*.stories.{js,jsx,ts,tsx}",
     ],
     languageOptions: {
@@ -624,7 +608,6 @@ const config = [
       "**/dist/**",
       "**/build/**",
       "pnpm-lock.yaml",
-      "packages/auth-service-sdk/**",
       "**/*.stories.{js,jsx,ts,tsx}",
     ],
     languageOptions: {
@@ -725,7 +708,33 @@ const config = [
             rule.selector !==
               "ExportNamedDeclaration[specifiers.length>1]:not([source])" &&
             rule.selector !==
-              "Program:has(ExportNamedDeclaration:not([source]) ~ ExportNamedDeclaration:not([source]))"
+              "Program:has(ExportNamedDeclaration:not([source]) ~ ExportNamedDeclaration:not([source]))" &&
+            rule.selector !==
+              "ExportNamedDeclaration:not([source]):not(:has(VariableDeclaration)):not(:has(FunctionDeclaration)):not(:has(ClassDeclaration)):not(:has(TSInterfaceDeclaration)):not(:has(TSTypeAliasDeclaration)):not(:has(TSEnumDeclaration))"
+        ),
+        ...tsOnlyRestrictedSyntax,
+      ],
+    },
+  },
+
+  // Test files that should have ERROR level rules but exclude export specifier rule
+  {
+    files: [
+      "**/test/type-assertions/**",
+      "**/test/test-optional.ts",
+      "**/test/test-js-optional.js",
+      "**/test/test-record-literals.ts",
+      "**/test/no-env-access-test.ts",
+      "**/test/import-export-rules.ts",
+    ],
+    rules: {
+      "max-lines-per-function": "off",
+      "no-restricted-syntax": [
+        "error", // Error level for these test files
+        ...sharedRestrictedSyntax.filter(
+          (rule) =>
+            rule.selector !==
+            "ExportNamedDeclaration:not([source]):not(:has(VariableDeclaration)):not(:has(FunctionDeclaration)):not(:has(ClassDeclaration)):not(:has(TSInterfaceDeclaration)):not(:has(TSTypeAliasDeclaration)):not(:has(TSEnumDeclaration))"
         ),
         ...tsOnlyRestrictedSyntax,
       ],
@@ -736,6 +745,9 @@ const config = [
   {
     files: [
       "**/test/invalid.tsx", // Special handling for the main test file
+      "**/test/single-export-valid.ts", // Allow export specifiers for import/group-exports testing
+      "**/test/typescript-rules.ts", // Allow export specifiers for typescript rules testing
+      "**/test/type-assertions/indexed-access-valid.ts", // Allow export specifiers for type assertions testing
     ],
     rules: {
       "max-lines-per-function": "off",
@@ -746,7 +758,9 @@ const config = [
             rule.selector !==
               "ExportNamedDeclaration[specifiers.length>1]:not([source])" &&
             rule.selector !==
-              "Program:has(ExportNamedDeclaration:not([source]) ~ ExportNamedDeclaration:not([source]))"
+              "Program:has(ExportNamedDeclaration:not([source]) ~ ExportNamedDeclaration:not([source]))" &&
+            rule.selector !==
+              "ExportNamedDeclaration:not([source]):not(:has(VariableDeclaration)):not(:has(FunctionDeclaration)):not(:has(ClassDeclaration)):not(:has(TSInterfaceDeclaration)):not(:has(TSTypeAliasDeclaration)):not(:has(TSEnumDeclaration))"
         ),
         ...tsOnlyRestrictedSyntax,
         // For TSX files, also include required export rules as warnings since we can't mix severities
@@ -786,7 +800,13 @@ const config = [
   // Switch case rules as errors for all TypeScript/JSX files (must come last to override)
   {
     files: ["**/*.{ts,tsx,js,jsx}"],
-    ignores: ["**/*.stories.{js,jsx,ts,tsx}"],
+    ignores: [
+      "**/*.stories.{js,jsx,ts,tsx}",
+      "**/test/**",
+      "!**/test/export/**",
+      "!**/test/required-exports/**",
+      "**/rules/**",
+    ],
     rules: {
       "no-restricted-syntax": [
         "error",
@@ -867,7 +887,9 @@ 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,
+        allRules.noExportSpecifiersConfig,
         // Export restriction rules
         // Required export rules
         ...requiredExportRules,
@@ -897,9 +919,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,
     },
   },
 
@@ -954,6 +976,27 @@ const config = [
       ...storybookPlugin.configs.recommended.rules,
     },
   },
+
+  // Rules directory configuration - allow export specifiers for API definitions
+  {
+    files: ["**/rules/**/*.{js,ts}"],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+    },
+    rules: {
+      "no-restricted-syntax": [
+        "error",
+        // Include all shared rules EXCEPT our export specifier rule
+        ...sharedRestrictedSyntax.filter(
+          (rule) =>
+            rule.selector !==
+            "ExportNamedDeclaration:not([source]):not(:has(VariableDeclaration)):not(:has(FunctionDeclaration)):not(:has(ClassDeclaration)):not(:has(TSInterfaceDeclaration)):not(:has(TSTypeAliasDeclaration)):not(:has(TSEnumDeclaration))"
+        ),
+      ],
+    },
+  },
 ];
 
 export default config;

package/package.json

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

package/rules/index.js

@@ -0,0 +1,60 @@
+/**
+ * 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";
+import { noExportSpecifiersConfig } from "./no-empty-exports/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,
+  noExportSpecifiersConfig,
+
+  // 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,
+  noExportSpecifiersConfig,
+
+  // Plugin rule configurations
+  pluginRules,
+  typescriptEslintRules,
+};

package/rules/no-empty-exports/examples/invalid/empty-export.js

@@ -0,0 +1,2 @@
+// Invalid: Empty export specifiers
+export { };

package/rules/no-empty-exports/examples/invalid/multiple-exports.js

@@ -0,0 +1,5 @@
+// Invalid: Export specifiers with multiple items
+const foo = 1;
+const bar = 2;
+const baz = 3;
+export { foo, bar, baz };

package/rules/no-empty-exports/examples/invalid/single-export.js

@@ -0,0 +1,3 @@
+// Invalid: Export specifiers with single item
+const bar = 2;
+export { bar };

package/rules/no-empty-exports/examples/valid/default-export.js

@@ -0,0 +1,3 @@
+// Valid: Default export
+const something = { value: 42 };
+export default something;

package/rules/no-empty-exports/examples/valid/direct-class.js

@@ -0,0 +1,6 @@
+// Valid: Direct class export
+export class Baz {
+  constructor() {
+    this.value = 42;
+  }
+}

package/rules/no-empty-exports/examples/valid/direct-const.js

@@ -0,0 +1,2 @@
+// Valid: Direct const export
+export const foo = 1;

package/rules/no-empty-exports/examples/valid/direct-function.js

@@ -0,0 +1,4 @@
+// Valid: Direct function export
+export function bar() {
+  return 'hello';
+}

package/rules/no-empty-exports/examples/valid/re-export-from.js

@@ -0,0 +1,2 @@
+// Valid: Re-export from other module
+export { something } from './other-file';

package/rules/no-empty-exports/examples/valid/re-export-star.js

@@ -0,0 +1,2 @@
+// Valid: Re-export all from other module
+export * from './other-file';

package/rules/no-empty-exports/index.js

@@ -0,0 +1,16 @@
+// Rule to prevent export { } statements of any length
+
+const selector = 'ExportNamedDeclaration:not([source]):not(:has(VariableDeclaration)):not(:has(FunctionDeclaration)):not(:has(ClassDeclaration)):not(:has(TSInterfaceDeclaration)):not(:has(TSTypeAliasDeclaration)):not(:has(TSEnumDeclaration))';
+const message = 'Export specifier syntax "export { ... }" is not allowed. Use direct exports instead.';
+
+const rule = {
+  selector,
+  message,
+};
+
+const noExportSpecifiersConfig = {
+  selector,
+  message,
+};
+
+export { rule, selector, message, noExportSpecifiersConfig };

package/rules/no-empty-exports/no-empty-exports.spec.js

@@ -0,0 +1,104 @@
+import { RuleTester } from "eslint";
+import { selector, message } from "./index.js";
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    ecmaVersion: 2022,
+    sourceType: "module",
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true,
+      },
+    },
+  },
+});
+
+// Create a mock rule for testing
+const mockRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow empty export statements",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      [selector]: (node) => {
+        context.report({
+          node,
+          message,
+        });
+      },
+    };
+  },
+};
+
+ruleTester.run("no-empty-exports", mockRule, {
+  valid: [
+    // Named exports with declarations
+    'export const foo = 1;',
+    'export function bar() {}',
+    'export class Baz {}',
+
+    // Default exports
+    'const foo = 1; export default foo;',
+    'export default function() {}',
+    'export default class {}',
+
+    // Re-exports from other modules (allowed)
+    'export { } from "./other";',
+    'export { foo } from "./other";',
+    'export * from "./other";',
+    'export * as namespace from "./other";',
+
+    // Regular exports
+    'const Bar = {}; export { Bar };',
+
+    // No exports at all
+    'const foo = 1;',
+    'function bar() {}',
+    'class Baz {}',
+
+    // Named exports with local variables
+    'const foo = 1; const bar = 2; export { foo };',
+    'const foo = 1; const bar = 2; export { foo, bar };',
+    'const foo = 1; export { foo as bar };',
+  ],
+  invalid: [
+    {
+      code: 'export { };',
+      errors: [{ message }],
+    },
+    {
+      code: 'export {\n};',
+      errors: [{ message }],
+    },
+    {
+      code: 'export {  };',
+      errors: [{ message }],
+    },
+    {
+      code: `export {
+      };`,
+      errors: [{ message }],
+    },
+    {
+      code: 'export { /* comment */ };',
+      errors: [{ message }],
+    },
+    // Multiple empty exports
+    {
+      code: `export { };
+export { };`,
+      errors: [{ message }, { message }],
+    },
+    // Mixed with valid exports
+    {
+      code: `export const foo = 1;
+export { };
+export function bar() {}`,
+      errors: [{ message }],
+    },
+  ],
+});

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",
 };