eslint-config-vylda-typescript 5.0.0

package/rules/imports.mjs

@@ -0,0 +1,119 @@
+// @ts-check
+import {
+  defaultImportExtensions as die,
+  defaultImportExtensionsRuleGranularOption as diergov,
+  defaultImportNoExtraneousDependenciesDevDependencies as dinedddv,
+  defaultImportResolverNodeExtensions as dirne,
+  getImportConfig as getVanillaImportConfig,
+} from 'eslint-config-vylda-vanilla';
+
+/**
+ * Create dependencies fot typescript
+ * @param {Array.<string>} dependencies Dependencies to update
+ * @returns {Array.<string>}
+ */
+const createTsDevDependencies = (dependencies) => dependencies.reduce(
+
+  /**
+   * @param {Array<string>} result
+   * @param {string} devDep
+   */
+  (result, devDep) => {
+    const toAppend = [devDep];
+    const tsDevDep = devDep.replace(/\bjs(x?)\b/g, 'ts$1');
+
+    if (tsDevDep !== devDep) {
+      toAppend.push(tsDevDep);
+    }
+
+    return [...result, ...toAppend];
+  },
+  [],
+);
+
+const ctdd = createTsDevDependencies(dinedddv);
+
+export const defaultImportExtensions = [
+  ...die,
+  '.mts',
+  '.ts',
+].sort();
+
+export const defaultImportExtensionsRuleGranularOption = {
+  ...diergov,
+  ts: 'never',
+};
+export const defaultImportResolverNodeExtensions = [
+  ...dirne,
+  '.mts',
+  '.ts',
+].sort();
+export const defaultImportNoExtraneousDependenciesDevDependencies = ctdd;
+
+const diergo = defaultImportExtensionsRuleGranularOption;
+const dineddd = defaultImportNoExtraneousDependenciesDevDependencies;
+
+const defaultOptions = {
+  importExtensions: defaultImportExtensions,
+  importExtensionsRuleGranularOption: diergo,
+  importNoExtraneousDependenciesDevDependencies: dineddd,
+  importResolverNodeExtensions: defaultImportResolverNodeExtensions,
+};
+
+/**
+ * Return import config for ESLint
+ * @param {string} tsConfigPath - path to tsconfig.json
+ * @param {Object} [options] - options, for default values see Readme.md
+ * @param {Array.<string>} [options.importExtensions=['.js', '.json', '.mjs', '.mts', '.ts']] - extensions for import/resolver.node.extensions
+ * @param {Object.<string, string>} [options.importExtensionsRuleGranularOption] - granural oprions for import/extensions rule; for defaultValues see Readme.md
+ * @param {Array.<string>} [options.importNoExtraneousDependenciesDevDependencies=['see Readme.md']] - devDependencies for import/no-extraneous-dependencies rule
+ * @param {Array.<string>} [options.importResolverNodeExtensions=['.js', '.mjs', '.mts', '.ts']] - extensions for import/extensions
+ * @returns {Array.<Object>} - ESLint Flat config
+ */
+const getImportConfig = (
+  tsConfigPath,
+  options = defaultOptions,
+) => {
+  const {
+    importExtensions = defaultImportExtensions,
+    importExtensionsRuleGranularOption = diergo,
+    importNoExtraneousDependenciesDevDependencies = dineddd,
+    importResolverNodeExtensions = defaultImportResolverNodeExtensions,
+  } = options;
+
+  const [config] = getVanillaImportConfig({
+    importExtensions,
+    importExtensionsRuleGranularOption,
+    importNoExtraneousDependenciesDevDependencies,
+    importResolverNodeExtensions,
+  });
+
+  const { settings = {}, ...rest } = config;
+
+  return [
+    {
+      ...rest,
+      name: '@typescript-eslint/imports',
+      settings: {
+        ...settings || {},
+        'import/resolver': {
+          node: {
+            extensions: importResolverNodeExtensions,
+          },
+          typescript: {
+            // always try to resolve types under `<root>@types` directory even it doesn't contain any source code, like `@types/unist`
+            alwaysTryTypes: true,
+            // use <root>/path/to/folder/tsconfig.json or <root>/path/to/folder/jsconfig.json
+            // use a glob pattern
+            // use an array
+            // use an array of glob patterns
+            // https://www.npmjs.com/package/eslint-import-resolver-typescript#eslint-plugin-import
+            project: tsConfigPath,
+          },
+        },
+      },
+    },
+  ];
+};
+
+export default getImportConfig;

package/rules/index.mjs

