@code-guideline/eslint/dist/index.d.ts

Code Guideline for eslint

import tsParser from '@typescript-eslint/parser';
import stylistic from '@stylistic/eslint-plugin';
import newlineDestructuring from 'eslint-plugin-newline-destructuring';
import importNewLines from 'eslint-plugin-import-newlines';
import simpleImportSort from 'eslint-plugin-simple-import-sort';
import unusedImports from 'eslint-plugin-unused-imports';
import typescript from '@typescript-eslint/eslint-plugin';

/**
 * @type {import('eslint').Linter.Config}
 */
const config$4 = {
  plugins: {
    '@stylistic': stylistic, 'newline-destructuring': newlineDestructuring,
  },
  files: ['**/*.{js,mjs,cjs,jsx,ts,mts,cts,tsx}'],
  rules: {
    '@stylistic/array-bracket-newline': [
      'error',
      {
        minItems:  3,
        multiline: true,
      },
    ],

    '@stylistic/array-bracket-spacing': ['error', 'never'],

    '@stylistic/array-element-newline': [
      'error',
      {
        ArrayExpression: 'consistent',
        ArrayPattern:    'consistent',
      },
    ],

    '@stylistic/arrow-parens': ['error', 'as-needed'],

    '@stylistic/arrow-spacing': [
      'error',
      {
        after:  true,
        before: true,
      },
    ],

    '@stylistic/block-spacing': ['error', 'always'],

    '@stylistic/brace-style': [
      'error',
      '1tbs',
      { allowSingleLine: true },
    ],

    '@stylistic/comma-dangle': ['error', 'always-multiline'],

    '@stylistic/comma-spacing': [
      'error',
      {
        after:  true,
        before: false,
      },
    ],

    '@stylistic/comma-style': ['error', 'last'],

    '@stylistic/computed-property-spacing': ['error', 'never'],

    '@stylistic/curly-newline': ['error', 'always'],

    '@stylistic/dot-location': ['error', 'property'],

    '@stylistic/eol-last': ['error', 'always'],

    '@stylistic/function-call-argument-newline': ['error', 'consistent'],

    '@stylistic/function-call-spacing': ['error', 'never'],

    '@stylistic/function-paren-newline': ['error', { minItems: 5 }],

    '@stylistic/generator-star-spacing': [
      'error',
      {
        after:  true,
        before: false,
      },
    ],

    '@stylistic/implicit-arrow-linebreak': ['error', 'beside'],

    '@stylistic/indent': ['error', 2],

    '@stylistic/indent-binary-ops': ['error', 2],

    '@stylistic/key-spacing': [
      'error',
      { align: {
        beforeColon: false,
        afterColon:  true,
        mode:        'strict',
        on:          'value',
      } },
    ],

    '@stylistic/keyword-spacing': [
      'error',
      {
        before: true,
        after:  true,
      },
    ],

    '@stylistic/line-comment-position': 'off',

    '@stylistic/linebreak-style': ['off', 'unix'],

    '@stylistic/lines-around-comment': [
      'error',
      {
        beforeLineComment:          true,
        allowClassStart:            false,
        allowClassEnd:              false,
        allowObjectStart:           false,
        allowObjectEnd:             false,
        allowArrayStart:            false,
        allowArrayEnd:              false,
        allowBlockStart:            true,
        allowBlockEnd:              false,
        allowEnumStart:             false,
        allowEnumEnd:               false,
        allowInterfaceStart:        false,
        allowInterfaceEnd:          false,
        allowModuleStart:           false,
        allowModuleEnd:             false,
        allowTypeStart:             false,
        allowTypeEnd:               false,
        applyDefaultIgnorePatterns: false,
        afterHashbangComment:       true,
      },
    ],

    '@stylistic/lines-between-class-members': [
      'error',
      { enforce: [
        {
          blankLine: 'always',
          prev:      'method',
          next:      'method',
        },
      ] },
    ],

    '@stylistic/max-len': [
      'error',
      {
        code:                   Number.POSITIVE_INFINITY,
        tabWidth:               2,
        comments:               100,
        ignoreComments:         true,
        ignoreTrailingComments: true,
        ignoreUrls:             true,
        ignoreStrings:          true,
        ignoreTemplateLiterals: true,
        ignoreRegExpLiterals:   true,
      },
    ],

    '@stylistic/max-statements-per-line': ['error', { max: 2 }],

    '@stylistic/member-delimiter-style': 'error',

    '@stylistic/multiline-comment-style': ['error', 'starred-block'],

    '@stylistic/multiline-ternary': ['error', 'always-multiline'],

    '@stylistic/new-parens': ['error', 'never'],

    '@stylistic/newline-per-chained-call': ['error', { ignoreChainWithDepth: 2 }],

    '@stylistic/no-confusing-arrow': ['error', { onlyOneSimpleParam: true }],

    '@stylistic/no-extra-parens': [
      'error',
      'all',
      {
        nestedBinaryExpressions:         false,
        ternaryOperandBinaryExpressions: false,
        ignoreJSX:                       'multi-line',
        nestedConditionalExpressions:    false,
        enforceForArrowConditionals:     false,
      },
    ],

    '@stylistic/no-extra-semi': 'error',

    '@stylistic/no-floating-decimal': 'error',

    '@stylistic/no-mixed-operators': 'error',

    '@stylistic/no-mixed-spaces-and-tabs': 'error',

    '@stylistic/no-multi-spaces': 'off',

    '@stylistic/no-multiple-empty-lines': [
      'error',
      {
        max:    1,
        maxBOF: 0,
        maxEOF: 1,
      },
    ],

    '@stylistic/no-tabs': 'error',

    '@stylistic/no-trailing-spaces': 'error',

    '@stylistic/no-whitespace-before-property': 'error',

    '@stylistic/nonblock-statement-body-position': ['error', 'beside'],

    '@stylistic/object-curly-newline': [
      'error',
      {
        ObjectExpression:  { minProperties: 2 },
        ObjectPattern:     { minProperties: 3 },
        ImportDeclaration: { minProperties: 4 },
        ExportDeclaration: 'always',
        TSTypeLiteral:     'always',
        TSInterfaceBody:   'always',
      },
    ],

    '@stylistic/object-curly-spacing': [
      'error',
      'always',
      { arraysInObjects: true },
    ],

    '@stylistic/object-property-newline': [
      'error',
      {
        allowAllPropertiesOnSameLine:   true,
        // allowMultiplePropertiesPerLine: true, // ESLint 9.x에서 지원하지 않으므로 삭제
      },
    ],

    '@stylistic/one-var-declaration-per-line': ['error', 'always'],

    '@stylistic/operator-linebreak': [
      'error',
      'after',
      { overrides: {
        '?': 'before',
        ':': 'before',
      } },
    ],

    '@stylistic/padded-blocks': ['error', 'never'],

    '@stylistic/padding-line-between-statements': [
      'error',
      {
        blankLine: 'always',
        prev:      '*',
        next:      '*',
      },
      {
        blankLine: 'any',
        prev:      'import',
        next:      'import',
      },
      {
        blankLine: 'never',
        prev:      'singleline-export',
        next:      'singleline-export',
      },
      {
        blankLine: 'never',
        prev:      'singleline-const',
        next:      'singleline-const',
      },
      {
        blankLine: 'never',
        prev:      'let',
        next:      'let',
      },
    ],

    '@stylistic/quote-props': ['error', 'as-needed'],

    '@stylistic/quotes': [
      'error',
      'single',
      { avoidEscape: true },
    ],

    '@stylistic/rest-spread-spacing': 'error',

    '@stylistic/semi': 'error',

    '@stylistic/semi-spacing': [
      'error',
      {
        before: false,
        after:  true,
      },
    ],

    '@stylistic/semi-style': 'error',

    '@stylistic/space-before-blocks': 'error',

    '@stylistic/space-before-function-paren': [
      'error',
      {
        anonymous:  'never',
        named:      'never',
        asyncArrow: 'always',
      },
    ],

    '@stylistic/space-in-parens': 'error',

    '@stylistic/space-infix-ops': 'error',

    '@stylistic/space-unary-ops': 'error',

    '@stylistic/spaced-comment': ['error', 'always'],

    '@stylistic/switch-colon-spacing': 'error',

    '@stylistic/template-curly-spacing': 'error',

    '@stylistic/template-tag-spacing': 'error',

    '@stylistic/type-annotation-spacing': 'error',

    '@stylistic/type-generic-spacing': 'error',

    '@stylistic/type-named-tuple-spacing': 'error',

    '@stylistic/wrap-iife': ['error', 'inside'],

    '@stylistic/wrap-regex': 'error',

    '@stylistic/yield-star-spacing': ['error', 'after'],

    'newline-destructuring/newline': ['error', { itemsWithRest: 2 }],
  },
};

