@perfective/eslint-config 0.29.2 → 0.31.0

package/config/jest/typescript-eslint-jest-rules.d.ts

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

package/config/jest/typescript-eslint-jest-rules.js

@@ -0,0 +1,5 @@
+export const typescriptEslintJestRules = {
+  'jest/unbound-method': ['error', {
+    ignoreStatic: false
+  }]
+};

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

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

package/config/jest-dom/index.js

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

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

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

package/config/jest-dom/jest-dom-config.js

@@ -0,0 +1,23 @@
+import eslintPluginJestDom from 'eslint-plugin-jest-dom';
+import { jestFiles } from "../../linter/glob.js";
+export function jestDomConfig(files = jestFiles) {
+  return {
+    files,
+    plugins: {
+      'jest-dom': eslintPluginJestDom
+    },
+    rules: {
+      'jest-dom/prefer-checked': 'warn',
+      'jest-dom/prefer-empty': 'warn',
+      'jest-dom/prefer-enabled-disabled': 'warn',
+      'jest-dom/prefer-focus': 'warn',
+      'jest-dom/prefer-in-document': 'off',
+      'jest-dom/prefer-required': 'warn',
+      'jest-dom/prefer-to-have-attribute': 'warn',
+      'jest-dom/prefer-to-have-class': 'warn',
+      'jest-dom/prefer-to-have-style': 'warn',
+      'jest-dom/prefer-to-have-text-content': 'warn',
+      'jest-dom/prefer-to-have-value': 'warn'
+    }
+  };
+}

package/config/jsdoc/jsdoc-config.d.ts

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

package/config/jsdoc/jsdoc-config.js

