@perfective/eslint-config 0.29.2 → 0.31.0

package/config/eslint/possible-problems-rules.js

@@ -0,0 +1,96 @@
+export const eslintPossibleProblemsRules = {
+  'array-callback-return': ['error', {
+    allowImplicit: true,
+    checkForEach: false,
+    allowVoid: false
+  }],
+  'constructor-super': 'error',
+  'for-direction': 'error',
+  'getter-return': 'error',
+  'no-async-promise-executor': 'error',
+  'no-await-in-loop': 'error',
+  'no-class-assign': 'error',
+  'no-compare-neg-zero': 'error',
+  'no-cond-assign': ['error', 'always'],
+  'no-const-assign': 'error',
+  'no-constant-binary-expression': 'error',
+  'no-constant-condition': 'error',
+  'no-constructor-return': 'error',
+  'no-control-regex': 'error',
+  'no-debugger': 'error',
+  'no-dupe-args': 'error',
+  'no-dupe-class-members': 'error',
+  'no-dupe-else-if': 'error',
+  'no-dupe-keys': 'error',
+  'no-duplicate-case': 'error',
+  'no-duplicate-imports': ['off', {
+    includeExports: true
+  }],
+  'no-empty-character-class': 'error',
+  'no-empty-pattern': 'error',
+  'no-ex-assign': 'error',
+  'no-fallthrough': ['error', {
+    allowEmptyCase: false,
+    reportUnusedFallthroughComment: true
+  }],
+  'no-func-assign': 'error',
+  'no-import-assign': 'error',
+  'no-inner-declarations': 'error',
+  'no-invalid-regexp': 'error',
+  'no-irregular-whitespace': ['error', {
+    skipStrings: false,
+    skipComments: false,
+    skipRegExps: false,
+    skipTemplates: false,
+    skipJSXText: false
+  }],
+  'no-loss-of-precision': 'error',
+  'no-misleading-character-class': ['error', {
+    allowEscape: false
+  }],
+  'no-new-native-nonconstructor': 'error',
+  'no-new-symbol': 'error',
+  'no-obj-calls': 'error',
+  'no-promise-executor-return': 'error',
+  'no-prototype-builtins': 'error',
+  'no-self-assign': 'error',
+  'no-self-compare': 'error',
+  'no-setter-return': 'error',
+  'no-sparse-arrays': 'error',
+  'no-template-curly-in-string': 'error',
+  'no-this-before-super': 'error',
+  'no-undef': 'off',
+  'no-unexpected-multiline': 'error',
+  'no-unmodified-loop-condition': 'error',
+  'no-unreachable': 'error',
+  'no-unreachable-loop': 'error',
+  'no-unsafe-finally': 'error',
+  'no-unsafe-negation': 'error',
+  'no-unsafe-optional-chaining': 'error',
+  'no-unused-private-class-members': 'error',
+  'no-unused-vars': ['error', {
+    args: 'after-used',
+    argsIgnorePattern: '^_',
+    caughtErrors: 'all',
+    destructuredArrayIgnorePattern: '^_',
+    ignoreClassWithStaticInitBlock: false,
+    ignoreRestSiblings: false,
+    reportUsedIgnorePattern: false,
+    vars: 'all'
+  }],
+  'no-use-before-define': ['error', {
+    functions: false,
+    classes: false,
+    variables: false,
+    allowNamedExports: false
+  }],
+  'no-useless-backreference': 'error',
+  'no-useless-assignment': 'error',
+  'require-atomic-updates': ['error', {
+    allowProperties: false
+  }],
+  'use-isnan': 'error',
+  'valid-typeof': ['error', {
+    requireStringLiterals: true
+  }]
+};

package/config/eslint/suggestions-rules.d.ts

@@ -0,0 +1,2 @@
+import { Linter } from 'eslint';
+export declare const eslintSuggestionsRules: Linter.RulesRecord;

package/config/eslint/suggestions-rules.js

