eslint-config-decent 1.1.0 → 1.2.0

package/README.md

@@ -15,6 +15,35 @@ import tsEslint from 'typescript-eslint';
 export default tsEslint.config(...defaultConfig());
 ```
 
+## Override parserOptions
+
+````mjs
+// eslint.config.mjs
+
+import { defaultConfig } from 'eslint-config-decent';
+import tsEslint from 'typescript-eslint';
+
+export default tsEslint.config(...defaultConfig({
+      projectService: {
+        allowedDefaultProject: ['./*.js', './*.cjs', './*.mjs', './tests/**/*.ts', './tests/**/*.js', './tests/**/*.cjs', './tests/**/*.mjs'],
+        defaultProject: 'tsconfig.json',
+      },
+      tsconfigRootDir: import.meta.dirname,
+}));
+
+## Disable require-extensions rules
+
+```mjs
+// eslint.config.mjs
+
+import { defaultConfig } from 'eslint-config-decent';
+import tsEslint from 'typescript-eslint';
+
+export default tsEslint.config(...defaultConfig({
+  enableRequireExtensions: false,
+}));
+````
+
 ## License
 
 MIT

package/dist/index.cjs

@@ -4,6 +4,8 @@ const eslint = require('@eslint/js');
 const globals = require('globals');
 const tsEslint = require('typescript-eslint');
 const prettier = require('eslint-plugin-prettier/recommended');
+const fs = require('fs');
+const path = require('path');
 const jsdoc = require('eslint-plugin-jsdoc');
 const mocha = require('eslint-plugin-mocha');
 const promise = require('eslint-plugin-promise');