@@ -0,0 +1,10 @@
+// @ts-check
+export { default as defaultTs } from './defaultTs.mjs';
+export { default as getImportConfig } from './imports.mjs';
+export { default as off } from './off.mjs';
+export { default as plus } from './plus.mjs';
+export { default as tsStrict } from './strictTs.mjs';
+export { default as tsStylistic } from './stylisticTs.mjs';
+export { default as tsConfig } from './typescriptConfig.mjs';
+export { default as getVanillaConfig } from './vanillaConfig.mjs';
+export { default as tsVariables } from './variablesTs.mjs';

package/rules/off.mjs

@@ -0,0 +1,64 @@
+// @ts-check
+
+// The following rules are enabled config, but are already checked (more thoroughly) by the TypeScript compiler
+// Some of the rules also fail in TypeScript files, for example: https://github.com/typescript-eslint/typescript-eslint/issues/662#issuecomment-507081586
+// Rules are inspired by: https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/src/configs/eslint-recommended.ts
+
+/** @type {import('eslint').Linter.Config[]} */
+const config = [
+  {
+    name: 'typescript eslint/vanilla eslint off rules',
+
+    /** @type {import('eslint').Linter.RulesRecord} */
+    rules: {
+      'class-methods-use-this': 'off',
+      'consistent-return': 'off',
+      'constructor-super': 'off',
+      'default-param-last': 'off',
+      'dot-notation': 'off',
+      'getter-return': 'off',
+      'import/named': 'off',
+      'import/no-named-as-default-member': 'off',
+      'init-declarations': 'off',
+      'max-params': 'off',
+      'no-array-constructor': 'off',
+      'no-class-assign': 'off',
+      'no-const-assign': 'off',
+      'no-dupe-args': 'off',
+      'no-dupe-class-members': 'off',
+      'no-dupe-keys': 'off',
+      'no-empty-function': 'off',
+      'no-func-assign': 'off',
+      'no-implied-eval': 'off',
+      'no-import-assign': 'off',
+      'no-invalid-this': 'off',
+      'no-loop-func': 'off',
+      'no-magic-numbers': 'off',
+      'no-new-native-nonconstructor': 'off',
+      'no-obj-calls': 'off',
+      'no-redeclare': 'off',
+      'no-setter-return': 'off',
+      'no-shadow': 'off',
+      'no-this-before-super': 'off',
+      'no-throw-literal': 'off',
+      'no-undef': 'off',
+      'no-unreachable': 'off',
+      'no-unsafe-negation': 'off',
+      'no-unused-expressions': 'off',
+      'no-unused-vars': 'off',
+      'no-use-before-define': 'off',
+      'no-useless-constructor': 'off',
+      'no-var': 'error',
+      'no-with': 'off',
+      'prefer-const': 'error',
+      'prefer-destructuring': 'off',
+      'prefer-promise-reject-errors': 'off',
+      'prefer-rest-params': 'error',
+      'prefer-spread': 'error',
+      'require-await': 'off',
+      'valid-typeof': 'off',
+    },
+  },
+];
+
+export default config;

package/rules/plus.mjs

@@ -0,0 +1,22 @@
+import { plus } from 'eslint-config-vylda-vanilla';
+
+/** @type {import('eslint').Linter.Config[]} */
+const config = [
+  ...plus,
+  {
+    name: '@typescript-eslint/plus',
+
+    /** @type {import('eslint').Linter.RulesRecord} */
+    rules: {
+      // Enforces consistent spacing inside TypeScript type generics.
+      // https://eslint.style/rules/plus/type-generic-spacing
+      '@stylistic/type-generic-spacing': 'error',
+
+      // Expect space before the type declaration in the named tuple.
+      // https://eslint.style/rules/plus/type-named-tuple-spacing
+      '@stylistic/type-named-tuple-spacing': 'error',
+    },
+  },
+];
+
+export default config;

package/rules/strictTs.mjs