@@ -0,0 +1,181 @@
+export const eslintSuggestionsRules = {
+  'accessor-pairs': 'error',
+  'arrow-body-style': ['warn', 'as-needed'],
+  'block-scoped-var': 'error',
+  'camelcase': 'off',
+  'capitalized-comments': ['warn', 'always', {
+    ignorePattern: 'eslint|tslint',
+    ignoreConsecutiveComments: true
+  }],
+  'class-methods-use-this': 'off',
+  'complexity': ['error', 3],
+  'consistent-return': 'error',
+  'consistent-this': ['error', 'self'],
+  'curly': ['warn', 'all'],
+  'default-case': 'error',
+  'default-case-last': 'error',
+  'default-param-last': 'error',
+  'dot-notation': ['warn', {
+    allowKeywords: true
+  }],
+  'eqeqeq': ['warn', 'always'],
+  'func-name-matching': ['error', 'always'],
+  'func-names': ['error', 'always'],
+  'func-style': ['error', 'declaration'],
+  'grouped-accessor-pairs': ['error', 'setBeforeGet'],
+  'guard-for-in': 'error',
+  'id-denylist': ['error', 'arr', 'ctx', 'el', 'elem', 'err', 'ind', 'ptr'],
+  'id-length': 'off',
+  'id-match': 'off',
+  'init-declarations': ['error', 'always'],
+  'logical-assignment-operators': ['warn', 'always', {
+    enforceForIfStatements: true
+  }],
+  'max-classes-per-file': ['error', 1],
+  'max-depth': ['error', 4],
+  'max-lines': 'off',
+  'max-lines-per-function': 'off',
+  'max-nested-callbacks': ['error', 2],
+  'max-params': ['off', {
+    max: 3
+  }],
+  'max-statements': ['off', {
+    max: 10
+  }],
+  'multiline-comment-style': 'off',
+  'new-cap': ['error', {
+    newIsCap: true,
+    capIsNew: true,
+    properties: true
+  }],
+  'no-alert': 'error',
+  'no-array-constructor': 'error',
+  'no-bitwise': 'error',
+  'no-caller': 'error',
+  'no-case-declarations': 'error',
+  'no-confusing-arrow': 'off',
+  'no-console': 'error',
+  'no-continue': 'error',
+  'no-delete-var': 'error',
+  'no-div-regex': 'warn',
+  'no-else-return': ['warn', {
+    allowElseIf: false
+  }],
+  'no-empty': 'error',
+  'no-empty-function': 'error',
+  'no-empty-static-block': 'error',
+  'no-eq-null': 'error',
+  'no-eval': 'error',
+  'no-extend-native': 'error',
+  'no-extra-bind': 'warn',
+  'no-extra-boolean-cast': ['warn', {
+    enforceForInnerExpressions: true
+  }],
+  'no-extra-label': 'warn',
+  'no-extra-semi': 'off',
+  'no-floating-decimal': 'off',
+  'no-global-assign': 'error',
+  'no-implicit-coercion': 'warn',
+  'no-implicit-globals': 'error',
+  'no-implied-eval': 'error',
+  'no-inline-comments': ['error', {
+    ignorePattern: '^ == .+'
+  }],
+  'no-invalid-this': 'error',
+  'no-iterator': 'error',
+  'no-label-var': 'error',
+  'no-labels': 'error',
+  'no-lone-blocks': 'error',
+  'no-lonely-if': 'warn',
+  'no-loop-func': 'error',
+  'no-magic-numbers': 'off',
+  'no-mixed-operators': 'off',
+  'no-multi-assign': 'error',
+  'no-multi-str': 'error',
+  'no-negated-condition': 'off',
+  'no-nested-ternary': 'error',
+  'no-new': 'error',
+  'no-new-func': 'error',
+  'no-new-object': 'off',
+  'no-new-wrappers': 'error',
+  'no-nonoctal-decimal-escape': 'error',
+  'no-object-constructor': 'error',
+  'no-octal': 'error',
+  'no-octal-escape': 'error',
+  'no-param-reassign': 'error',
+  'no-plusplus': ['error', {
+    allowForLoopAfterthoughts: true
+  }],
+  'no-proto': 'error',
+  'no-redeclare': 'error',
+  'no-regex-spaces': 'warn',
+  'no-restricted-exports': 'off',
+  'no-restricted-globals': 'error',
+  'no-restricted-imports': 'error',
+  'no-restricted-properties': 'error',
+  'no-restricted-syntax': ['error', 'ForInStatement'],
+  'no-return-assign': 'error',
+  'no-script-url': 'error',
+  'no-sequences': ['error', {
+    allowInParentheses: false
+  }],
+  'no-shadow': 'off',
+  'no-shadow-restricted-names': 'error',
+  'no-ternary': 'off',
+  'no-throw-literal': 'error',
+  'no-undef-init': 'warn',
+  'no-undefined': 'off',
+  'no-underscore-dangle': ['error', {
+    allowAfterSuper: false,
+    allowAfterThis: true,
+    allowAfterThisConstructor: false,
+    allowFunctionParams: true,
+    enforceInMethodNames: true,
+    enforceInClassFields: true
+  }],
+  'no-unneeded-ternary': 'warn',
+  'no-unused-expressions': 'error',
+  'no-unused-labels': 'warn',
+  'no-useless-call': 'error',
+  'no-useless-catch': 'error',
+  'no-useless-computed-key': 'warn',
+  'no-useless-concat': 'error',
+  'no-useless-constructor': 'error',
+  'no-useless-escape': 'error',
+  'no-useless-rename': 'warn',
+  'no-useless-return': 'warn',
+  'no-var': 'warn',
+  'no-void': 'error',
+  'no-warning-comments': 'off',
+  'no-with': 'error',
+  'object-shorthand': ['warn', 'always'],
+  'one-var': ['warn', 'never'],
+  'one-var-declaration-per-line': 'off',
+  'operator-assignment': ['warn', 'always'],
+  'prefer-arrow-callback': 'warn',
+  'prefer-const': 'warn',
+  'prefer-destructuring': 'off',
+  'prefer-exponentiation-operator': 'warn',
+  'prefer-named-capture-group': 'off',
+  'prefer-numeric-literals': 'warn',
+  'prefer-object-has-own': 'off',
+  'prefer-object-spread': 'warn',
+  'prefer-promise-reject-errors': 'error',
+  'prefer-regex-literals': 'off',
+  'prefer-rest-params': 'error',
+  'prefer-spread': 'error',
+  'prefer-template': 'warn',
+  'quote-props': 'off',
+  'radix': 'error',
+  'require-await': 'error',
+  'require-unicode-regexp': 'error',
+  'require-yield': 'error',
+  'sort-imports': 'off',
+  'sort-keys': 'off',
+  'sort-vars': 'off',
+  'spaced-comment': 'off',
+  'strict': 'warn',
+  'symbol-description': 'error',
+  'vars-on-top': 'error',
+  'yoda': ['warn', 'never']
+};