@@ -0,0 +1,179 @@
+import eslintPluginJsdoc from 'eslint-plugin-jsdoc';
+import { javascriptFiles } from "../../linter/glob.js";
+import { javascriptLanguageOptions } from "../../linter/language-options.js";
+export function jsdocConfig() {
+  return {
+    plugins: {
+      jsdoc: {
+        rules: eslintPluginJsdoc.configs['flat/recommended'].plugins['jsdoc'].rules
+      }
+    },
+    settings: {
+      jsdoc: {
+        tagNamePreference: {
+          augments: {
+            message: 'Use @extends instead of @augments as it is more evocative of classes than @augments',
+            replacement: 'extends'
+          },
+          todo: {
+            message: 'Use TODO for comments'
+          },
+          fires: {
+            replacement: 'emits'
+          }
+        },
+        ignoreReplacesDocs: true,
+        overrideReplacesDocs: true,
+        augmentsExtendsReplacesDocs: false,
+        implementsReplacesDoc: false
+      }
+    },
+    rules: {
+      'jsdoc/check-access': 'off',
+      'jsdoc/check-alignment': 'error',
+      'jsdoc/check-examples': 'off',
+      'jsdoc/check-indentation': 'off',
+      'jsdoc/check-line-alignment': ['off', 'never'],
+      'jsdoc/check-param-names': ['error', {
+        allowExtraTrailingParamDocs: false,
+        checkDestructured: true,
+        checkRestProperty: false,
+        disableExtraPropertyReporting: false,
+        disableMissingParamChecks: false,
+        enableFixer: true,
+        useDefaultObjectProperties: false
+      }],
+      'jsdoc/check-property-names': ['error', {
+        enableFixer: true
+      }],
+      'jsdoc/check-syntax': 'error',
+      'jsdoc/check-tag-names': ['error', {
+        definedTags: ['final', 'flags', 'sealed', 'workaround'],
+        jsxTags: true
+      }],
+      'jsdoc/check-template-names': 'error',
+      'jsdoc/check-types': ['error', {
+        noDefaults: false
+      }],
+      'jsdoc/check-values': 'error',
+      'jsdoc/convert-to-jsdoc-comments': 'off',
+      'jsdoc/empty-tags': ['error', {
+        tags: ['final', 'flags', 'sealed']
+      }],
+      'jsdoc/implements-on-classes': 'error',
+      'jsdoc/imports-as-dependencies': 'error',
+      'jsdoc/lines-before-block': 'off',
+      'jsdoc/match-description': 'error',
+      'jsdoc/match-name': 'off',
+      'jsdoc/multiline-blocks': ['warn', {
+        noZeroLineText: true,
+        noFinalLineText: true,
+        noSingleLineBlocks: true,
+        singleLineTags: ['lends', 'type', 'deprecated'],
+        noMultilineBlocks: false,
+        multilineTags: ['*'],
+        allowMultipleTags: true
+      }],
+      'jsdoc/no-bad-blocks': ['error', {
+        ignore: ['ts-check', 'ts-expect-error', 'ts-ignore', 'ts-nocheck', 'typescript-eslint'],
+        preventAllMultiAsteriskBlocks: false
+      }],
+      'jsdoc/no-blank-blocks': 'warn',
+      'jsdoc/no-blank-block-descriptions': 'off',
+      'jsdoc/no-defaults': 'error',
+      'jsdoc/no-missing-syntax': 'off',
+      'jsdoc/no-multi-asterisks': ['error', {
+        allowWhitespace: false,
+        preventAtMiddleLines: true,
+        preventAtEnd: true
+      }],
+      'jsdoc/no-restricted-syntax': 'off',
+      'jsdoc/no-types': 'error',
+      'jsdoc/no-undefined-types': 'error',
+      'jsdoc/require-asterisk-prefix': ['error', 'always'],
+      'jsdoc/require-description': ['error', {
+        exemptedBy: ['inheritdoc', 'package', 'private', 'see', 'deprecated']
+      }],
+      'jsdoc/require-description-complete-sentence': 'warn',
+      'jsdoc/require-example': 'off',
+      'jsdoc/require-file-overview': 'off',
+      'jsdoc/require-hyphen-before-param-description': ['warn', 'always'],
+      'jsdoc/require-jsdoc': 'off',
+      'jsdoc/require-param': 'off',
+      'jsdoc/require-param-description': 'error',
+      'jsdoc/require-param-name': 'error',
+      'jsdoc/require-param-type': 'off',
+      'jsdoc/require-property': 'error',
+      'jsdoc/require-property-description': 'error',
+      'jsdoc/require-property-name': 'error',
+      'jsdoc/require-property-type': 'error',
+      'jsdoc/require-returns': 'off',
+      'jsdoc/require-returns-check': 'error',
+      'jsdoc/require-returns-description': 'error',
+      'jsdoc/require-returns-type': 'off',
+      'jsdoc/require-template': ['off', {
+        requireSeparateTemplates: false
+      }],
+      'jsdoc/require-throws': 'error',
+      'jsdoc/require-yields': 'error',
+      'jsdoc/require-yields-check': 'error',
+      'jsdoc/sort-tags': ['warn', {
+        tagSequence: [{
+          tags: ['summary', 'typeSummary']
+        }, {
+          tags: ['module', 'exports', 'file', 'fileoverview', 'overview']
+        }, {
+          tags: ['typedef', 'interface', 'record', 'template', 'name', 'kind', 'type', 'alias', 'external', 'host', 'callback', 'func', 'function', 'method', 'class', 'constructor']
+        }, {
+          tags: ['modifies', 'mixes', 'mixin', 'mixinClass', 'mixinFunction', 'namespace', 'borrows', 'constructs', 'lends', 'implements', 'requires']
+        }, {
+          tags: ['desc', 'description', 'classdesc', 'tutorial', 'copyright', 'license']
+        }, {
+          tags: ['const', 'constant', 'final', 'global', 'readonly', 'abstract', 'virtual', 'var', 'member', 'memberof', 'memberof!', 'inner', 'instance', 'inheritdoc', 'inheritDoc', 'override', 'hideconstructor']
+        }, {
+          tags: ['param', 'arg', 'argument', 'prop', 'property']
+        }, {
+          tags: ['async', 'generator', 'default', 'defaultvalue', 'enum', 'augments', 'extends', 'return', 'returns', 'throws', 'exception', 'yield', 'yields', 'event', 'fires', 'emits', 'listens', 'this']
+        }, {
+          tags: ['static', 'private', 'protected', 'public', 'access', 'package']
+        }, {
+          tags: ['see', 'example']
+        }, {
+          tags: ['closurePrimitive', 'customElement', 'expose', 'hidden', 'idGenerator', 'meaning', 'ngInject', 'owner', 'wizaction']
+        }, {
+          tags: ['define', 'dict', 'export', 'externs', 'implicitCast', 'noalias', 'nocollapse', 'nocompile', 'noinline', 'nosideeffects', 'polymer', 'polymerBehavior', 'preserve', 'struct', 'suppress', 'unrestricted']
+        }, {
+          tags: ['category']
+        }, {
+          tags: ['ignore', 'author', 'version', 'variation', 'since', 'deprecated', 'todo']
+        }],
+        alphabetizeExtras: false,
+        linesBetween: 1,
+        reportTagGroupSpacing: true,
+        reportIntraTagGroupSpacing: true
+      }],
+      'jsdoc/tag-lines': ['warn', 'always', {
+        count: 0,
+        startLines: 1,
+        endLines: 0,
+        applyToEndTag: false,
+        tags: {}
+      }],
+      'jsdoc/valid-types': 'error'
+    }
+  };
+}
+export function jsdocJavascriptConfig() {
+  return {
+    files: javascriptFiles,
+    languageOptions: javascriptLanguageOptions(),
+    rules: {
+      'jsdoc/no-types': 'off',
+      'jsdoc/no-undefined-types': 'off',
+      'jsdoc/require-param': 'error',
+      'jsdoc/require-param-type': 'error',
+      'jsdoc/require-returns': 'error',
+      'jsdoc/require-returns-type': 'error'
+    }
+  };
+}