@@ -30,7 +32,7 @@ const testingLibrary__default = /*#__PURE__*/_interopDefaultCompat(testingLibrar
 const security__default = /*#__PURE__*/_interopDefaultCompat(security);
 const unicorn__default = /*#__PURE__*/_interopDefaultCompat(unicorn);
 
-const base$7 = {
+const base$8 = {
   rules: {
     "array-callback-return": ["error", { allowImplicit: true }],
     "block-scoped-var": "error",
@@ -277,12 +279,122 @@ const cjs = {
     strict: ["error", "global"]
   }
 };
-const configs$7 = {
-  base: base$7,
+const configs$8 = {
+  base: base$8,
   cjsAndEsm,
   cjs
 };
 
+const requireExtensionRule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Ensure import and export statements include a file extension",
+      category: "Best Practices",
+      recommended: true
+    },
+    fixable: "code",
+    schema: []
+  },
+  create(context) {
+    function checkSource(source) {
+      const importPath = source.value;
+      if (!importPath || !importPath.startsWith(".") || importPath.endsWith(".js")) {
+        return;
+      }
+      const resolvedPath = path.resolve(path.dirname(context.filename), importPath);
+      if (!fs.existsSync(resolvedPath)) {
+        context.report({
+          node: source,
+          message: "Relative imports and exports must include a file extension.",
+          fix(fixer) {
+            const fixedPath = `${importPath}.js`;
+            return fixer.replaceText(source, `'${fixedPath}'`);
+          }
+        });
+      }
+    }
+    return {
+      ImportDeclaration(node) {
+        checkSource(node.source);
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source) {
+          checkSource(node.source);
+        }
+      },
+      ExportAllDeclaration(node) {
+        checkSource(node.source);
+      }
+    };
+  }
+};
+
+const requireIndexRule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Ensure directory import and export statements use index.js",
+      category: "Best Practices",
+      recommended: true
+    },
+    fixable: "code",
+    schema: []
+  },
+  create(context) {
+    function checkSource(source) {
+      const importPath = source.value;
+      const resolvedPath = path.resolve(path.dirname(context.filename), importPath);
+      const isDirectory = fs.existsSync(resolvedPath) && fs.lstatSync(resolvedPath).isDirectory();
+      if (isDirectory) {
+        context.report({
+          node: source,
+          message: "Directory imports and exports must use index.js.",
+          fix(fixer) {
+            const fixedPath = importPath.replace(/\/?$/, "/index.js");
+            return fixer.replaceText(source, `'${fixedPath}'`);
+          }
+        });
+      }
+    }
+    return {
+      ImportDeclaration(node) {
+        checkSource(node.source);
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source) {
+          checkSource(node.source);
+        }
+      },
+      ExportAllDeclaration(node) {
+        checkSource(node.source);
+      }
+    };
+  }
+};
+
+const base$7 = {
+  plugins: {
+    "decent-extension": {
+      meta: {
+        name: "decent-extension",
+        version: "1.0.0"
+      },
+      rules: {
+        "require-extension": requireExtensionRule,
+        "require-index": requireIndexRule
+      }
+    }
+  },
+  rules: {
+    "decent-extension/require-extension": "error",
+    "decent-extension/require-index": "error"
+  }
+};
+const configs$7 = {
+  base: base$7
+};
+
 const base$6 = {
   settings: {
     jsdoc: {
@@ -533,7 +645,8 @@ const configs = {
   base
 };
 
-function defaultConfig(parserOptions) {
+function defaultConfig(options) {
+  const enableRequireExtensionRule = options?.enableRequireExtensionRule ?? true;
   const languageOptions = {
     globals: {
       ...globals__default.node
@@ -545,7 +658,7 @@ function defaultConfig(parserOptions) {
         defaultProject: "tsconfig.json"
       },
       tsconfigRootDir: undefined,
-      ...parserOptions
+      ...options?.parserOptions
     }
   };
   return [
@@ -564,13 +677,15 @@ function defaultConfig(parserOptions) {
     {
       files: ["**/*.ts", "**/*.js", "**/*.cjs", "**/*.mjs", "**/*.tsx"],
       plugins: {
+        ...configs$7.base.plugins,
         ...configs$6.base.plugins,
         ...configs$4.base.plugins,
         ...configs$2.base.plugins,
         ...configs.base.plugins
       },
       rules: {
-        ...configs$7.base.rules,
+        ...configs$8.base.rules,
+        ...enableRequireExtensionRule ? configs$7.base.rules : {},
         ...configs$6.base.rules,
         ...configs$4.base.rules,
         ...configs$2.base.rules,
@@ -582,14 +697,14 @@ function defaultConfig(parserOptions) {
       languageOptions: {
         sourceType: "script"
       },
-      ...configs$7.cjsAndEsm
+      ...configs$8.cjsAndEsm
     },
     {
       files: ["**/*.js", "**/*.cjs"],
       languageOptions: {
         sourceType: "script"
       },
-      ...configs$7.cjs
+      ...configs$8.cjs
     },
     {
       files: ["**/*.ts", "**/*.tsx"],
@@ -608,7 +723,7 @@ function defaultConfig(parserOptions) {
 }
 
 exports.defaultConfig = defaultConfig;
-exports.eslintConfigs = configs$7;
+exports.eslintConfigs = configs$8;
 exports.jsdocConfigs = configs$6;
 exports.promiseConfigs = configs$4;
 exports.reactConfigs = configs$3;

package/dist/index.d.cts

@@ -30,6 +30,10 @@ declare const configs: {
     base: ConfigWithExtends;
 };
 
-declare function defaultConfig(parserOptions?: NonNullable<ConfigWithExtends['languageOptions']>['parserOptions']): ConfigWithExtends[];
+interface DefaultConfigOptions {
+    parserOptions?: NonNullable<ConfigWithExtends['languageOptions']>['parserOptions'];
+    enableRequireExtensionRule?: boolean;
+}
+declare function defaultConfig(options?: DefaultConfigOptions): ConfigWithExtends[];
 
-export { defaultConfig, configs$6 as eslintConfigs, configs$5 as jsdocConfigs, configs$4 as promiseConfigs, configs$3 as reactConfigs, configs$2 as securityConfigs, configs$1 as typescriptEslintConfigs, configs as unicornConfigs };
+export { type DefaultConfigOptions, defaultConfig, configs$6 as eslintConfigs, configs$5 as jsdocConfigs, configs$4 as promiseConfigs, configs$3 as reactConfigs, configs$2 as securityConfigs, configs$1 as typescriptEslintConfigs, configs as unicornConfigs };

package/dist/index.d.mts

@@ -30,6 +30,10 @@ declare const configs: {
     base: ConfigWithExtends;
 };
 
-declare function defaultConfig(parserOptions?: NonNullable<ConfigWithExtends['languageOptions']>['parserOptions']): ConfigWithExtends[];
+interface DefaultConfigOptions {
+    parserOptions?: NonNullable<ConfigWithExtends['languageOptions']>['parserOptions'];
+    enableRequireExtensionRule?: boolean;
+}
+declare function defaultConfig(options?: DefaultConfigOptions): ConfigWithExtends[];
 
-export { defaultConfig, configs$6 as eslintConfigs, configs$5 as jsdocConfigs, configs$4 as promiseConfigs, configs$3 as reactConfigs, configs$2 as securityConfigs, configs$1 as typescriptEslintConfigs, configs as unicornConfigs };
+export { type DefaultConfigOptions, defaultConfig, configs$6 as eslintConfigs, configs$5 as jsdocConfigs, configs$4 as promiseConfigs, configs$3 as reactConfigs, configs$2 as securityConfigs, configs$1 as typescriptEslintConfigs, configs as unicornConfigs };

package/dist/index.d.ts

@@ -30,6 +30,10 @@ declare const configs: {
     base: ConfigWithExtends;
 };
 
-declare function defaultConfig(parserOptions?: NonNullable<ConfigWithExtends['languageOptions']>['parserOptions']): ConfigWithExtends[];
+interface DefaultConfigOptions {
+    parserOptions?: NonNullable<ConfigWithExtends['languageOptions']>['parserOptions'];
+    enableRequireExtensionRule?: boolean;
+}
+declare function defaultConfig(options?: DefaultConfigOptions): ConfigWithExtends[];
 
-export { defaultConfig, configs$6 as eslintConfigs, configs$5 as jsdocConfigs, configs$4 as promiseConfigs, configs$3 as reactConfigs, configs$2 as securityConfigs, configs$1 as typescriptEslintConfigs, configs as unicornConfigs };
+export { type DefaultConfigOptions, defaultConfig, configs$6 as eslintConfigs, configs$5 as jsdocConfigs, configs$4 as promiseConfigs, configs$3 as reactConfigs, configs$2 as securityConfigs, configs$1 as typescriptEslintConfigs, configs as unicornConfigs };

package/dist/index.mjs

@@ -2,6 +2,8 @@ import eslint from '@eslint/js';
 import globals from 'globals';
 import tsEslint from 'typescript-eslint';
 import prettier from 'eslint-plugin-prettier/recommended';
+import { existsSync, lstatSync } from 'fs';
+import { resolve, dirname } from 'path';
 import jsdoc from 'eslint-plugin-jsdoc';
 import mocha from 'eslint-plugin-mocha';
 import promise from 'eslint-plugin-promise';
@@ -12,7 +14,7 @@ import testingLibrary from 'eslint-plugin-testing-library';
 import security from 'eslint-plugin-security';
 import unicorn from 'eslint-plugin-unicorn';
 
-const base$7 = {
+const base$8 = {
   rules: {
     "array-callback-return": ["error", { allowImplicit: true }],
     "block-scoped-var": "error",
@@ -259,12 +261,122 @@ const cjs = {
     strict: ["error", "global"]
   }
 };
-const configs$7 = {
-  base: base$7,
+const configs$8 = {
+  base: base$8,
   cjsAndEsm,
   cjs
 };
 
+const requireExtensionRule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Ensure import and export statements include a file extension",
+      category: "Best Practices",
+      recommended: true
+    },
+    fixable: "code",
+    schema: []
+  },
+  create(context) {
+    function checkSource(source) {
+      const importPath = source.value;
+      if (!importPath || !importPath.startsWith(".") || importPath.endsWith(".js")) {
+        return;
+      }
+      const resolvedPath = resolve(dirname(context.filename), importPath);
+      if (!existsSync(resolvedPath)) {
+        context.report({
+          node: source,
+          message: "Relative imports and exports must include a file extension.",
+          fix(fixer) {
+            const fixedPath = `${importPath}.js`;
+            return fixer.replaceText(source, `'${fixedPath}'`);
+          }
+        });
+      }
+    }
+    return {
+      ImportDeclaration(node) {
+        checkSource(node.source);
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source) {
+          checkSource(node.source);
+        }
+      },
+      ExportAllDeclaration(node) {
+        checkSource(node.source);
+      }
+    };
+  }
+};
+
+const requireIndexRule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Ensure directory import and export statements use index.js",
+      category: "Best Practices",
+      recommended: true
+    },
+    fixable: "code",
+    schema: []
+  },
+  create(context) {
+    function checkSource(source) {
+      const importPath = source.value;
+      const resolvedPath = resolve(dirname(context.filename), importPath);
+      const isDirectory = existsSync(resolvedPath) && lstatSync(resolvedPath).isDirectory();
+      if (isDirectory) {
+        context.report({
+          node: source,
+          message: "Directory imports and exports must use index.js.",
+          fix(fixer) {
+            const fixedPath = importPath.replace(/\/?$/, "/index.js");
+            return fixer.replaceText(source, `'${fixedPath}'`);
+          }
+        });
+      }
+    }
+    return {
+      ImportDeclaration(node) {
+        checkSource(node.source);
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source) {
+          checkSource(node.source);
+        }
+      },
+      ExportAllDeclaration(node) {
+        checkSource(node.source);
+      }
+    };
+  }
+};
+
+const base$7 = {
+  plugins: {
+    "decent-extension": {
+      meta: {
+        name: "decent-extension",
+        version: "1.0.0"
+      },
+      rules: {
+        "require-extension": requireExtensionRule,
+        "require-index": requireIndexRule
+      }
+    }
+  },
+  rules: {
+    "decent-extension/require-extension": "error",
+    "decent-extension/require-index": "error"
+  }
+};
+const configs$7 = {
+  base: base$7
+};
+
 const base$6 = {
   settings: {
     jsdoc: {
@@ -515,7 +627,8 @@ const configs = {
   base
 };
 
-function defaultConfig(parserOptions) {
+function defaultConfig(options) {
+  const enableRequireExtensionRule = options?.enableRequireExtensionRule ?? true;
   const languageOptions = {
     globals: {
       ...globals.node
@@ -527,7 +640,7 @@ function defaultConfig(parserOptions) {
         defaultProject: "tsconfig.json"
       },
       tsconfigRootDir: import.meta.dirname,
-      ...parserOptions
+      ...options?.parserOptions
     }
   };
   return [
@@ -546,13 +659,15 @@ function defaultConfig(parserOptions) {
     {
       files: ["**/*.ts", "**/*.js", "**/*.cjs", "**/*.mjs", "**/*.tsx"],
       plugins: {
+        ...configs$7.base.plugins,
         ...configs$6.base.plugins,
         ...configs$4.base.plugins,
         ...configs$2.base.plugins,
         ...configs.base.plugins
       },
       rules: {
-        ...configs$7.base.rules,
+        ...configs$8.base.rules,
+        ...enableRequireExtensionRule ? configs$7.base.rules : {},
         ...configs$6.base.rules,
         ...configs$4.base.rules,
         ...configs$2.base.rules,
@@ -564,14 +679,14 @@ function defaultConfig(parserOptions) {
       languageOptions: {
         sourceType: "script"
       },
-      ...configs$7.cjsAndEsm
+      ...configs$8.cjsAndEsm
     },
     {
       files: ["**/*.js", "**/*.cjs"],
       languageOptions: {
         sourceType: "script"
       },
-      ...configs$7.cjs
+      ...configs$8.cjs
     },
     {
       files: ["**/*.ts", "**/*.tsx"],
@@ -589,4 +704,4 @@ function defaultConfig(parserOptions) {
   ];
 }
 
-export { defaultConfig, configs$7 as eslintConfigs, configs$6 as jsdocConfigs, configs$4 as promiseConfigs, configs$3 as reactConfigs, configs$2 as securityConfigs, configs$1 as typescriptEslintConfigs, configs as unicornConfigs };
+export { defaultConfig, configs$8 as eslintConfigs, configs$6 as jsdocConfigs, configs$4 as promiseConfigs, configs$3 as reactConfigs, configs$2 as securityConfigs, configs$1 as typescriptEslintConfigs, configs as unicornConfigs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-decent",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A decent ESLint configuration",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",

package/src/extension.ts

@@ -0,0 +1,30 @@
+import type { ConfigWithExtends } from 'typescript-eslint';
+import { requireExtensionRule } from './rules/requireExtensionRule.js';
+import { requireIndexRule } from './rules/requireIndexRule.js';
+
+const base: ConfigWithExtends = {
+  plugins: {
+    'decent-extension': {
+      meta: {
+        name: 'decent-extension',
+        version: '1.0.0',
+      },
+      rules: {
+        'require-extension': requireExtensionRule,
+        'require-index': requireIndexRule,
+      },
+    },
+  },
+  rules: {
+    'decent-extension/require-extension': 'error',
+    'decent-extension/require-index': 'error',
+  },
+};
+
+export const configs = {
+  base,
+};
+
+export default {
+  configs,
+};

package/src/index.ts

@@ -3,6 +3,7 @@ import globals from 'globals';
 import tsEslint, { type ConfigWithExtends } from 'typescript-eslint';
 import prettier from 'eslint-plugin-prettier/recommended';
 import { configs as eslintConfigs } from './eslint.js';
+import { configs as extensionConfigs } from './extension.js';
 import { configs as jsdocConfigs } from './jsdoc.js';
 import { configs as mochaConfigs } from './mocha.js';
 import { configs as promiseConfigs } from './promise.js';
@@ -21,7 +22,13 @@ export {
   unicornConfigs,
 };
 
-export function defaultConfig(parserOptions?: NonNullable<ConfigWithExtends['languageOptions']>['parserOptions']): ConfigWithExtends[] {
+export interface DefaultConfigOptions {
+  parserOptions?: NonNullable<ConfigWithExtends['languageOptions']>['parserOptions'];
+  enableRequireExtensionRule?: boolean;
+}
+
+export function defaultConfig(options?: DefaultConfigOptions): ConfigWithExtends[] {
+  const enableRequireExtensionRule = options?.enableRequireExtensionRule ?? true;
   const languageOptions: ConfigWithExtends['languageOptions'] = {
     globals: {
       ...globals.node,
@@ -33,7 +40,7 @@ export function defaultConfig(parserOptions?: NonNullable<ConfigWithExtends['lan
         defaultProject: 'tsconfig.json',
       },
       tsconfigRootDir: import.meta.dirname,
-      ...parserOptions,
+      ...options?.parserOptions,
     },
   };
 
@@ -53,6 +60,7 @@ export function defaultConfig(parserOptions?: NonNullable<ConfigWithExtends['lan
     {
       files: ['**/*.ts', '**/*.js', '**/*.cjs', '**/*.mjs', '**/*.tsx'],
       plugins: {
+        ...extensionConfigs.base.plugins,
         ...jsdocConfigs.base.plugins,
         ...promiseConfigs.base.plugins,
         ...securityConfigs.base.plugins,
@@ -60,6 +68,7 @@ export function defaultConfig(parserOptions?: NonNullable<ConfigWithExtends['lan
       },
       rules: {
         ...eslintConfigs.base.rules,
+        ...(enableRequireExtensionRule ? extensionConfigs.base.rules : {}),
         ...jsdocConfigs.base.rules,
         ...promiseConfigs.base.rules,
         ...securityConfigs.base.rules,

package/src/rules/requireExtensionRule.ts

@@ -0,0 +1,54 @@
+import { existsSync } from 'fs';
+import { dirname, resolve } from 'path';
+import type { Rule } from 'eslint';
+
+export const requireExtensionRule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Ensure import and export statements include a file extension',
+      category: 'Best Practices',
+      recommended: true,
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  create(context: Rule.RuleContext) {
+    function checkSource(source: Parameters<NonNullable<Rule.NodeListener['ImportDeclaration']>>[0]['source']): void {
+      const importPath = source.value as string;
+
+      if (!importPath || !importPath.startsWith('.') || importPath.endsWith('.js')) {
+        return;
+      }
+
+      const resolvedPath = resolve(dirname(context.filename), importPath);
+
+      // If the import/export path doesn't end with a file extension, report an error
+      // eslint-disable-next-line security/detect-non-literal-fs-filename
+      if (!existsSync(resolvedPath)) {
+        context.report({
+          node: source,
+          message: 'Relative imports and exports must include a file extension.',
+          fix(fixer) {
+            const fixedPath = `${importPath}.js`;
+            return fixer.replaceText(source, `'${fixedPath}'`);
+          },
+        });
+      }
+    }
+
+    return {
+      ImportDeclaration(node: Parameters<NonNullable<Rule.NodeListener['ImportDeclaration']>>[0]): void {
+        checkSource(node.source);
+      },
+      ExportNamedDeclaration(node: Parameters<NonNullable<Rule.NodeListener['ExportNamedDeclaration']>>[0]): void {
+        if (node.source) {
+          checkSource(node.source);
+        }
+      },
+      ExportAllDeclaration(node: Parameters<NonNullable<Rule.NodeListener['ExportAllDeclaration']>>[0]): void {
+        checkSource(node.source);
+      },
+    };
+  },
+};

package/src/rules/requireIndexRule.ts

@@ -0,0 +1,51 @@
+import { existsSync, lstatSync } from 'fs';
+import { resolve, dirname } from 'path';
+import type { Rule } from 'eslint';
+
+export const requireIndexRule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Ensure directory import and export statements use index.js',
+      category: 'Best Practices',
+      recommended: true,
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  create(context: Rule.RuleContext) {
+    function checkSource(source: Parameters<NonNullable<Rule.NodeListener['ImportDeclaration']>>[0]['source']): void {
+      const importPath = source.value as string;
+
+      // Resolve the path relative to the file being linted
+      const resolvedPath = resolve(dirname(context.filename), importPath);
+
+      // eslint-disable-next-line security/detect-non-literal-fs-filename
+      const isDirectory = existsSync(resolvedPath) && lstatSync(resolvedPath).isDirectory();
+      if (isDirectory) {
+        context.report({
+          node: source,
+          message: 'Directory imports and exports must use index.js.',
+          fix(fixer) {
+            const fixedPath = importPath.replace(/\/?$/, '/index.js');
+            return fixer.replaceText(source, `'${fixedPath}'`);
+          },
+        });
+      }
+    }
+
+    return {
+      ImportDeclaration(node: Parameters<NonNullable<Rule.NodeListener['ImportDeclaration']>>[0]): void {
+        checkSource(node.source);
+      },
+      ExportNamedDeclaration(node: Parameters<NonNullable<Rule.NodeListener['ExportNamedDeclaration']>>[0]): void {
+        if (node.source) {
+          checkSource(node.source);
+        }
+      },
+      ExportAllDeclaration(node: Parameters<NonNullable<Rule.NodeListener['ExportAllDeclaration']>>[0]): void {
+        checkSource(node.source);
+      },
+    };
+  },
+};