/**
 * @type {import('eslint').Linter.Config}
 */
const config$3 = {
  plugins: {
    'simple-import-sort': simpleImportSort,
    'import-newlines':    importNewLines,
    'unused-imports':     unusedImports,
  },
  settings: { 'import/resolver': {
    typescript: {},
    node:       { extensions: [
      '.js',
      '.mjs',
      '.cjs',
      '.jsx',
      '.ts',
      '.mts',
      '.cts',
      '.tsx',
    ] },
  } },
  rules: {
    'simple-import-sort/imports': [
      'error',
      { groups: [
        ['^.+\\.css$'],
        [
          '^@?\\w',
          '^@/',
          '^\\.',
        ],
        ['^\\u0000'],
      ] },
    ],
    'import-newlines/enforce':          ['error', { items: 3 }],
    'unused-imports/no-unused-imports': 'error',
    'no-restricted-imports':            ['error', { patterns: ['../../*'] }],
    'no-restricted-syntax':             [
      'error',
      {
        selector: ':not(ImportDeclaration[source.value=/\.css$/]) > ImportNamespaceSpecifier',
        message:  'Importing entire module is not allowed.',
      },
    ],
  },
};

/**
 * @type {import('eslint').Linter.Config}
 */
const defaultConfig$2 = { rules: {
  'no-console':           ['warn', { allow: ['warn', 'error'] }],
  'no-debugger':          'error',
  'no-alert':             'error',
  'no-var':               'error',
  'no-duplicate-imports': 'error',
  'no-restricted-syntax': 'off',
} };