package/config/eslint-comments/best-practices-rules.d.ts

@@ -0,0 +1,2 @@
+import { Linter } from 'eslint';
+export declare const bestPracticesRules: Linter.RulesRecord;

package/config/eslint-comments/best-practices-rules.js

@@ -0,0 +1,8 @@
+export const bestPracticesRules = {
+  'eslint-comments/disable-enable-pair': 'error',
+  'eslint-comments/no-aggregating-enable': 'error',
+  'eslint-comments/no-duplicate-disable': 'error',
+  'eslint-comments/no-unlimited-disable': 'error',
+  'eslint-comments/no-unused-disable': 'error',
+  'eslint-comments/no-unused-enable': 'error'
+};

package/config/eslint-comments/eslint-comments-config.d.ts

@@ -0,0 +1,2 @@
+import { Linter } from 'eslint';
+export declare function eslintCommentsConfig(): Linter.Config;

package/config/eslint-comments/eslint-comments-config.js

@@ -0,0 +1,11 @@
+import eslintPluginEslintComments from '@eslint-community/eslint-plugin-eslint-comments';
+import { bestPracticesRules } from "./best-practices-rules.js";
+import { stylisticIssuesRules } from "./stylistic-issues-rules.js";
+export function eslintCommentsConfig() {
+  return {
+    plugins: {
+      'eslint-comments': eslintPluginEslintComments
+    },
+    rules: Object.assign(Object.assign({}, bestPracticesRules), stylisticIssuesRules)
+  };
+}

