eslint-config-agent 1.3.7 → 1.3.9

package/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to this project will be documented in this file. See [Conven
 
 
 
+## [1.3.9](https://github.com/tupe12334/eslint-config/compare/v1.3.8...v1.3.9) (2025-09-27)
+
+### Bug Fixes
+
+* update eslint-plugin-error to version 1.1.3 for improved stability ([4fc6a2f](https://github.com/tupe12334/eslint-config/commit/4fc6a2f688ea195d5e2038222449993fce4a7dc7))
+
+## [1.3.8](https://github.com/tupe12334/eslint-config/compare/v1.3.7...v1.3.8) (2025-09-27)
+
+### Features
+
+* add eslint-plugin-default for enhanced linting rules; configure default plugin strict settings ([70d3ac6](https://github.com/tupe12334/eslint-config/commit/70d3ac6f7ab6666eb7652840cf8eb6b68de74df7))
+* add test files configuration and refactor index.js to import shared rules ([28d3799](https://github.com/tupe12334/eslint-config/commit/28d3799edbc7d4726027adbbdc597746579e516e))
+* add TODO.md with function export and translation function guidelines ([94bfd21](https://github.com/tupe12334/eslint-config/commit/94bfd2167b29480cf7f3d2bb11120756239b0ee7))
+* implement no-nullish-coalescing rule with examples and tests ([838196f](https://github.com/tupe12334/eslint-config/commit/838196f500125d09e92f9fa0d7f6bb65280a2f3b))
+* implement no-record-literal-types rule to enforce type safety; add examples and tests ([3308ccb](https://github.com/tupe12334/eslint-config/commit/3308ccb59ba4e9d05725e2f810453df454c63ba5))
+* include configs directory in package.json files list ([3bce2b4](https://github.com/tupe12334/eslint-config/commit/3bce2b41440a7330816603918bf74dfea3900b2b))
+* refine .npmignore and package.json to better manage test and example files in rules directory ([9ed652b](https://github.com/tupe12334/eslint-config/commit/9ed652bae2410faa4428dab583e3494abf9cc5bc))
+* update .npmignore to include examples and test files in rules directory ([d1bb23d](https://github.com/tupe12334/eslint-config/commit/d1bb23df50c623ada2bc2805f7638f9398f2ba64))
+* update no-empty-exports tests for consistency and clarity; enhance test-runner to scan for spec files ([25a7d26](https://github.com/tupe12334/eslint-config/commit/25a7d2660cc992e9031e0577197bfb57faf2c570))
+
 ## [1.3.7](https://github.com/tupe12334/eslint-config/compare/v1.3.6...v1.3.7) (2025-09-24)
 
 ### Features

package/configs/test-files.js

@@ -0,0 +1,248 @@
+import allRules from "../rules/index.js";
+import { noRecordLiteralTypesConfigs } from "../rules/no-record-literal-types/index.js";
+
+// Shared rules for both JS and TS files
+const sharedRules = {
+  ...allRules.pluginRules,
+  "object-curly-newline": "off",
+  "no-shadow": "off",
+  "comma-dangle": "off",
+  "function-paren-newline": "off",
+  quotes: "off",
+  "no-unused-vars": "off",
+  "@typescript-eslint/no-unused-vars": "off",
+  "max-lines-per-function": allRules.maxFunctionLinesWarning,
+  "max-lines": allRules.maxFileLinesWarning,
+  semi: "off",
+  complexity: "off",
+  "no-trailing-spaces": allRules.noTrailingSpacesConfig,
+  "operator-linebreak": "off",
+  "implicit-arrow-linebreak": "off",
+  "arrow-body-style": "off",
+  "no-continue": "off",
+  // Additional built-in error handling rules
+  "prefer-promise-reject-errors": "error",
+};
+
+// Shared no-restricted-syntax rules for both JS and TS
+const sharedRestrictedSyntax = [
+  {
+    selector: "MemberExpression[optional=true]",
+    message: "Optional chaining is not allowed.",
+  },
+  {
+    selector: "CallExpression[optional=true]",
+    message: "Optional chaining is not allowed.",
+  },
+  allRules.noNullishCoalescingConfig,
+  {
+    selector:
+      "ExportNamedDeclaration[exportKind=type]:not([source]):has(ExportSpecifier)",
+    message:
+      "Type-only exports are not allowed. Use regular export or re-export with 'from' clause.",
+  },
+  {
+    selector: "ExportSpecifier[local.name=default][exported.name!=default]",
+    message:
+      "Re-exporting default as named export is not allowed. Use explicit export declaration instead.",
+  },
+  {
+    selector:
+      "Program:has(ImportDeclaration) ExportNamedDeclaration:has(VariableDeclaration > VariableDeclarator[init.type=Identifier]):not(:has(ClassDeclaration))",
+    message:
+      "Exporting imported variables is not allowed. Use direct re-export with 'from' clause or define new values.",
+  },
+  {
+    selector: "SwitchStatement > SwitchCase > ReturnStatement[argument=null]",
+    message:
+      "Switch case functions must provide an explicit return value. Default return values are not allowed.",
+  },
+  {
+    selector:
+      "SwitchStatement > SwitchCase > BlockStatement > ReturnStatement[argument=null]",
+    message:
+      "Switch case functions must provide an explicit return value. Default return values are not allowed.",
+  },
+  {
+    selector: "SwitchStatement > SwitchCase[test=null]",
+    message:
+      "Default cases are not allowed in switch statements. Handle all possible cases explicitly.",
+  },
+  {
+    selector:
+      "ExportNamedDeclaration[source.value=/^[a-z]/]:not([source.value=/^@/])",
+    message:
+      "Exporting from external libraries is not allowed. Only re-export from relative paths or scoped packages.",
+  },
+  allRules.noProcessEnvPropertiesConfig,
+  allRules.noExportSpecifiersConfig,
+  ...allRules.noDefaultClassExportRules,
+];
+
+// TypeScript-specific no-restricted-syntax rules
+const tsOnlyRestrictedSyntax = [
+  ...noRecordLiteralTypesConfigs,
+  {
+    selector:
+      "TSTypeAnnotation > TSUnionType:not(PropertyDefinition > .typeAnnotation > .typeAnnotation):not(TSPropertySignature > .typeAnnotation > .typeAnnotation)",
+    message: "Use a named type declaration instead of inline union types.",
+  },
+  {
+    selector:
+      "TSPropertySignature > TSTypeAnnotation > TSUnionType:has(TSLiteralType)",
+    message:
+      "Interface properties with literal unions should use a named type declaration.",
+  },
+  {
+    selector:
+      "PropertyDefinition > TSTypeAnnotation > TSUnionType:has(TSLiteralType)",
+    message:
+      "Class properties with literal unions should use a named type declaration.",
+  },
+  allRules.noTypeAssertionsConfig,
+  allRules.noClassPropertyDefaultsConfig,
+  {
+    selector: "TSAsExpression:has(> TSIndexedAccessType > TSTypeQuery)",
+    message:
+      'Type assertions with indexed access types like "as (typeof X)[number]" are not allowed. Use a named type instead.',
+  },
+  {
+    selector:
+      "SwitchStatement > SwitchCase ArrowFunctionExpression:not([returnType])",
+    message:
+      "Switch case arrow functions must have explicit return type annotations.",
+  },
+  {
+    selector:
+      "SwitchStatement > SwitchCase FunctionExpression:not([returnType])",
+    message:
+      "Switch case function expressions must have explicit return type annotations.",
+  },
+  {
+    selector:
+      "SwitchStatement > SwitchCase > BlockStatement ArrowFunctionExpression:not([returnType])",
+    message:
+      "Switch case arrow functions must have explicit return type annotations.",
+  },
+  {
+    selector:
+      "SwitchStatement > SwitchCase > BlockStatement FunctionExpression:not([returnType])",
+    message:
+      "Switch case function expressions must have explicit return type annotations.",
+  },
+  {
+    selector: "FunctionDeclaration:has(SwitchStatement):not([returnType])",
+    message:
+      "Functions containing switch statements must have explicit return type annotations.",
+  },
+  {
+    selector: "ArrowFunctionExpression:has(SwitchStatement):not([returnType])",
+    message:
+      "Arrow functions containing switch statements must have explicit return type annotations.",
+  },
+  {
+    selector: "FunctionExpression:has(SwitchStatement):not([returnType])",
+    message:
+      "Function expressions containing switch statements must have explicit return type annotations.",
+  },
+];
+
+// Test and spec files configuration
+export const testFilesConfig = [
+  // Disable function and file size limits for test and spec files
+  {
+    files: [
+      "**/*.test.{js,jsx,ts,tsx}",
+      "**/*.spec.{js,jsx,ts,tsx}",
+      "**/test/**/*.{js,jsx,ts,tsx}",
+      "**/tests/**/*.{js,jsx,ts,tsx}",
+      "**/__tests__/**/*.{js,jsx,ts,tsx}",
+    ],
+    ignores: [
+      "**/long-function-test.tsx", // Exception: this file tests the max-lines rule itself
+      "**/test/export/**", // Export tests should follow strict export rules
+      "**/test/required-exports/**", // Required export tests should follow strict export rules
+    ],
+    rules: {
+      "max-lines-per-function": "off",
+      "max-lines": "off", // Ignore file length limits in test and spec files
+      // Allow multiple exports in test files for testing import/export patterns
+      "no-restricted-syntax": [
+        "warn",
+        ...sharedRestrictedSyntax.filter(
+          (rule) =>
+            rule.selector !==
+              "ExportNamedDeclaration[specifiers.length>1]:not([source])" &&
+            rule.selector !==
+              "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,
+      ],
+    },
+  },
+
+  // Test files configuration with mixed severity levels
+  {
+    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",
+      "no-restricted-syntax": [
+        "warn", // Base level for most rules
+        ...sharedRestrictedSyntax.filter(
+          (rule) =>
+            rule.selector !==
+              "ExportNamedDeclaration[specifiers.length>1]:not([source])" &&
+            rule.selector !==
+              "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,
+      ],
+    },
+  },
+
+  // Disable file length rules for configuration and spec files
+  {
+    files: [
+      "index.js", // Main configuration file
+      "**/rules/**/*.spec.js", // Spec files in rules directory
+      "**/scripts/**/*.js", // Script files
+    ],
+    rules: {
+      "max-lines": "off",
+      "max-lines-per-function": "off",
+    },
+  },
+];

package/index.js

@@ -12,7 +12,10 @@ import storybookPlugin from "eslint-plugin-storybook";
 import globals from "globals";
 import allRules from "./rules/index.js";
 import { noDefaultClassExportRule } from "./rules/no-default-class-export/index.js";
+import { noRecordLiteralTypesConfigs } from "./rules/no-record-literal-types/index.js";
 import errorPlugin from "eslint-plugin-error";
+import defaultPlugin from "eslint-plugin-default";
+import { testFilesConfig } from "./configs/test-files.js";
 
 // Conditionally import preact plugin if available
 let preactPlugin = null;
@@ -55,11 +58,7 @@ const sharedRestrictedSyntax = [
     selector: "CallExpression[optional=true]",
     message: "Optional chaining is not allowed.",
   },
-  {
-    selector: 'LogicalExpression[operator="??"]',
-    message:
-      "Nullish coalescing operator (??) is not allowed. Use explicit null/undefined checks instead.",
-  },
+  allRules.noNullishCoalescingConfig,
   {
     selector:
       "ExportNamedDeclaration[exportKind=type]:not([source]):has(ExportSpecifier)",
@@ -106,18 +105,7 @@ const sharedRestrictedSyntax = [
 
 // TypeScript-specific no-restricted-syntax rules
 const tsOnlyRestrictedSyntax = [
-  {
-    selector:
-      'TSTypeReference[typeName.name="Record"] > TSTypeParameterInstantiation > .params:first-child TSLiteralType',
-    message:
-      "Avoid using Record with string literal keys. Use a more specific interface or type instead.",
-  },
-  {
-    selector:
-      'TSTypeReference[typeName.name="Record"] > TSTypeParameterInstantiation > TSLiteralType:first-child',
-    message:
-      "Avoid using Record with string literal keys. Use a more specific interface or type instead.",
-  },
+  ...noRecordLiteralTypesConfigs,
   {
     selector:
       "TSTypeAnnotation > TSUnionType:not(PropertyDefinition > .typeAnnotation > .typeAnnotation):not(TSPropertySignature > .typeAnnotation > .typeAnnotation)",
@@ -226,6 +214,16 @@ const config = [
       ...errorPlugin.configs.strict.rules,
     },
   },
+  // Default plugin strict config
+  {
+    plugins: {
+      default: defaultPlugin,
+    },
+    rules: {
+      "default/no-localhost": ["error", { allowInTests: true }],
+      "default/no-hardcoded-urls": ["error", { allowInTests: true }],
+    },
+  },
 
   // TypeScript and TSX files
   {
@@ -723,89 +721,8 @@ const config = [
     },
   },
 
-  // Disable function and file size limits for test and spec files
-  {
-    files: [
-      "**/*.test.{js,jsx,ts,tsx}",
-      "**/*.spec.{js,jsx,ts,tsx}",
-      "**/test/**/*.{js,jsx,ts,tsx}",
-      "**/tests/**/*.{js,jsx,ts,tsx}",
-      "**/__tests__/**/*.{js,jsx,ts,tsx}",
-    ],
-    ignores: [
-      "**/long-function-test.tsx", // Exception: this file tests the max-lines rule itself
-      "**/test/export/**", // Export tests should follow strict export rules
-      "**/test/required-exports/**", // Required export tests should follow strict export rules
-    ],
-    rules: {
-      "max-lines-per-function": "off",
-      "max-lines": "off", // Ignore file length limits in test and spec files
-      // Allow multiple exports in test files for testing import/export patterns
-      "no-restricted-syntax": [
-        "warn",
-        ...sharedRestrictedSyntax.filter(
-          (rule) =>
-            rule.selector !==
-              "ExportNamedDeclaration[specifiers.length>1]:not([source])" &&
-            rule.selector !==
-              "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,
-      ],
-    },
-  },
-
-  // Test files configuration with mixed severity levels
-  {
-    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",
-      "no-restricted-syntax": [
-        "warn", // Base level for most rules
-        ...sharedRestrictedSyntax.filter(
-          (rule) =>
-            rule.selector !==
-              "ExportNamedDeclaration[specifiers.length>1]:not([source])" &&
-            rule.selector !==
-              "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 and spec files configuration (imported from separate config)
+  ...testFilesConfig,
 
   // Index files configuration - allow specific export patterns
   {
@@ -928,11 +845,7 @@ const config = [
           selector: "CallExpression[optional=true]",
           message: "Optional chaining is not allowed.",
         },
-        {
-          selector: 'LogicalExpression[operator="??"]',
-          message:
-            "Nullish coalescing operator (??) is not allowed. Use explicit null/undefined checks instead.",
-        },
+        allRules.noNullishCoalescingConfig,
         {
           selector: 'TSAsExpression[typeAnnotation.type="TSIndexedAccessType"]',
           message:
@@ -974,18 +887,6 @@ const config = [
     },
   },
 
-  // Disable file length rules for configuration and spec files
-  {
-    files: [
-      "index.js", // Main configuration file
-      "**/rules/**/*.spec.js", // Spec files in rules directory
-      "**/scripts/**/*.js", // Script files
-    ],
-    rules: {
-      "max-lines": "off",
-      "max-lines-per-function": "off",
-    },
-  },
 
   // Allow default exports in configuration files (must be last to override)
   {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-agent",
-  "version": "1.3.7",
+  "version": "1.3.9",
   "description": "ESLint configuration package with TypeScript support",
   "main": "index.js",
   "type": "module",
@@ -11,7 +11,11 @@
     "index.js",
     "README.md",
     "CHANGELOG.md",
-    "rules/"
+    "configs/",
+    "rules/**/index.js",
+    "!rules/**/examples/",
+    "!rules/**/*.spec.js",
+    "!rules/**/*.test.js"
   ],
   "engines": {
     "node": ">=18.0.0"
@@ -28,7 +32,7 @@
     "test:edge": "eslint test/edge-cases.tsx",
     "test:performance": "eslint test/performance-test.tsx",
     "test:comprehensive": "node scripts/test-runner.js",
-    "test:ci": "eslint . --ignore-pattern 'test/**' --ignore-pattern 'scripts/**' --ignore-pattern 'rules/**/examples/**' --max-warnings 0",
+    "test:ci": "eslint . --ignore-pattern 'test/**' --ignore-pattern 'scripts/**' --ignore-pattern 'rules/**/examples/**' --ignore-pattern 'configs/**' --ignore-pattern 'index.js' --max-warnings 0",
     "validate": "node scripts/validate-config.js",
     "release": "dotenv -e .env -- release-it",
     "release:patch": "dotenv -e .env -- release-it patch",
@@ -108,6 +112,7 @@
     "typescript-eslint": "^8.40.0"
   },
   "dependencies": {
-    "eslint-plugin-error": "^1.1.1"
+    "eslint-plugin-default": "^1.0.1",
+    "eslint-plugin-error": "^1.1.3"
   }
 }

package/rules/index.js

@@ -17,6 +17,7 @@ import { noExportSpecifiersConfig } from "./no-empty-exports/index.js";
 import { noClassPropertyDefaultsConfig } from "./no-class-property-defaults/index.js";
 import { noDefaultClassExportRules } from "./no-default-class-export/index.js";
 import { jsxClassNameRequiredRule } from "./jsx-classname-required/index.js";
+import { noNullishCoalescingConfig } from "./nullish-coalescing/index.js";
 
 // Plugin rule configurations
 import { pluginRules } from "./plugin/index.js";
@@ -38,6 +39,7 @@ const allRules = {
   noClassPropertyDefaultsConfig,
   noDefaultClassExportRules,
   jsxClassNameRequiredRule,
+  noNullishCoalescingConfig,
 
   // Plugin rule configurations
   pluginRules,
@@ -62,6 +64,7 @@ export {
   noClassPropertyDefaultsConfig,
   noDefaultClassExportRules,
   jsxClassNameRequiredRule,
+  noNullishCoalescingConfig,
 
   // Plugin rule configurations
   pluginRules,

package/rules/no-record-literal-types/README.md

@@ -0,0 +1,63 @@
+# no-record-literal-types
+
+Disallows using Record type with string literal keys in favor of more specific interface or type definitions.
+
+## Rule Details
+
+This rule helps enforce better type safety and readability by discouraging the use of `Record<LiteralKeys, ValueType>` patterns and encouraging more explicit type definitions.
+
+## Examples
+
+❌ **Incorrect** - Record with literal keys:
+
+```typescript
+type UserInfo = Record<"name" | "age", string>;
+type Status = Record<"active", boolean>;
+type Config = Record<"host" | "port" | "ssl", string>;
+```
+
+✅ **Correct** - Explicit interfaces and types:
+
+```typescript
+interface UserInfo {
+  name: string;
+  age: string;
+}
+
+type Status = {
+  active: boolean;
+};
+
+type Config = {
+  host: string;
+  port: number;
+  ssl: boolean;
+};
+```
+
+✅ **Correct** - Generic Record types:
+
+```typescript
+type UserData = Record<string, unknown>;
+type IndexMap = Record<number, string>;
+type DynamicKeys = Record<`prefix-${string}`, boolean>;
+```
+
+## Why This Rule Exists
+
+1. **Better IntelliSense**: Explicit interfaces provide better autocomplete and documentation
+2. **Type Safety**: More specific types catch errors earlier
+3. **Maintainability**: Clear structure makes code easier to understand and modify
+4. **Consistency**: Encourages consistent type definition patterns
+
+## Testing
+
+This rule is tested through integration tests in `/test/test-record-literals.ts` which validates that the rule correctly identifies and reports violations in real TypeScript code.
+
+The rule uses two AST selectors to comprehensively catch Record literal patterns:
+1. `.params:first-child TSLiteralType` - Catches literals inside unions
+2. `TSLiteralType:first-child` - Catches direct literal types
+
+## Configuration
+
+This rule is automatically included when using the eslint-config-agent package and applies to all TypeScript files.

package/rules/no-record-literal-types/index.js

@@ -0,0 +1,67 @@
+/**
+ * Rule configuration for no-record-literal-types
+ *
+ * This rule disallows using Record type with string literal keys in favor of
+ * more specific interface or type definitions for better type safety and readability.
+ *
+ * The Record utility type with literal string keys can make code harder to understand
+ * and maintain because it doesn't explicitly define the structure of the object.
+ * Using specific interfaces or types provides better IntelliSense, type checking,
+ * and documentation.
+ *
+ * Examples:
+ * - ❌ Record<'name' | 'age', string>
+ * - ❌ Record<'active', boolean>
+ * - ❌ Record<'foo' | 'bar' | 'baz', number>
+ * - ✅ interface UserInfo { name: string; age: string; }
+ * - ✅ type Status = { active: boolean; }
+ * - ✅ Record<string, unknown> (generic keys are allowed)
+ *
+ * @see https://eslint.org/docs/latest/rules/no-restricted-syntax
+ * @see https://www.typescriptlang.org/docs/handbook/utility-types.html#recordkeys-type
+ */
+
+const rule = "error";
+
+// First selector: matches TSLiteralType descendants of first param (catches literals inside unions)
+const selectorNestedParams = 'TSTypeReference[typeName.name="Record"] > TSTypeParameterInstantiation > .params:first-child TSLiteralType';
+
+// Second selector: matches direct TSLiteralType as first param
+const selectorFirstChild = 'TSTypeReference[typeName.name="Record"] > TSTypeParameterInstantiation > TSLiteralType:first-child';
+
+const message = "Avoid using Record with string literal keys. Use a more specific interface or type instead.";
+
+/**
+ * Export the complete rule configurations for no-restricted-syntax
+ * Can be used in ESLint config as part of no-restricted-syntax rules
+ */
+const noRecordLiteralTypesNestedConfig = {
+  selector: selectorNestedParams,
+  message,
+};
+
+const noRecordLiteralTypesFirstChildConfig = {
+  selector: selectorFirstChild,
+  message,
+};
+
+/**
+ * Combined rule configurations for comprehensive Record literal type prevention
+ */
+const noRecordLiteralTypesConfigs = [
+  noRecordLiteralTypesNestedConfig,
+  noRecordLiteralTypesFirstChildConfig,
+];
+
+// Consolidated exports
+export {
+  rule,
+  selectorNestedParams,
+  selectorFirstChild,
+  message,
+  noRecordLiteralTypesNestedConfig,
+  noRecordLiteralTypesFirstChildConfig,
+  noRecordLiteralTypesConfigs,
+};
+
+export default noRecordLiteralTypesConfigs;