/**
 * @type {import('eslint').Linter.Config}
 */
const typescriptConfig$1 = {
  plugins: { '@typescript-eslint': typescript },
  files:   ['**/*.{js,ts,mjs,mts,cjs,cts,jsx,tsx}'],
  rules:   {
    '@typescript-eslint/no-explicit-any': 'error',
    '@typescript-eslint/no-unused-vars':  [
      'error',
      {
        varsIgnorePattern:              '^_',
        caughtErrorsIgnorePattern:      '^_',
        destructuredArrayIgnorePattern: '^_',
        argsIgnorePattern:              '^_',
      },
    ],
    'no-unused-vars': [
      'error',
      {
        varsIgnorePattern:              '^_',
        caughtErrorsIgnorePattern:      '^_',
        destructuredArrayIgnorePattern: '^_',
        argsIgnorePattern:              '^_',
      },
    ],
    'no-redeclare': 'error',
  },
};

var baseRestrictConfig = [defaultConfig$2, typescriptConfig$1];

/**
 * @type {import("eslint").Linter.Config}
 */
const config$2 = {
  plugins: { '@stylistic': stylistic },
  rules:   {
    '@stylistic/jsx-child-element-spacing': 'off',

    '@stylistic/jsx-closing-bracket-location': ['error', 'tag-aligned'],

    '@stylistic/jsx-closing-tag-location': ['error', 'line-aligned'],

    '@stylistic/jsx-curly-brace-presence': [
      'error',
      {
        props:             'never',
        children:          'never',
        propElementValues: 'always',
      },
    ],

    '@stylistic/jsx-curly-newline': [
      'error',
      {
        multiline:  'consistent',
        singleline: 'forbid',
      },
    ],

    '@stylistic/jsx-curly-spacing': [
      'error',
      'never',
      { allowMultiline: false },
    ],

    '@stylistic/jsx-equals-spacing': ['error', 'never'],

    '@stylistic/jsx-first-prop-new-line': ['error', 'multiline'],

    '@stylistic/jsx-function-call-newline': ['error', 'multiline'],

    '@stylistic/jsx-indent-props': ['error', 2],

    '@stylistic/jsx-max-props-per-line': 'error',

    '@stylistic/jsx-newline': [
      'error',
      {
        prevent:         true,
        allowMultilines: true,
      },
    ],

    '@stylistic/jsx-one-expression-per-line': ['error', { allow: 'non-jsx' }],

    '@stylistic/jsx-pascal-case': [
      'error',
      {
        allowAllCaps:   true,
        allowNamespace: true,
      },
    ],

    '@stylistic/jsx-props-no-multi-spaces': 'error',

    '@stylistic/jsx-quotes': ['error', 'prefer-single'],

    '@stylistic/jsx-self-closing-comp': [
      'error',
      {
        component: true,
        html:      true,
      },
    ],

    '@stylistic/jsx-sort-props': [
      'error',
      {
        ignoreCase:           true,
        callbacksLast:        true,
        shorthandFirst:       true,
        multiline:            'last',
        noSortAlphabetically: true,
        reservedFirst:        true,
      },
    ],

    '@stylistic/jsx-tag-spacing': [
      'error',
      {
        closingSlash:      'allow',
        beforeClosing:     'never',
        beforeSelfClosing: 'always',
      },
    ],

    '@stylistic/jsx-wrap-multilines': [
      'error',
      {
        declaration:   'parens-new-line',
        assignment:    'parens-new-line',
        return:        'parens-new-line',
        arrow:         'parens-new-line',
        condition:     'parens-new-line',
        logical:       'parens-new-line',
        prop:          'parens-new-line',
        propertyValue: 'parens',
      },
    ],
  },
};