package/config/eslint-comments/stylistic-issues-rules.d.ts

@@ -0,0 +1,2 @@
+import { Linter } from 'eslint';
+export declare const stylisticIssuesRules: Linter.RulesRecord;

package/config/eslint-comments/stylistic-issues-rules.js

@@ -0,0 +1,9 @@
+export const stylisticIssuesRules = {
+  'eslint-comments/no-restricted-disable': 'off',
+  'eslint-comments/no-use': ['error', {
+    allow: ['eslint-disable', 'eslint-disable-next-line', 'eslint-enable']
+  }],
+  'eslint-comments/require-description': ['error', {
+    ignore: ['eslint-enable']
+  }]
+};

package/config/import/helpful-warnings-rules.d.ts

@@ -0,0 +1,2 @@
+import { Linter } from 'eslint';
+export declare const helpfulWarningsRules: Linter.RulesRecord;

package/config/import/helpful-warnings-rules.js

@@ -0,0 +1,11 @@
+import { importNoExtraneousDependencies } from "./rules/no-extraneous-dependencies.js";
+export const helpfulWarningsRules = {
+  'import/export': 'error',
+  'import/no-deprecated': 'off',
+  'import/no-empty-named-blocks': 'warn',
+  'import/no-extraneous-dependencies': ['error', importNoExtraneousDependencies()],
+  'import/no-mutable-exports': 'error',
+  'import/no-named-as-default': 'error',
+  'import/no-named-as-default-member': 'error',
+  'import/no-unused-modules': 'error'
+};

package/config/import/import-config.d.ts

@@ -0,0 +1,4 @@
+import { Linter } from 'eslint';
+export declare function importConfig(): Linter.Config;
+export declare function importJavascriptConfig(): Linter.Config;
+export declare function importTypescriptConfig(): Linter.Config;

package/config/import/import-config.js

@@ -0,0 +1,46 @@
+import { flatConfigs } from 'eslint-plugin-import';
+import { javascriptFiles, typescriptFiles } from "../../linter/glob.js";
+import { javascriptLanguageOptions, typescriptLanguageOptions } from "../../linter/language-options.js";
+import { helpfulWarningsRules } from "./helpful-warnings-rules.js";
+import { moduleSystemsRules } from "./module-systems-rules.js";
+import { staticAnalysisRules } from "./static-analysis-rules.js";
+import { styleGuideRules } from "./style-guide-rules.js";
+export function importConfig() {
+  return {
+    plugins: {
+      import: flatConfigs.recommended.plugins.import
+    },
+    rules: Object.assign(Object.assign(Object.assign(Object.assign({}, staticAnalysisRules), helpfulWarningsRules), moduleSystemsRules), styleGuideRules)
+  };
+}
+export function importJavascriptConfig() {
+  return {
+    files: javascriptFiles,
+    languageOptions: javascriptLanguageOptions(),
+    plugins: {},
+    settings: {
+      'import/extensions': ['.js', '.jsx']
+    },
+    rules: {
+      'import/no-commonjs': 'off',
+      'import/unambiguous': 'off'
+    }
+  };
+}
+export function importTypescriptConfig() {
+  return {
+    files: typescriptFiles,
+    languageOptions: typescriptLanguageOptions(),
+    settings: {
+      'import/parsers': {
+        '@typescript-eslint/parser': ['.ts', '.tsx']
+      },
+      'import/resolver': {
+        typescript: {
+          alwaysTryTypes: true,
+          project: './tsconfig.json'
+        }
+      }
+    }
+  };
+}