package/config/node/node-config.d.ts

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

package/config/node/node-config.js

@@ -0,0 +1,66 @@
+import eslintPluginN from 'eslint-plugin-n';
+export function nodeConfig() {
+  return {
+    plugins: {
+      n: eslintPluginN
+    },
+    rules: {
+      'n/callback-return': ['error', ['callback', 'cb', 'next']],
+      'n/exports-style': ['warn', 'module.exports', {
+        allowBatchAssign: false
+      }],
+      'n/file-extension-in-import': 'off',
+      'n/global-require': 'error',
+      'n/handle-callback-err': 'error',
+      'n/hashbang': 'warn',
+      'n/no-callback-literal': 'error',
+      'n/no-deprecated-api': 'error',
+      'n/no-exports-assign': 'error',
+      'n/no-extraneous-import': 'off',
+      'n/no-extraneous-require': 'off',
+      'n/no-hide-core-modules': 'off',
+      'n/no-missing-import': 'off',
+      'n/no-missing-require': 'off',
+      'n/no-mixed-requires': 'error',
+      'n/no-new-require': 'error',
+      'n/no-path-concat': 'error',
+      'n/no-process-env': 'error',
+      'n/no-process-exit': 'off',
+      'n/no-restricted-import': 'error',
+      'n/no-restricted-require': 'error',
+      'n/no-sync': ['error', {
+        allowAtRootLevel: false
+      }],
+      'n/no-unpublished-bin': 'error',
+      'n/no-unpublished-import': ['error', {
+        ignorePrivate: false
+      }],
+      'n/no-unpublished-require': ['error', {
+        allowModules: [],
+        ignorePrivate: false,
+        tryExtensions: ['.js', '.json', '.node']
+      }],
+      'n/no-unsupported-features/es-builtins': ['error', {
+        version: '>=18.0.0',
+        ignores: []
+      }],
+      'n/no-unsupported-features/es-syntax': 'off',
+      'n/no-unsupported-features/node-builtins': ['error', {
+        version: '>=18.0.0',
+        ignores: []
+      }],
+      'n/prefer-global/buffer': ['error', 'always'],
+      'n/prefer-global/console': ['error', 'always'],
+      'n/prefer-global/process': ['error', 'always'],
+      'n/prefer-global/text-decoder': ['error', 'always'],
+      'n/prefer-global/text-encoder': ['error', 'always'],
+      'n/prefer-global/url': ['error', 'always'],
+      'n/prefer-global/url-search-params': ['error', 'always'],
+      'n/prefer-node-protocol': 'off',
+      'n/prefer-promises/dns': 'error',
+      'n/prefer-promises/fs': 'error',
+      'n/process-exit-as-throw': 'error',
+      'n/shebang': 'off'
+    }
+  };
+}

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

@@ -0,0 +1,6 @@
+import { Linter } from 'eslint';
+import { LinterConfig } from '../linter/linter-config';
+/**
+ * Returns an array of flat configs.
+ */
+export declare function perfectiveEslintConfig(configs?: LinterConfig[]): Linter.Config[];

