@mrpalmer/eslint-plugin 1.0.0 → 1.0.2

package/lib/rules/shorten-paths.js

@@ -1,8 +1,8 @@
 import path from 'node:path';
 import { createRule } from '../utils/create-rule.js';
-import { loadConfig } from '../utils/ts-config.js';
 import { getImportPathOptions } from '../utils/import-path-options.js';
 import { getShortestPath } from '../utils/shortest-path.js';
+import { loadConfig } from '../utils/ts-config.js';
 export default createRule({
     meta: {
         type: 'suggestion',
@@ -15,6 +15,7 @@ export default createRule({
                 type: 'object',
                 properties: {
                     breakTies: {
+                        description: 'When the aliased and relative paths are the same length, which should be preferred.',
                         type: 'string',
                         enum: ['alias', 'relative'],
                     },
@@ -22,6 +23,11 @@ export default createRule({
                 additionalProperties: false,
             },
         ],
+        defaultOptions: [
+            {
+                breakTies: 'alias',
+            },
+        ],
         messages: {
             shortenImport: 'Import can be shortened to "{{path}}"',
             shortenExport: 'Export can be shortened to "{{path}}"',

package/lib/rules/sort-imports.d.ts

@@ -1,4 +1,4 @@
-import { type TSESLint } from '@typescript-eslint/utils';
+import type { TSESLint } from '@typescript-eslint/utils';
 import { type MinimatchOptions } from 'minimatch';
 import type { Arrayable } from '../types.js';
 import { type ImportType as ImportType_ } from '../utils/import-type.js';

package/lib/rules/sort-imports.js

@@ -1,11 +1,11 @@
-import { TSESTree } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/types';
 import { minimatch } from 'minimatch';
-import { reverse, findOutOfOrder, groupBy } from '../utils/array.js';
-import { findRootNode, findEndOfLineWithComments, findStartOfLineWithComments, } from '../utils/ast.js';
+import { findOutOfOrder, groupBy, reverse } from '../utils/array.js';
+import { findEndOfLineWithComments, findRootNode, findStartOfLineWithComments, } from '../utils/ast.js';
 import { createRule } from '../utils/create-rule.js';
+import { importType, } from '../utils/import-type.js';
 import { getSettings } from '../utils/settings.js';
 import { loadConfig } from '../utils/ts-config.js';
-import { importType, } from '../utils/import-type.js';
 const categories = {
     import: 'import',
     exports: 'exports',
@@ -21,34 +21,34 @@ const defaultGroups = [
 // REPORTING AND FIXING
 function isRequireExpression(expr) {
     return (expr != null &&
-        expr.type === TSESTree.AST_NODE_TYPES.CallExpression &&
+        expr.type === AST_NODE_TYPES.CallExpression &&
         // eslint-disable-next-line eslint-plugin/no-property-in-node
         'name' in expr.callee &&
         expr.callee.name === 'require' &&
         expr.arguments.length === 1 &&
-        expr.arguments[0].type === TSESTree.AST_NODE_TYPES.Literal);
+        expr.arguments[0].type === AST_NODE_TYPES.Literal);
 }
 function isSupportedRequireModule(node) {
-    if (node.type !== TSESTree.AST_NODE_TYPES.VariableDeclaration) {
+    if (node.type !== AST_NODE_TYPES.VariableDeclaration) {
         return false;
     }
     if (node.declarations.length !== 1) {
         return false;
     }
     const decl = node.declarations[0];
-    const isPlainRequire = (decl.id.type === TSESTree.AST_NODE_TYPES.Identifier ||
-        decl.id.type === TSESTree.AST_NODE_TYPES.ObjectPattern) &&
+    const isPlainRequire = (decl.id.type === AST_NODE_TYPES.Identifier ||
+        decl.id.type === AST_NODE_TYPES.ObjectPattern) &&
         isRequireExpression(decl.init);
-    const isRequireWithMemberExpression = (decl.id.type === TSESTree.AST_NODE_TYPES.Identifier ||
-        decl.id.type === TSESTree.AST_NODE_TYPES.ObjectPattern) &&
+    const isRequireWithMemberExpression = (decl.id.type === AST_NODE_TYPES.Identifier ||
+        decl.id.type === AST_NODE_TYPES.ObjectPattern) &&
         decl.init != null &&
-        decl.init.type === TSESTree.AST_NODE_TYPES.CallExpression &&
-        decl.init.callee.type === TSESTree.AST_NODE_TYPES.MemberExpression &&
+        decl.init.type === AST_NODE_TYPES.CallExpression &&
+        decl.init.callee.type === AST_NODE_TYPES.MemberExpression &&
         isRequireExpression(decl.init.callee.object);
     return isPlainRequire || isRequireWithMemberExpression;
 }
 function isPlainImportModule(node) {
-    return node.type === TSESTree.AST_NODE_TYPES.ImportDeclaration;
+    return node.type === AST_NODE_TYPES.ImportDeclaration;
 }
 function canCrossNodeWhileReorder(node) {
     return isSupportedRequireModule(node) || isPlainImportModule(node);
@@ -276,8 +276,7 @@ function registerNode(context, settings, importEntry, ranks, imported) {
     if (rank !== -1) {
         let importNode = importEntry.node;
         if (importEntry.type === 'require' &&
-            importNode.parent?.parent?.type ===
-                TSESTree.AST_NODE_TYPES.VariableDeclaration) {
+            importNode.parent?.parent?.type === AST_NODE_TYPES.VariableDeclaration) {
             importNode = importNode.parent.parent;
         }
         imported.push({
@@ -292,7 +291,7 @@ function registerNode(context, settings, importEntry, ranks, imported) {
     }
 }
 function isSideEffectImport(node, sourceCode) {
-    if (node.type !== TSESTree.AST_NODE_TYPES.ImportDeclaration) {
+    if (node.type !== AST_NODE_TYPES.ImportDeclaration) {
         return false;
     }
     return (node.specifiers.length === 0 &&
@@ -300,22 +299,19 @@ function isSideEffectImport(node, sourceCode) {
         !isPunctuator(sourceCode.getFirstToken(node, { skip: 1 }), '{'));
 }
 function isPunctuator(token, value) {
-    return (token &&
-        token.type === TSESTree.AST_TOKEN_TYPES.Punctuator &&
-        token.value === value);
+    return (token && token.type === AST_TOKEN_TYPES.Punctuator && token.value === value);
 }
 function getRequireBlock(node) {
     let n = node;
     // Handle cases like `const baz = require('foo').bar.baz`
     // and `const foo = require('foo')()`
-    while ((n.parent?.type === TSESTree.AST_NODE_TYPES.MemberExpression &&
+    while ((n.parent?.type === AST_NODE_TYPES.MemberExpression &&
         n.parent.object === n) ||
-        (n.parent?.type === TSESTree.AST_NODE_TYPES.CallExpression &&
-            n.parent.callee === n)) {
+        (n.parent?.type === AST_NODE_TYPES.CallExpression && n.parent.callee === n)) {
         n = n.parent;
     }
-    if (n.parent?.type === TSESTree.AST_NODE_TYPES.VariableDeclarator &&
-        n.parent.parent.parent.type === TSESTree.AST_NODE_TYPES.Program) {
+    if (n.parent?.type === AST_NODE_TYPES.VariableDeclarator &&
+        n.parent.parent.parent.type === AST_NODE_TYPES.Program) {
         return n.parent.parent.parent;
     }
     return undefined;
@@ -482,9 +478,11 @@ export default createRule({
                 type: 'object',
                 properties: {
                     groups: {
+                        description: 'The order of import types.',
                         type: 'array',
                     },
                     pathGroups: {
+                        description: 'Custom path patterns and their import types.',
                         type: 'array',
                         items: {
                             type: 'object',
@@ -515,6 +513,12 @@ export default createRule({
                 additionalProperties: false,
             },
         ],
+        defaultOptions: [
+            {
+                groups: defaultGroups,
+                pathGroups: [],
+            },
+        ],
         messages: {
             error: '{{error}}',
             noLineBetweenImports: 'There should be no empty line between import statements',
@@ -628,9 +632,9 @@ function getErrorMessage(error) {
     return undefined;
 }
 function isStaticRequire(node) {
-    return (node.callee.type === TSESTree.AST_NODE_TYPES.Identifier &&
+    return (node.callee.type === AST_NODE_TYPES.Identifier &&
         node.callee.name === 'require' &&
         node.arguments.length === 1 &&
-        node.arguments[0].type === TSESTree.AST_NODE_TYPES.Literal &&
+        node.arguments[0].type === AST_NODE_TYPES.Literal &&
         typeof node.arguments[0].value === 'string');
 }

package/lib/rules/sort-named.d.ts

@@ -1,4 +1,4 @@
-import { type TSESLint } from '@typescript-eslint/utils';
+import type { TSESLint } from '@typescript-eslint/utils';
 export interface Options {
     ignoreCase?: boolean;
     types?: NamedTypes;

package/lib/rules/sort-named.js

@@ -1,5 +1,5 @@
-import { TSESTree } from '@typescript-eslint/utils';
-import { groupBy, reverse, findOutOfOrder } from '../utils/array.js';
+import { AST_NODE_TYPES } from '@typescript-eslint/types';
+import { findOutOfOrder, groupBy, reverse } from '../utils/array.js';
 import { createRule } from '../utils/create-rule.js';
 //region rule
 // REPORTING AND FIXING
@@ -21,24 +21,23 @@ function findSpecifierEnd(sourceCode, node) {
 }
 function isRequireExpression(expr) {
     return (expr != null &&
-        expr.type === TSESTree.AST_NODE_TYPES.CallExpression &&
-        expr.callee.type === TSESTree.AST_NODE_TYPES.Identifier &&
+        expr.type === AST_NODE_TYPES.CallExpression &&
+        expr.callee.type === AST_NODE_TYPES.Identifier &&
         expr.callee.name === 'require' &&
         expr.arguments.length === 1 &&
-        expr.arguments[0].type === TSESTree.AST_NODE_TYPES.Literal);
+        expr.arguments[0].type === AST_NODE_TYPES.Literal);
 }
 function isCJSExports(context, node) {
-    if (node.type === TSESTree.AST_NODE_TYPES.MemberExpression &&
-        node.object.type === TSESTree.AST_NODE_TYPES.Identifier &&
-        node.property.type === TSESTree.AST_NODE_TYPES.Identifier &&
+    if (node.type === AST_NODE_TYPES.MemberExpression &&
+        node.object.type === AST_NODE_TYPES.Identifier &&
+        node.property.type === AST_NODE_TYPES.Identifier &&
         node.object.name === 'module' &&
         node.property.name === 'exports') {
         return !context.sourceCode
             .getScope(node)
             .variables.some((variable) => variable.name === 'module');
     }
-    if (node.type === TSESTree.AST_NODE_TYPES.Identifier &&
-        node.name === 'exports') {
+    if (node.type === AST_NODE_TYPES.Identifier && node.name === 'exports') {
         return !context.sourceCode
             .getScope(node)
             .variables.some((variable) => variable.name === 'exports');
@@ -46,14 +45,14 @@ function isCJSExports(context, node) {
     return false;
 }
 function getNamedCJSExports(context, node) {
-    if (node.type !== TSESTree.AST_NODE_TYPES.MemberExpression) {
+    if (node.type !== AST_NODE_TYPES.MemberExpression) {
         return undefined;
     }
     const result = [];
     let root = node;
     let parent;
-    while (root.type === TSESTree.AST_NODE_TYPES.MemberExpression) {
-        if (root.property.type !== TSESTree.AST_NODE_TYPES.Identifier) {
+    while (root.type === AST_NODE_TYPES.MemberExpression) {
+        if (root.property.type !== AST_NODE_TYPES.Identifier) {
             return undefined;
         }
         result.unshift(root.property.name);
@@ -259,13 +258,13 @@ function makeOutOfOrderReport(context, imported) {
 }
 function isSimpleObjectPropertyList(properties) {
     return properties.every((p) => {
-        if (p.type !== TSESTree.AST_NODE_TYPES.Property) {
+        if (p.type !== AST_NODE_TYPES.Property) {
             return false;
         }
-        if (p.key.type !== TSESTree.AST_NODE_TYPES.Identifier) {
+        if (p.key.type !== AST_NODE_TYPES.Identifier) {
             return false;
         }
-        return p.value.type === TSESTree.AST_NODE_TYPES.Identifier;
+        return p.value.type === AST_NODE_TYPES.Identifier;
     });
 }
 export default createRule({
@@ -280,9 +279,11 @@ export default createRule({
                 type: 'object',
                 properties: {
                     ignoreCase: {
+                        description: 'Whether to ignore case when sorting.',
                         type: 'boolean',
                     },
                     types: {
+                        description: 'Whether to group type and value imports/exports, and if so, which should come first.',
                         type: 'string',
                         enum: ['mixed', 'types-first', 'types-last'],
                     },
@@ -290,6 +291,12 @@ export default createRule({
                 additionalProperties: false,
             },
         ],
+        defaultOptions: [
+            {
+                ignoreCase: false,
+                types: 'types-first',
+            },
+        ],
         messages: {
             order: '{{secondImport}} should occur {{order}} {{firstImport}}',
         },
@@ -337,7 +344,7 @@ export default createRule({
                     return;
                 }
                 makeNamedOrderReport(context, node.specifiers
-                    .filter((specifier) => specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier)
+                    .filter((specifier) => specifier.type === AST_NODE_TYPES.ImportSpecifier)
                     .map((specifier) => ({
                     node: specifier,
                     value: getValue(specifier.imported),
@@ -349,7 +356,7 @@ export default createRule({
                 })));
             },
             VariableDeclarator(node) {
-                if (node.id.type === TSESTree.AST_NODE_TYPES.ObjectPattern &&
+                if (node.id.type === AST_NODE_TYPES.ObjectPattern &&
                     isRequireExpression(node.init)) {
                     const { properties } = node.id;
                     if (!isSimpleObjectPropertyList(properties)) {
@@ -381,9 +388,9 @@ export default createRule({
                 })));
             },
             AssignmentExpression(node) {
-                if (node.parent.type === TSESTree.AST_NODE_TYPES.ExpressionStatement) {
+                if (node.parent.type === AST_NODE_TYPES.ExpressionStatement) {
                     if (isCJSExports(context, node.left)) {
-                        if (node.right.type === TSESTree.AST_NODE_TYPES.ObjectExpression) {
+                        if (node.right.type === AST_NODE_TYPES.ObjectExpression) {
                             const { properties } = node.right;
                             if (!isSimpleObjectPropertyList(properties)) {
                                 return;
@@ -425,9 +432,9 @@ export default createRule({
 //region utils
 function getValue(node) {
     switch (node.type) {
-        case TSESTree.AST_NODE_TYPES.Identifier:
+        case AST_NODE_TYPES.Identifier:
             return node.name;
-        case TSESTree.AST_NODE_TYPES.Literal:
+        case AST_NODE_TYPES.Literal:
             return node.value;
         default:
             throw new Error(`Unsupported node type: ${node.type}`);

package/lib/utils/ast.d.ts

@@ -1,4 +1,4 @@
-import { type TSESLint, TSESTree } from '@typescript-eslint/utils';
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 export declare function findRootNode(node: TSESTree.Node): TSESTree.Node;
 export declare function findEndOfLineWithComments(sourceCode: TSESLint.SourceCode, node: TSESTree.Node): number;
 export declare function findStartOfLineWithComments(sourceCode: TSESLint.SourceCode, node: TSESTree.Node): number;

package/lib/utils/ast.js

@@ -1,4 +1,4 @@
-import { TSESTree } from '@typescript-eslint/utils';
+import { AST_TOKEN_TYPES } from '@typescript-eslint/types';
 export function findRootNode(node) {
     let parent = node;
     while (parent.parent != null &&
@@ -83,8 +83,8 @@ export function findEndOfLineWithComments(sourceCode, node) {
     return result;
 }
 function commentOnSameLineAs(node) {
-    return (token) => (token.type === TSESTree.AST_TOKEN_TYPES.Block ||
-        token.type === TSESTree.AST_TOKEN_TYPES.Line) &&
+    return (token) => (token.type === AST_TOKEN_TYPES.Block ||
+        token.type === AST_TOKEN_TYPES.Line) &&
         token.loc.start.line === token.loc.end.line &&
         token.loc.end.line === node.loc.end.line;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrpalmer/eslint-plugin",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Custom ESLint rules for Mike Palmer's projects",
   "license": "MIT",
   "type": "module",
@@ -16,16 +16,22 @@
     "lib"
   ],
   "dependencies": {
-    "@typescript-eslint/utils": "^8.29.1",
+    "@typescript-eslint/types": "^8.36.0",
     "get-tsconfig": "^4.10.0",
     "minimatch": "^10.0.1"
   },
   "peerDependencies": {
+    "@typescript-eslint/utils": "^8.0.0",
     "eslint": "^9.0.0"
   },
+  "peerDependenciesMeta": {
+    "@typescript-eslint/utils": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=20",
-    "npm": ">=8",
+    "npm": ">=10",
     "yarn": ">=1"
   }
 }