package/config/import/index.d.ts

@@ -0,0 +1 @@
+export { ImportNoExtraneousDependencies, importNoExtraneousDependencies, } from './rules/no-extraneous-dependencies';

package/config/import/index.js

@@ -0,0 +1 @@
+export { importNoExtraneousDependencies } from "./rules/no-extraneous-dependencies.js";

package/config/import/module-systems-rules.d.ts

@@ -0,0 +1,2 @@
+import { Linter } from 'eslint';
+export declare const moduleSystemsRules: Linter.RulesRecord;

package/config/import/module-systems-rules.js

@@ -0,0 +1,10 @@
+export const moduleSystemsRules = {
+  'import/no-amd': 'error',
+  'import/no-commonjs': ['error', {
+    allowConditionalRequire: true,
+    allowPrimitiveModules: true
+  }],
+  'import/no-import-module-exports': 'error',
+  'import/no-nodejs-modules': 'off',
+  'import/unambiguous': 'error'
+};

package/config/import/rules/no-extraneous-dependencies.d.ts

@@ -0,0 +1,15 @@
+import { Glob } from '../../../linter/glob';
+/**
+ * Configuration options for the `import/no-extraneous-dependencies` rule.
+ */
+export interface ImportNoExtraneousDependencies {
+    devDependencies: boolean | Glob[];
+    optionalDependencies: boolean | Glob[];
+    peerDependencies: boolean | Glob[];
+    bundledDependencies: boolean | Glob[];
+    packageDir?: string;
+}
+/**
+ * Returns configuration for the `import/no-extraneous-dependencies` rule.
+ */
+export declare function importNoExtraneousDependencies(overrides?: Partial<ImportNoExtraneousDependencies>): ImportNoExtraneousDependencies;

package/config/import/rules/no-extraneous-dependencies.js

@@ -0,0 +1,8 @@
+export function importNoExtraneousDependencies(overrides = {}) {
+  return Object.assign({
+    bundledDependencies: true,
+    devDependencies: false,
+    optionalDependencies: false,
+    peerDependencies: false
+  }, overrides);
+}

package/config/import/static-analysis-rules.d.ts

@@ -0,0 +1,2 @@
+import { Linter } from 'eslint';
+export declare const staticAnalysisRules: Linter.RulesRecord;

package/config/import/static-analysis-rules.js

@@ -0,0 +1,26 @@
+export const staticAnalysisRules = {
+  'import/default': 'error',
+  'import/named': ['error', {
+    commonjs: false
+  }],
+  'import/namespace': 'error',
+  'import/no-absolute-path': 'error',
+  'import/no-cycle': ['error', {
+    ignoreExternal: true,
+    allowUnsafeDynamicCyclicDependency: false
+  }],
+  'import/no-dynamic-require': ['error', {
+    esmodule: true
+  }],
+  'import/no-internal-modules': 'off',
+  'import/no-relative-packages': 'warn',
+  'import/no-relative-parent-imports': 'off',
+  'import/no-restricted-paths': 'off',
+  'import/no-self-import': 'error',
+  'import/no-unresolved': ['error', {
+    caseSensitive: true,
+    caseSensitiveStrict: true
+  }],
+  'import/no-useless-path-segments': 'warn',
+  'import/no-webpack-loader-syntax': 'error'
+};

package/config/import/style-guide-rules.d.ts

@@ -0,0 +1,2 @@
+import { Linter } from 'eslint';
+export declare const styleGuideRules: Linter.RulesRecord;

package/config/import/style-guide-rules.js

