eslint-config-agent 1.4.3 → 1.4.4

package/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this project will be documented in this file. See [Conven
 
 
 
+## [1.4.4](https://github.com/tupe12334/eslint-config/compare/v1.4.3...v1.4.4) (2025-09-30)
+
+### Features
+
+* add no-trivial-type-aliases rule with examples and tests ([27da82f](https://github.com/tupe12334/eslint-config/commit/27da82f53a084e2cdb88b26b06b53e11992a2a32))
+
+### Bug Fixes
+
+* restore eslint-plugin-single-export dependency in package.json and pnpm-lock.yaml ([7b273a5](https://github.com/tupe12334/eslint-config/commit/7b273a595c7ee1c5c5919b98f800fdca2c1d6fb9))
+
 ## [1.4.3](https://github.com/tupe12334/eslint-config/compare/v1.4.2...v1.4.3) (2025-09-27)
 
 ### Features

package/index.js

@@ -100,6 +100,7 @@ const tsOnlyRestrictedSyntax = [
   },
   ...allRules.switchCaseFunctionsReturnTypeConfigs,
   ...allRules.switchStatementsReturnTypeConfigs,
+  ...allRules.noTrivialTypeAliasesConfigs,
 ];
 
 const config = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-agent",
-  "version": "1.4.3",
+  "version": "1.4.4",
   "description": "ESLint configuration package with TypeScript support",
   "main": "index.js",
   "type": "module",
@@ -107,7 +107,6 @@
     "eslint-plugin-react-hooks": "^5.2.0",
     "eslint-plugin-required-exports": "^0.2.0",
     "eslint-plugin-security": "^3.0.1",
-    "eslint-plugin-single-export": "^1.1.2",
     "eslint-plugin-storybook": "^9.1.5",
     "globals": "^16.3.0",
     "release-it": "^19.0.4",
@@ -116,6 +115,7 @@
   "dependencies": {
     "eslint-plugin-default": "^1.1.0",
     "eslint-plugin-error": "^1.1.3",
-    "eslint-plugin-no-optional-chaining": "^1.0.0"
+    "eslint-plugin-no-optional-chaining": "^1.0.0",
+    "eslint-plugin-single-export": "^1.1.2"
   }
 }

package/rules/index.js

@@ -21,6 +21,7 @@ import { noNullishCoalescingConfig } from "./nullish-coalescing/index.js";
 import { switchStatementsReturnTypeConfigs } from "./switch-statements-return-type/index.js";
 import { switchCaseFunctionsReturnTypeConfigs } from "./switch-case-functions-return-type/index.js";
 import { switchCaseExplicitReturnConfigs } from "./switch-case-explicit-return/index.js";
+import { noTrivialTypeAliasesConfigs } from "./no-trivial-type-aliases/index.js";
 
 // Plugin rule configurations
 import { pluginRules } from "./plugin/index.js";
@@ -46,6 +47,7 @@ const allRules = {
   switchStatementsReturnTypeConfigs,
   switchCaseFunctionsReturnTypeConfigs,
   switchCaseExplicitReturnConfigs,
+  noTrivialTypeAliasesConfigs,
 
   // Plugin rule configurations
   pluginRules,
@@ -74,6 +76,7 @@ export {
   switchStatementsReturnTypeConfigs,
   switchCaseFunctionsReturnTypeConfigs,
   switchCaseExplicitReturnConfigs,
+  noTrivialTypeAliasesConfigs,
 
   // Plugin rule configurations
   pluginRules,

package/rules/no-trivial-type-aliases/index.js

@@ -0,0 +1,112 @@
+/**
+ * Rule configuration for no-trivial-type-aliases
+ *
+ * This rule disallows trivial TypeScript type aliases that don't add semantic value.
+ * Trivial type aliases are direct assignments to primitive types, other types, or literals
+ * without any transformation.
+ *
+ * ## Rationale
+ *
+ * Trivial type aliases can make code harder to understand and maintain because they:
+ * - Add unnecessary indirection without semantic meaning
+ * - Increase cognitive load when reading code
+ * - Can make refactoring more difficult
+ * - Don't provide any type safety benefits
+ *
+ * ## Rule Details
+ *
+ * This rule flags the following patterns:
+ *
+ * ### ❌ Invalid (will trigger errors):
+ *
+ * ```typescript
+ * // Primitive type aliases
+ * type MyString = string;
+ * type MyNumber = number;
+ * type MyBoolean = boolean;
+ *
+ * // Direct type reference aliases
+ * type UserId = OtherId;
+ * type UserData = SomeOtherType;
+ *
+ * // Literal type aliases
+ * type Status = 'active';
+ * type Count = 42;
+ * ```
+ *
+ * ### ✅ Valid (will NOT trigger errors):
+ *
+ * ```typescript
+ * // Union types (add semantic meaning)
+ * type StringOrNumber = string | number;
+ * type Status = 'active' | 'inactive' | 'pending';
+ *
+ * // Generic types (parameterized)
+ * type Container<T> = { value: T };
+ * type Result<T, E = Error> = T | E;
+ *
+ * // Mapped types (transformation)
+ * type Partial<T> = { [P in keyof T]?: T[P] };
+ *
+ * // Conditional types (logic)
+ * type NonNullable<T> = T extends null | undefined ? never : T;
+ *
+ * // Type references with generics
+ * type ListOfUsers = Array<User>;
+ * ```
+ *
+ * @see https://eslint.org/docs/latest/rules/no-restricted-syntax
+ * @see ./examples/invalid.js for more invalid examples
+ * @see ./examples/valid.js for more valid examples
+ */
+
+/**
+ * Rule configuration for type aliases to other types without generics
+ * Catches: type A = B (where B is not a generic type)
+ */
+const noTrivialTypeReferenceConfig = {
+  selector:
+    "TSTypeAliasDeclaration > TSTypeReference:not(:has(TSTypeParameterInstantiation))",
+  message:
+    "Trivial type aliases are not allowed. Use the original type directly instead of creating an alias that doesn't add meaning.",
+};
+
+/**
+ * Rule configuration for type aliases to primitive types
+ * Catches: type A = string, type B = number, etc.
+ */
+const noTrivialPrimitiveTypeConfig = {
+  selector:
+    "TSTypeAliasDeclaration:has(TSStringKeyword):not(:has(TSUnionType)):not(:has(TSIntersectionType)):not(:has(TSMappedType))",
+  message:
+    "Trivial type aliases to primitive types are not allowed. Use the primitive type directly instead.",
+};
+
+/**
+ * Rule configuration for type aliases to literal types
+ * Catches: type A = 'literal', type B = 42, etc.
+ */
+const noTrivialLiteralTypeConfig = {
+  selector: "TSTypeAliasDeclaration > TSLiteralType",
+  message:
+    "Trivial type aliases to literal types are not allowed. Use the literal type directly instead.",
+};
+
+/**
+ * Combined configuration array for all trivial type alias rules
+ */
+const noTrivialTypeAliasesConfigs = [
+  noTrivialTypeReferenceConfig,
+  noTrivialPrimitiveTypeConfig,
+  noTrivialLiteralTypeConfig,
+];
+
+// Consolidated exports
+export {
+  noTrivialTypeReferenceConfig,
+  noTrivialPrimitiveTypeConfig,
+  noTrivialLiteralTypeConfig,
+  noTrivialTypeAliasesConfigs,
+};
+
+export default noTrivialTypeAliasesConfigs;