/**
 * @type {import('eslint').Linter.Config}
 */
const config$1 = {
  plugins: {
    '@stylistic':            stylistic,
    'newline-destructuring': newlineDestructuring,
  },
  files: ['**/*.{js,mjs,cjs,jsx,ts,mts,cts,tsx}'],
  rules: {
    '@stylistic/array-bracket-newline': [
      'error',
      {
        minItems:  3,
        multiline: true,
      },
    ],
    '@stylistic/array-bracket-spacing': ['error', 'never'],
    '@stylistic/array-element-newline': [
      'error',
      {
        ArrayExpression: 'consistent',
        ArrayPattern:    'consistent',
      },
    ],
    '@stylistic/arrow-parens':  ['error', 'as-needed'],
    '@stylistic/arrow-spacing': [
      'error',
      {
        after:  true,
        before: true,
      },
    ],
    '@stylistic/block-spacing': ['error', 'always'],
    '@stylistic/brace-style':   [
      'error',
      '1tbs',
      { allowSingleLine: true },
    ],
    '@stylistic/comma-dangle':  ['error', 'always-multiline'],
    '@stylistic/comma-spacing': [
      'error',
      {
        after:  true,
        before: false,
      },
    ],
    '@stylistic/comma-style':                    ['error', 'last'],
    '@stylistic/computed-property-spacing':      ['error', 'never'],
    '@stylistic/curly-newline':                  ['error', 'always'],
    '@stylistic/dot-location':                   ['error', 'property'],
    '@stylistic/eol-last':                       ['error', 'always'],
    '@stylistic/function-call-argument-newline': ['error', 'consistent'],
    '@stylistic/function-call-spacing':          ['error', 'never'],
    '@stylistic/function-paren-newline':         ['error', { minItems: 5 }],
    '@stylistic/generator-star-spacing':         [
      'error',
      {
        after:  true,
        before: false,
      },
    ],
    '@stylistic/implicit-arrow-linebreak': ['error', 'beside'],
    '@stylistic/indent':                   ['error', 2],
    '@stylistic/indent-binary-ops':        ['error', 2],
    '@stylistic/key-spacing':              [
      'error',
      { align: {
        beforeColon: false,
        afterColon:  true,
        mode:        'strict',
        on:          'value',
      } },
    ],
    '@stylistic/keyword-spacing': [
      'error',
      {
        before: true,
        after:  true,
      },
    ],
    '@stylistic/line-comment-position': 'off',
    '@stylistic/linebreak-style':       ['off', 'unix'],
    '@stylistic/lines-around-comment':  [
      'error',
      {
        beforeLineComment:          true,
        allowClassStart:            false,
        allowClassEnd:              false,
        allowObjectStart:           false,
        allowObjectEnd:             false,
        allowArrayStart:            false,
        allowArrayEnd:              false,
        allowBlockStart:            true,
        allowBlockEnd:              false,
        allowEnumStart:             false,
        allowEnumEnd:               false,
        allowInterfaceStart:        false,
        allowInterfaceEnd:          false,
        allowModuleStart:           false,
        allowModuleEnd:             false,
        allowTypeStart:             false,
        allowTypeEnd:               false,
        applyDefaultIgnorePatterns: false,
        afterHashbangComment:       true,
      },
    ],
    '@stylistic/lines-between-class-members': [
      'error',
      { enforce: [
        {
          blankLine: 'always',
          prev:      'method',
          next:      'method',
        },
      ] },
    ],
    '@stylistic/max-len': [
      'error',
      {
        code:                   Number.POSITIVE_INFINITY,
        tabWidth:               2,
        comments:               100,
        ignoreComments:         true,
        ignoreTrailingComments: true,
        ignoreUrls:             true,
        ignoreStrings:          true,
        ignoreTemplateLiterals: true,
        ignoreRegExpLiterals:   true,
      },
    ],
    '@stylistic/max-statements-per-line':  ['error', { max: 2 }],
    '@stylistic/member-delimiter-style':   'error',
    '@stylistic/multiline-comment-style':  ['error', 'starred-block'],
    '@stylistic/multiline-ternary':        ['error', 'always-multiline'],
    '@stylistic/new-parens':               ['error', 'never'],
    '@stylistic/newline-per-chained-call': ['error', { ignoreChainWithDepth: 2 }],
    '@stylistic/no-confusing-arrow':       ['error', { onlyOneSimpleParam: true }],
    '@stylistic/no-extra-parens':          [
      'error',
      'all',
      {
        nestedBinaryExpressions:         false,
        ternaryOperandBinaryExpressions: false,
        ignoreJSX:                       'multi-line',
        nestedConditionalExpressions:    false,
        enforceForArrowConditionals:     false,
      },
    ],
    '@stylistic/no-extra-semi':            'error',
    '@stylistic/no-floating-decimal':      'error',
    '@stylistic/no-mixed-operators':       'error',
    '@stylistic/no-mixed-spaces-and-tabs': 'error',
    '@stylistic/no-multi-spaces':          'off',
    '@stylistic/no-multiple-empty-lines':  [
      'error',
      {
        max:    1,
        maxBOF: 0,
        maxEOF: 1,
      },
    ],
    '@stylistic/no-tabs':                          'error',
    '@stylistic/no-trailing-spaces':               'error',
    '@stylistic/no-whitespace-before-property':    'error',
    '@stylistic/nonblock-statement-body-position': ['error', 'beside'],
    '@stylistic/object-curly-newline':             [
      'error',
      {
        ObjectExpression:  { minProperties: 2 },
        ObjectPattern:     { minProperties: 3 },
        ImportDeclaration: { minProperties: 4 },
        ExportDeclaration: 'always',
        TSTypeLiteral:     'always',
        TSInterfaceBody:   'always',
      },
    ],
    '@stylistic/object-curly-spacing': [
      'error',
      'always',
      { arraysInObjects: true },
    ],
    '@stylistic/object-property-newline': [
      'error',
      {
        allowAllPropertiesOnSameLine:   true,
      },
    ],
    '@stylistic/one-var-declaration-per-line': ['error', 'always'],
    '@stylistic/operator-linebreak':           [
      'error',
      'after',
      { overrides: {
        '?': 'before',
        ':': 'before',
      } },
    ],
    '@stylistic/padded-blocks':                   ['error', 'never'],
    '@stylistic/padding-line-between-statements': [
      'error',
      {
        blankLine: 'always',
        prev:      '*',
        next:      '*',
      },
      {
        blankLine: 'any',
        prev:      'import',
        next:      'import',
      },
      {
        blankLine: 'never',
        prev:      'singleline-export',
        next:      'singleline-export',
      },
      {
        blankLine: 'never',
        prev:      'singleline-const',
        next:      'singleline-const',
      },
      {
        blankLine: 'never',
        prev:      'let',
        next:      'let',
      },
    ],
    '@stylistic/quote-props': ['error', 'as-needed'],
    '@stylistic/quotes':      [
      'error',
      'single',
      { avoidEscape: true },
    ],
    '@stylistic/rest-spread-spacing': 'error',
    '@stylistic/semi':                'error',
    '@stylistic/semi-spacing':        [
      'error',
      {
        before: false,
        after:  true,
      },
    ],
    '@stylistic/semi-style':                  'error',
    '@stylistic/space-before-blocks':         'error',
    '@stylistic/space-before-function-paren': [
      'error',
      {
        anonymous:  'never',
        named:      'never',
        asyncArrow: 'always',
      },
    ],
    '@stylistic/space-in-parens':          'error',
    '@stylistic/space-infix-ops':          'error',
    '@stylistic/space-unary-ops':          'error',
    '@stylistic/spaced-comment':           ['error', 'always'],
    '@stylistic/switch-colon-spacing':     'error',
    '@stylistic/template-curly-spacing':   'error',
    '@stylistic/template-tag-spacing':     'error',
    '@stylistic/type-annotation-spacing':  'error',
    '@stylistic/type-generic-spacing':     'error',
    '@stylistic/type-named-tuple-spacing': 'error',
    '@stylistic/wrap-iife':                ['error', 'inside'],
    '@stylistic/wrap-regex':               'error',
    '@stylistic/yield-star-spacing':       ['error', 'after'],
    'newline-destructuring/newline':       ['error', { itemsWithRest: 2 }],
  },
};