@@ -0,0 +1,33 @@
+export const styleGuideRules = {
+  'import/consistent-type-specifier-style': ['warn', 'prefer-inline'],
+  'import/dynamic-import-chunkname': 'off',
+  'import/exports-last': 'off',
+  'import/extensions': ['error', 'never', {
+    checkTypeImports: true
+  }],
+  'import/first': 'off',
+  'import/group-exports': 'off',
+  'import/max-dependencies': 'off',
+  'import/newline-after-import': ['warn', {
+    considerComments: true
+  }],
+  'import/no-anonymous-default-export': 'error',
+  'import/no-default-export': 'error',
+  'import/no-duplicates': ['warn', {
+    'considerQueryString': true,
+    'prefer-inline': true
+  }],
+  'import/no-named-default': 'error',
+  'import/no-named-export': 'off',
+  'import/no-namespace': 'off',
+  'import/no-unassigned-import': 'error',
+  'import/order': ['off', {
+    'groups': ['unknown', 'builtin', 'external', 'internal', 'parent', 'sibling', 'index'],
+    'newlines-between': 'always',
+    'alphabetize': {
+      order: 'asc',
+      caseInsensitive: false
+    }
+  }],
+  'import/prefer-default-export': 'off'
+};

package/config/jest/index.d.ts

@@ -0,0 +1 @@
+export { jestConfig } from './jest-config';

package/config/jest/index.js

@@ -0,0 +1 @@
+export { jestConfig } from "./jest-config.js";

package/config/jest/jest-config.d.ts

@@ -0,0 +1,8 @@
+import { Linter } from 'eslint';
+import { Glob } from '../../linter/glob';
+/**
+ * Creates a flat config for `eslint-plugin-jest` for a given list of files globs.
+ *
+ * @since v0.31.0
+ */
+export declare function jestConfig(files?: Glob[]): Linter.Config;

package/config/jest/jest-config.js