package/config/perfective-eslint-config.js

@@ -0,0 +1,45 @@
+import { configurationFiles, typescriptDeclarationFiles } from "../linter/glob.js";
+import { languageOptions } from "../linter/language-options.js";
+import { linterConfig } from "../linter/linter-config.js";
+import { arrayFuncConfig } from "./array-func/array-func-config.js";
+import { eslintConfig } from "./eslint/eslint-config.js";
+import { eslintCommentsConfig } from "./eslint-comments/eslint-comments-config.js";
+import { importConfig, importJavascriptConfig, importTypescriptConfig } from "./import/import-config.js";
+import { importNoExtraneousDependencies } from "./import/index.js";
+import { jsdocConfig, jsdocJavascriptConfig } from "./jsdoc/jsdoc-config.js";
+import { nodeConfig } from "./node/node-config.js";
+import { preferArrowConfig } from "./prefer-arrow/prefer-arrow-config.js";
+import { promiseConfig } from "./promise/promise-config.js";
+import { securityConfig } from "./security/security-config.js";
+import { simpleImportSortConfig } from "./simple-import-sort/simple-import-sort-config.js";
+import { stylisticJsConfig } from "./stylistic/js/stylistic-js-config.js";
+import { stylisticJsxConfig } from "./stylistic/jsx/stylistic-jsx-config.js";
+import { stylisticPlusConfig } from "./stylistic/plus/stylistic-plus-config.js";
+import { stylisticTsConfig } from "./stylistic/ts/stylistic-ts-config.js";
+import { typescriptEslintConfig } from "./typescript-eslint/typescript-eslint-config.js";
+import { unicornConfig } from "./unicorn/unicorn-config.js";
+export function perfectiveEslintConfig(configs = []) {
+  return [{
+    languageOptions: languageOptions()
+  }, {
+    ignores: ['**/dist', typescriptDeclarationFiles]
+  }, eslintConfig(), typescriptEslintConfig(), arrayFuncConfig(), eslintCommentsConfig(), importConfig(), importJavascriptConfig(), importTypescriptConfig(), jsdocConfig(), jsdocJavascriptConfig(), nodeConfig(), preferArrowConfig(), promiseConfig(), securityConfig(), simpleImportSortConfig(), stylisticJsConfig(), stylisticJsxConfig(), stylisticPlusConfig(), stylisticTsConfig(), unicornConfig(), configurationFilesConfig()].concat(configs.map(linterConfig));
+}
+function configurationFilesConfig() {
+  return {
+    files: configurationFiles,
+    rules: {
+      'import/extensions': ['error', 'ignorePackages'],
+      'import/no-default-export': ['off'],
+      'import/no-extraneous-dependencies': ['error', importNoExtraneousDependencies({
+        devDependencies: configurationFiles
+      })],
+      'n/no-unpublished-import': ['error', {
+        allowModules: ['gulp', '@perfective/build'],
+        convertPath: {
+          'dist/**/*.js': ['^dist/(.+)?\\.js$', '$1.js']
+        }
+      }]
+    }
+  };
+}

package/config/prefer-arrow/prefer-arrow-config.d.ts

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

package/config/prefer-arrow/prefer-arrow-config.js

@@ -0,0 +1,16 @@
+import eslintPluginPreferArrow from 'eslint-plugin-prefer-arrow';
+export function preferArrowConfig() {
+  return {
+    plugins: {
+      'prefer-arrow': eslintPluginPreferArrow
+    },
+    rules: {
+      'prefer-arrow/prefer-arrow-functions': ['error', {
+        allowStandaloneDeclarations: true,
+        classPropertiesAllowed: false,
+        disallowPrototype: false,
+        singleReturnOnly: false
+      }]
+    }
+  };
+}

package/config/promise/promise-config.d.ts

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

package/config/promise/promise-config.js