/**
 * @type {import('eslint').Linter.Config}
 */
const config = {
  plugins: {
    'simple-import-sort': simpleImportSort,
    'import-newlines':    importNewLines,
    'unused-imports':     unusedImports,
  },
  settings: { 'import/resolver': {
    typescript: {},
    node:       { extensions: [
      '.js',
      '.mjs',
      '.cjs',
      '.jsx',
      '.ts',
      '.mts',
      '.cts',
      '.tsx',
    ] },
  } },
};

/**
 * @type {import('eslint').Linter.Config}
 */
const defaultConfig$1 = { rules: {
  'no-console':           ['warn', { allow: ['warn', 'error'] }],
  'no-debugger':          'error',
  'no-alert':             'error',
  'no-var':               'error',
  'no-duplicate-imports': 'error',
  'no-restricted-syntax': 'off',
} };

/**
 * @type {import('eslint').Linter.Config}
 */
const typescriptConfig = {
  plugins: { '@typescript-eslint': typescript },
  files:   ['**/*.{js,ts,mjs,mts,cjs,cts,jsx,tsx}'],
  rules:   {
    '@typescript-eslint/no-explicit-any': 'error',
    '@typescript-eslint/no-unused-vars':  [
      'error',
      {
        varsIgnorePattern:              '^_',
        caughtErrorsIgnorePattern:      '^_',
        destructuredArrayIgnorePattern: '^_',
        argsIgnorePattern:              '^_',
      },
    ],
    'no-unused-vars': [
      'error',
      {
        varsIgnorePattern:              '^_',
        caughtErrorsIgnorePattern:      '^_',
        destructuredArrayIgnorePattern: '^_',
        argsIgnorePattern:              '^_',
      },
    ],
    'no-redeclare': 'error',
  },
};