@@ -0,0 +1,128 @@
+import eslintPluginJest from 'eslint-plugin-jest';
+import { jestFiles } from "../../linter/glob.js";
+import { importNoExtraneousDependencies } from "../import/index.js";
+import { typescriptEslintJestRules } from "./typescript-eslint-jest-rules.js";
+export function jestConfig(files = jestFiles) {
+  return {
+    files,
+    plugins: {
+      jest: eslintPluginJest
+    },
+    languageOptions: {
+      globals: eslintPluginJest.environments.globals.globals
+    },
+    rules: Object.assign(Object.assign(Object.assign({}, perfectiveRules()), typescriptEslintJestRules), {
+      'jest/consistent-test-it': ['warn', {
+        fn: 'test',
+        withinDescribe: 'it'
+      }],
+      'jest/expect-expect': ['error', {
+        assertFunctionNames: ['expect', 'request.*.expect'],
+        additionalTestBlockFunctions: []
+      }],
+      'jest/max-expects': ['error', {
+        max: 5
+      }],
+      'jest/max-nested-describe': ['error', {
+        max: 4
+      }],
+      'jest/no-alias-methods': 'warn',
+      'jest/no-commented-out-tests': 'error',
+      'jest/no-conditional-expect': 'error',
+      'jest/no-conditional-in-test': 'error',
+      'jest/no-confusing-set-timeout': 'error',
+      'jest/no-deprecated-functions': 'warn',
+      'jest/no-disabled-tests': 'error',
+      'jest/no-done-callback': 'error',
+      'jest/no-duplicate-hooks': 'error',
+      'jest/no-export': 'error',
+      'jest/no-focused-tests': 'warn',
+      'jest/no-hooks': 'off',
+      'jest/no-identical-title': 'error',
+      'jest/no-interpolation-in-snapshots': 'error',
+      'jest/no-jasmine-globals': 'warn',
+      'jest/no-large-snapshots': 'error',
+      'jest/no-mocks-import': 'error',
+      'jest/no-restricted-jest-methods': 'off',
+      'jest/no-restricted-matchers': ['error', {
+        toBeFalsy: 'Avoid `toBeFalsy`',
+        toBeTruthy: 'Avoid `toBeTruthy`',
+        toMatchSnapshot: 'Use `toMatchInlineSnapshot()` instead',
+        toThrowErrorMatchingSnapshot: 'Use `toThrowErrorMatchingInlineSnapshot()` instead'
+      }],
+      'jest/no-standalone-expect': 'error',
+      'jest/no-test-prefixes': 'warn',
+      'jest/no-test-return-statement': 'error',
+      'jest/no-untyped-mock-factory': 'warn',
+      'jest/padding-around-after-all-blocks': 'warn',
+      'jest/padding-around-after-each-blocks': 'warn',
+      'jest/padding-around-all': 'warn',
+      'jest/padding-around-before-all-blocks': 'warn',
+      'jest/padding-around-before-each-blocks': 'warn',
+      'jest/padding-around-describe-blocks': 'warn',
+      'jest/padding-around-expect-groups': 'warn',
+      'jest/padding-around-test-blocks': 'warn',
+      'jest/prefer-called-with': 'error',
+      'jest/prefer-comparison-matcher': 'warn',
+      'jest/prefer-each': 'error',
+      'jest/prefer-equality-matcher': 'error',
+      'jest/prefer-expect-assertions': 'off',
+      'jest/prefer-expect-resolves': 'warn',
+      'jest/prefer-hooks-in-order': 'error',
+      'jest/prefer-hooks-on-top': 'error',
+      'jest/prefer-importing-jest-globals': 'warn',
+      'jest/prefer-jest-mocked': 'warn',
+      'jest/prefer-lowercase-title': ['error', {
+        allowedPrefixes: [],
+        ignore: [],
+        ignoreTopLevelDescribe: true
+      }],
+      'jest/prefer-mock-promise-shorthand': 'warn',
+      'jest/prefer-snapshot-hint': ['error', 'always'],
+      'jest/prefer-spy-on': 'warn',
+      'jest/prefer-strict-equal': 'warn',
+      'jest/prefer-to-be': 'warn',
+      'jest/prefer-to-contain': 'warn',
+      'jest/prefer-to-have-length': 'warn',
+      'jest/prefer-todo': 'warn',
+      'jest/require-hook': ['error', {
+        allowedFunctionCalls: []
+      }],
+      'jest/require-to-throw-message': 'error',
+      'jest/require-top-level-describe': 'error',
+      'jest/valid-describe-callback': 'error',
+      'jest/valid-expect-in-promise': 'error',
+      'jest/valid-expect': 'error',
+      'jest/valid-title': ['warn', {
+        ignoreTypeOfDescribeName: true,
+        ignoreTypeOfTestName: false,
+        ignoreSpaces: false
+      }]
+    })
+  };
+}
+function perfectiveRules() {
+  return {
+    '@typescript-eslint/ban-ts-comment': ['error', {
+      'ts-expect-error': 'allow-with-description',
+      'ts-ignore': true,
+      'ts-nocheck': true,
+      'ts-check': false
+    }],
+    '@typescript-eslint/init-declarations': 'off',
+    '@typescript-eslint/unbound-method': 'off',
+    'import/no-extraneous-dependencies': ['error', importNoExtraneousDependencies({
+      devDependencies: jestFiles
+    })],
+    'import/no-unassigned-import': ['error', {
+      allow: ['@testing-library/jest-dom', '@testing-library/jest-dom/extend-expect']
+    }],
+    'max-nested-callbacks': ['error', 6],
+    'n/no-unpublished-import': ['error', {
+      allowModules: ['@jest/globals']
+    }],
+    'prefer-arrow/prefer-arrow-functions': 'off',
+    'promise/always-return': 'off',
+    '@smarttools/rxjs/no-topromise': 'off'
+  };
+}