@@ -0,0 +1,37 @@
+import eslintPluginPromise from 'eslint-plugin-promise';
+export function promiseConfig() {
+  return {
+    plugins: {
+      promise: eslintPluginPromise
+    },
+    rules: {
+      'promise/catch-or-return': ['error', {
+        allowThen: false,
+        allowThenStrict: false,
+        allowFinally: true
+      }],
+      'promise/no-return-wrap': 'error',
+      'promise/param-names': 'warn',
+      'promise/always-return': ['error', {
+        ignoreAssignmentVariable: ['globalThis']
+      }],
+      'promise/no-multiple-resolved': 'error',
+      'promise/no-native': 'off',
+      'promise/no-nesting': 'error',
+      'promise/no-promise-in-callback': 'error',
+      'promise/no-callback-in-promise': ['error', {
+        timeoutsErr: false
+      }],
+      'promise/avoid-new': 'off',
+      'promise/no-new-statics': 'warn',
+      'promise/no-return-in-finally': 'error',
+      'promise/prefer-catch': 'warn',
+      'promise/spec-only': ['error', {
+        allowedMethods: []
+      }],
+      'promise/valid-params': 'error',
+      'promise/prefer-await-to-then': 'off',
+      'promise/prefer-await-to-callbacks': 'off'
+    }
+  };
+}

package/config/rxjs/index.d.ts

@@ -0,0 +1 @@
+export { rxjsConfig } from './rxjs-config';

package/config/rxjs/index.js

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

package/config/rxjs/rxjs-config.d.ts

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

package/config/rxjs/rxjs-config.js

@@ -0,0 +1,67 @@
+import eslintPluginRxjs from 'eslint-plugin-rxjs-x';
+import { typescriptFiles } from "../../linter/glob.js";
+import { typescriptLanguageOptions } from "../../linter/language-options.js";
+export function rxjsConfig(files = typescriptFiles) {
+  return {
+    files,
+    languageOptions: typescriptLanguageOptions(),
+    plugins: {
+      'rxjs-x': eslintPluginRxjs.configs.recommended.plugins['rxjs-x']
+    },
+    rules: {
+      'rxjs-x/ban-observables': 'error',
+      'rxjs-x/ban-operators': ['error', {
+        tap: false
+      }],
+      'rxjs-x/finnish': ['error', {
+        functions: true,
+        methods: true,
+        names: {},
+        parameters: true,
+        properties: true,
+        strict: true,
+        types: {},
+        variables: true
+      }],
+      'rxjs-x/just': 'off',
+      'rxjs-x/no-async-subscribe': 'error',
+      'rxjs-x/no-compat': 'error',
+      'rxjs-x/no-connectable': 'error',
+      'rxjs-x/no-create': 'error',
+      'rxjs-x/no-cyclic-action': 'error',
+      'rxjs-x/no-explicit-generics': 'off',
+      'rxjs-x/no-exposed-subjects': 'error',
+      'rxjs-x/no-finnish': 'off',
+      'rxjs-x/no-floating-observables': 'error',
+      'rxjs-x/no-ignored-error': 'error',
+      'rxjs-x/no-ignored-notifier': 'error',
+      'rxjs-x/no-ignored-observable': 'off',
+      'rxjs-x/no-ignored-replay-buffer': 'error',
+      'rxjs-x/no-ignored-subscribe': 'error',
+      'rxjs-x/no-ignored-subscription': 'error',
+      'rxjs-x/no-ignored-takewhile-value': 'error',
+      'rxjs-x/no-implicit-any-catch': ['off', {
+        allowExplicitAny: false
+      }],
+      'rxjs-x/no-index': 'error',
+      'rxjs-x/no-internal': 'warn',
+      'rxjs-x/no-nested-subscribe': 'error',
+      'rxjs-x/no-redundant-notify': 'error',
+      'rxjs-x/no-sharereplay': 'off',
+      'rxjs-x/no-subclass': 'error',
+      'rxjs-x/no-subject-unsubscribe': 'error',
+      'rxjs-x/no-subject-value': 'error',
+      'rxjs-x/no-subscribe-handlers': 'off',
+      'rxjs-x/no-topromise': 'error',
+      'rxjs-x/no-unbound-methods': 'error',
+      'rxjs-x/no-unsafe-catch': 'error',
+      'rxjs-x/no-unsafe-first': 'error',
+      'rxjs-x/no-unsafe-subject-next': 'error',
+      'rxjs-x/no-unsafe-switchmap': 'error',
+      'rxjs-x/no-unsafe-takeuntil': 'error',
+      'rxjs-x/prefer-observer': 'off',
+      'rxjs-x/suffix-subjects': 'off',
+      'rxjs-x/throw-error': 'error'
+    }
+  };
+}