var nestjsRestrictConfig = [defaultConfig$1, typescriptConfig];

const typedConfig = {
  languageOptions: {
    parser: tsParser,
    parserOptions: {
      project: './tsconfig.json',
      tsconfigRootDir: process.cwd(),
      sourceType: 'module',
    },
  },
};

var nestjsNestConfig = [
  typedConfig,
  config$1,
];

const configMap = {
  react: [config$2],
  nestjs: [
    config$1,
    config,
    ...nestjsRestrictConfig,
    ...nestjsNestConfig,
  ],
};

/**
 * @type {Array<import('eslint').Linter.Config>}
 */
const defaultConfig = [
  {
    languageOptions: {
      ecmaVersion:   'latest',
      sourceType:    'module',
      parser:        tsParser,
      parserOptions: { ecmaFeatures: { jsx: true } },
    },
    settings: { react: { version: 'detect' } },
  },
  { ignores: [
    '**/node_modules/**',
    '**/dist/**',
    '**/build/**',
    '**/.next/**',
    '**/next-env.d.ts',
  ] },
  config$4,
  config$3,
  ...baseRestrictConfig,
];

function eslintCodeGuideline(extendsConfig) {
  if (!extendsConfig) {
    return defaultConfig;
  }

  let configs = [...defaultConfig];

  if (extendsConfig) {
    const extendItems = Array.isArray(extendsConfig) ? extendsConfig : [extendsConfig];

    extendItems.forEach(item => {
      configs = [...configs, ...configMap[item]];
    });
  }

  return configs;
}

export { eslintCodeGuideline as default };