@@ -0,0 +1,115 @@
+// @ts-check
+const config = [
+  {
+    name: 'typescript-eslint/recommended-strict-only',
+
+    /** @type {import('eslint').Linter.RulesRecord} */
+    rules: {
+      // Disallows awaiting a value that is not a Thenable (e.g., Promise).
+      // https://typescript-eslint.io/rules/await-thenable/
+      '@typescript-eslint/await-thenable': 'error',
+
+      // Disallows using the 'delete' operator on array elements.
+      // https://typescript-eslint.io/rules/no-array-delete/
+      '@typescript-eslint/no-array-delete': 'error',
+
+      // Disallows calling toString() on objects without a custom implementation.
+      // https://typescript-eslint.io/rules/no-base-to-string/
+      '@typescript-eslint/no-base-to-string': 'error',
+
+      // Disallows duplicate members in union and intersection types.
+      // https://typescript-eslint.io/rules/no-duplicate-type-constituents/
+      '@typescript-eslint/no-duplicate-type-constituents': 'error',
+
+      // Disallows unhandled Promises.
+      // https://typescript-eslint.io/rules/no-floating-promises/
+      '@typescript-eslint/no-floating-promises': 'error',
+
+      // Disallows iterating over an array with a for-in loop.
+      // https://typescript-eslint.io/rules/no-for-in-array/
+      '@typescript-eslint/no-for-in-array': 'error',
+
+      // Disallows the use of eval()-like methods.
+      // https://typescript-eslint.io/rules/no-implied-eval/
+      '@typescript-eslint/no-implied-eval': 'error',
+
+      // Disallows providing Promises to places not designed to handle them.
+      // https://typescript-eslint.io/rules/no-misused-promises/
+      '@typescript-eslint/no-misused-promises': 'error',
+
+      // Disallows redundant type constituents in union and intersection types.
+      // https://typescript-eslint.io/rules/no-redundant-type-constituents/
+      '@typescript-eslint/no-redundant-type-constituents': 'error',
+
+      // Disallow using type assertions that do not change the type of an expression.
+      // https://typescript-eslint.io/rules/no-unnecessary-type-assertion/
+      '@typescript-eslint/no-unnecessary-type-assertion': 'error',
+
+      // Disallows unnecessary constraints on generic types.
+      // https://typescript-eslint.io/rules/no-unnecessary-type-constraint/
+      '@typescript-eslint/no-unnecessary-type-constraint': 'error',
+
+      // Disallows calling a function with an 'any' typed argument.
+      // https://typescript-eslint.io/rules/no-unsafe-argument/
+      '@typescript-eslint/no-unsafe-argument': 'error',
+
+      // Disallow assigning a value with type 'any' to variables and properties.
+      // https://typescript-eslint.io/rules/no-unsafe-assignment/
+      '@typescript-eslint/no-unsafe-assignment': 'error',
+
+      // Disallows calling a value with type 'any'.
+      // https://typescript-eslint.io/rules/no-unsafe-call/
+      '@typescript-eslint/no-unsafe-call': 'error',
+
+      // Disallows comparing an enum value with a non-enum value.
+      // https://typescript-eslint.io/rules/no-unsafe-enum-comparison/
+      '@typescript-eslint/no-unsafe-enum-comparison': 'error',
+
+      // Disallows member access on variables with type 'any'.
+      // https://typescript-eslint.io/rules/no-unsafe-member-access/
+      '@typescript-eslint/no-unsafe-member-access': 'error',
+
+      // Disallow returning a value with type 'any' from a function.
+      // https://typescript-eslint.io/rules/no-unsafe-return/
+      '@typescript-eslint/no-unsafe-return': 'error',
+
+      // Disallows using the unary minus operator on values of type 'any'.
+      // https://typescript-eslint.io/rules/no-unsafe-unary-minus/
+      '@typescript-eslint/no-unsafe-unary-minus': 'error',
+
+      // Disallows throwing literals as exceptions.
+      // https://typescript-eslint.io/rules/only-throw-error/
+      '@typescript-eslint/only-throw-error': [
+        'error',
+        {
+          allow: [],
+          allowRethrowing: false,
+          allowThrowingAny: true,
+          allowThrowingUnknown: true,
+        },
+      ],
+
+      // Disallows using Promise.reject with non-Error values.
+      // https://typescript-eslint.io/rules/prefer-promise-reject-errors/
+      '@typescript-eslint/prefer-promise-reject-errors': 'error',
+
+      // Disallows async functions which have no 'await' expression.
+      // https://typescript-eslint.io/rules/require-await/
+      '@typescript-eslint/require-await': 'error',
+
+      // Disallows the use of the '+' operator with non-string operands.
+      // https://typescript-eslint.io/rules/restrict-plus-operands/
+      '@typescript-eslint/restrict-plus-operands': 'error',
+
+      // Disallows template expressions that might result in '[object Object]'.
+      // https://typescript-eslint.io/rules/restrict-template-expressions/
+      '@typescript-eslint/restrict-template-expressions': 'error',
+
+      // Enforce unbound methods are called with their expected scope.
+      // https://typescript-eslint.io/rules/unbound-method/
+      '@typescript-eslint/unbound-method': 'error',
+    },
+  },
+];
+
+export default config;