package/config/security/security-config.d.ts

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

package/config/security/security-config.js

@@ -0,0 +1,24 @@
+import eslintPluginSecurity from 'eslint-plugin-security';
+export function securityConfig() {
+  return {
+    plugins: {
+      security: eslintPluginSecurity
+    },
+    rules: {
+      'security/detect-bidi-characters': 'error',
+      'security/detect-buffer-noassert': 'error',
+      'security/detect-child-process': 'error',
+      'security/detect-disable-mustache-escape': 'error',
+      'security/detect-eval-with-expression': 'error',
+      'security/detect-new-buffer': 'error',
+      'security/detect-no-csrf-before-method-override': 'error',
+      'security/detect-non-literal-fs-filename': 'error',
+      'security/detect-non-literal-regexp': 'error',
+      'security/detect-non-literal-require': 'error',
+      'security/detect-object-injection': 'error',
+      'security/detect-possible-timing-attacks': 'error',
+      'security/detect-pseudoRandomBytes': 'error',
+      'security/detect-unsafe-regex': 'error'
+    }
+  };
+}

package/config/simple-import-sort/index.d.ts

@@ -0,0 +1 @@
+export { SimpleImportSortImports, simpleImportSortImports, } from './rules/imports';

package/config/simple-import-sort/index.js

@@ -0,0 +1 @@
+export { simpleImportSortImports } from "./rules/imports.js";

package/config/simple-import-sort/rules/imports.d.ts

@@ -0,0 +1,28 @@
+export type Match = string;
+export type Group = Match[];
+/**
+ * Configuration options for the `simple-import-sort/imports` rule.
+ *
+ * @since v0.11.0
+ */
+export interface SimpleImportSortImports {
+    groups: Group[];
+}
+/**
+ * Creates configuration for the `simple-import-sort/imports` ESLint rule.
+ *
+ * Allows to splice `internal` scope packages imports between the global and relative imports.
+ *
+ * @param internal - A list of internal scopes. Each scope is sorted in its own group.
+ *
+ * @since v0.11.0
+ */
+export declare function simpleImportSortImports(internal?: string[]): SimpleImportSortImports;
+/**
+ * @private
+ */
+export declare function scopedPackages(exclude: string[]): Group;
+/**
+ * @private
+ */
+export declare function internalPackages(internal: string[]): Group[];

package/config/simple-import-sort/rules/imports.js

@@ -0,0 +1,32 @@
+export function simpleImportSortImports(internal = []) {
+  return {
+    groups: [sideEffects(), nodePrefixedModules(), unscopedPackages(), scopedPackages(internal), ...internalPackages(internal), parentImports(), relativeImports(), styleImports()].filter(group => group.length > 0)
+  };
+}
+function sideEffects() {
+  return ['^\\u0000'];
+}
+function nodePrefixedModules() {
+  return ['^node:'];
+}
+function unscopedPackages() {
+  return ['^[a-zA-Z]'];
+}
+export function scopedPackages(exclude) {
+  if (exclude.length === 0) {
+    return ['^@'];
+  }
+  return [`^(?!${exclude.join('|')})@`];
+}
+export function internalPackages(internal) {
+  return internal.map(scope => [`^${scope}`]);
+}
+function parentImports() {
+  return ['^\\.\\.(?!/?$)', '^\\.\\./?$'];
+}
+function relativeImports() {
+  return ['^\\./(?=.*/)(?!/?$)', '^\\.(?!/?$)', '^\\./?$'];
+}
+function styleImports() {
+  return ['^.+\\.s?css$'];
+}

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

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

package/config/simple-import-sort/simple-import-sort-config.js

@@ -0,0 +1,13 @@
+import eslintPluginSimpleImportSort from 'eslint-plugin-simple-import-sort';
+import { simpleImportSortImports } from "./rules/imports.js";
+export function simpleImportSortConfig() {
+  return {
+    plugins: {
+      'simple-import-sort': eslintPluginSimpleImportSort
+    },
+    rules: {
+      'simple-import-sort/exports': 'warn',
+      'simple-import-sort/imports': ['warn', simpleImportSortImports()]
+    }
+  };
+}

package/config/stylistic/js/stylistic-js-config.d.ts

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