eslint-config-airbe/dist/index.mjs

A shared eslint config to apply eslint fastly

// src/utils.ts
var isPlainObject = (obj) => {
  return Object.prototype.toString.call(obj) === "[object Object]";
};

// src/configs/js.ts
import eslint from "@eslint/js";
function getJsConfig(jsConfig) {
  if (jsConfig) {
    const jsRules = {
      "prefer-template": "warn",
      "no-def": "off",
      eqeqeq: ["error", "always"],
      curly: ["error", "multi", "consistent"],
      "default-case": "warn",
      "default-case-last": "warn",
      "no-await-in-loop": "warn",
      "no-console": "warn",
      "no-use-before-define": "error",
      "no-eval": "error"
    };
    if (isPlainObject(jsConfig))
      Object.assign(jsRules, jsConfig);
    return [eslint.configs.recommended, { rules: jsRules }];
  }
  return [];
}

// src/configs/ts.ts
import tseslint from "typescript-eslint";
function getTsConfig(tsConfig) {
  if (tsConfig) {
    const tsRules = {
      "@typescript-eslint/prefer-nullish-coalescing": "off",
      "@typescript-eslint/no-unsafe-member-access": "off",
      "@typescript-eslint/no-unsafe-call": "off",
      "@typescript-eslint/no-unsafe-assignment": "off",
      "@typescript-eslint/no-unsafe-argument": "off",
      "@typescript-eslint/no-unsafe-return": "warn",
      "@typescript-eslint/no-unused-vars": "warn",
      "@typescript-eslint/no-explicit-any": "warn",
      "@typescript-eslint/no-unnecessary-type-assertion": "warn",
      "@typescript-eslint/dot-notation": "warn"
    };
    if (isPlainObject(tsConfig))
      Object.assign(tsRules, tsConfig);
    return [...tseslint.configs.recommendedTypeChecked, ...tseslint.configs.stylisticTypeChecked, {
      languageOptions: {
        parserOptions: {
          parser: tseslint.parser,
          projectService: true
        }
      },
      rules: tsRules
    }];
  }
  return [];
}

// src/configs/vue.ts
import pluginVue from "eslint-plugin-vue";
import vueParser from "vue-eslint-parser";
import tseslint2 from "typescript-eslint";
function getVueConfig(vueConfig) {
  if (vueConfig) {
    const vueRules = {
      "vue/multi-word-component-names": "off",
      "vue/no-duplicate-attributes": ["warn", {
        allowCoexistClass: true,
        allowCoexistStyle: true
      }],
      "vue/no-parsing-error": ["error", {
        "duplicate-attribute": false
      }],
      "vue/html-indent": ["error", 2],
      "vue/max-attributes-per-line": ["error", {
        singleline: {
          max: 1
        },
        multiline: {
          max: 1
        }
      }],
      "vue/first-attribute-linebreak": ["error", {
        singleline: "beside",
        multiline: "below"
      }],
      "vue/component-name-in-template-casing": ["error", "PascalCase", { registeredComponentsOnly: false }],
      "vue/attribute-hyphenation": "error",
      "vue/no-multiple-objects-in-class": "error",
      "vue/no-useless-mustaches": "error",
      "vue/no-useless-v-bind": "error",
      "vue/padding-line-between-blocks": "error",
      "vue/prefer-true-attribute-shorthand": "error",
      "vue/prefer-separate-static-class": "error",
      "vue/valid-v-slot": ["error", {
        allowModifiers: true
      }]
    };
    if (isPlainObject(vueConfig))
      Object.assign(vueRules, vueConfig);
    return [
      ...pluginVue.configs["flat/recommended"],
      {
        languageOptions: {
          parser: vueParser,
          parserOptions: {
            parser: tseslint2.parser,
            projectService: true,
            ecmaFeatures: {
              jsx: true
            }
          }
        }
      },
      {
        rules: vueRules
      }
    ];
  }
  return [];
}

// src/configs/stylistic.ts
import stylisticEslint from "@stylistic/eslint-plugin";
function getStylisticConfig(stylisticConfig) {
  if (stylisticConfig) {
    const stylisticRules = {
      "@stylistic/no-trailing-spaces": ["error", { skipBlankLines: true }]
    };
    if (isPlainObject(stylisticConfig))
      Object.assign(stylisticRules, stylisticConfig);
    return [
      stylisticEslint.configs.customize({
        quoteProps: "as-needed"
      }),
      {
        rules: stylisticRules
      }
    ];
  }
  return [];
}

// src/configs/import.ts
import eslintImportX from "eslint-plugin-import-x";
function getImportConfig(importConfig) {
  if (importConfig) {
    const importRules = {
      "import-x/no-absolute-path": "error",
      "import-x/no-unused-modules": "warn",
      "import-x/first": "warn",
      "import-x/newline-after-import": "warn"
    };
    if (isPlainObject(importConfig))
      Object.assign(importRules, importConfig);
    return [
      eslintImportX.configs.typescript,
      {
        plugins: {
          "import-x": eslintImportX
        },
        settings: {
          "import-x/resolver": {
            typescript: true
          }
        },
        rules: importRules
      }
    ];
  }
  return [];
}

// src/configs/unusedImports.ts
import unusedImports from "eslint-plugin-unused-imports";
function getUnusedImportsConfig(unusedImportsConfig, useTpeScriptEslint) {
  if (unusedImportsConfig) {
    const unusedImportsRules = {
      "no-unused-vars": "off",
      "unused-imports/no-unused-imports": "error",
      "unused-imports/no-unused-vars": [
        "warn",
        {
          vars: "all",
          varsIgnorePattern: "^_",
          args: "after-used",
          argsIgnorePattern: "^_"
        }
      ]
    };
    if (useTpeScriptEslint && (unusedImportsConfig === true || unusedImportsConfig["unused-imports/no-unused-vars"] !== "off"))
      Object.assign(unusedImportsRules, { "@typescript-eslint/no-unused-vars": "off" });
    if (isPlainObject(unusedImportsConfig))
      Object.assign(unusedImportsRules, unusedImportsConfig);
    return [
      {
        plugins: {
          "unused-imports": unusedImports
        },
        rules: unusedImportsRules
      }
    ];
  }
  return [];
}

// src/index.ts
var defineConfig = (config, ...customFlatConfigs) => {
  const {
    js,
    ts,
    vue,
    stylistic,
    importX,
    unusedImports: unusedImports2,
    ignores,
    globals
  } = config;
  const eslintConfig = [
    ...getJsConfig(js),
    ...getTsConfig(ts),
    ...getVueConfig(vue),
    ...getStylisticConfig(stylistic),
    ...getImportConfig(importX),
    ...getUnusedImportsConfig(unusedImports2)
  ];
  if (Array.isArray(ignores))
    eslintConfig.push({
      ignores
    });
  if (isPlainObject(globals))
    eslintConfig.push({
      languageOptions: {
        globals
      }
    });
  eslintConfig.push({
    files: ["*.json"],
    rules: {
      "no-invalid-meta": "off",
      "@stylistic/quotes": ["error", "double"],
      "@stylistic/quote-props": ["error", "always"],
      "@stylistic/comma-dangle": "off",
      "@typescript-eslint/no-unused-expressions": "off"
    }
  });
  if (Array.isArray(customFlatConfigs))
    eslintConfig.push(...customFlatConfigs);
  return eslintConfig;
};
var src_default = defineConfig;
export {
  src_default as default
};