eslint-config-airbe/dist/index.js

A shared eslint config to apply eslint fastly

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  default: () => src_default
});
module.exports = __toCommonJS(src_exports);

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

// src/configs/js.ts
var import_js = __toESM(require("@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 [import_js.default.configs.recommended, { rules: jsRules }];
  }
  return [];
}

// src/configs/ts.ts
var import_typescript_eslint = __toESM(require("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 [...import_typescript_eslint.default.configs.recommendedTypeChecked, ...import_typescript_eslint.default.configs.stylisticTypeChecked, {
      languageOptions: {
        parserOptions: {
          parser: import_typescript_eslint.default.parser,
          projectService: true
        }
      },
      rules: tsRules
    }];
  }
  return [];
}

// src/configs/vue.ts
var import_eslint_plugin_vue = __toESM(require("eslint-plugin-vue"));
var import_vue_eslint_parser = __toESM(require("vue-eslint-parser"));
var import_typescript_eslint2 = __toESM(require("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 [
      ...import_eslint_plugin_vue.default.configs["flat/recommended"],
      {
        languageOptions: {
          parser: import_vue_eslint_parser.default,
          parserOptions: {
            parser: import_typescript_eslint2.default.parser,
            projectService: true,
            ecmaFeatures: {
              jsx: true
            }
          }
        }
      },
      {
        rules: vueRules
      }
    ];
  }
  return [];
}

// src/configs/stylistic.ts
var import_eslint_plugin = __toESM(require("@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 [
      import_eslint_plugin.default.configs.customize({
        quoteProps: "as-needed"
      }),
      {
        rules: stylisticRules
      }
    ];
  }
  return [];
}

// src/configs/import.ts
var import_eslint_plugin_import_x = __toESM(require("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 [
      import_eslint_plugin_import_x.default.configs.typescript,
      {
        plugins: {
          "import-x": import_eslint_plugin_import_x.default
        },
        settings: {
          "import-x/resolver": {
            typescript: true
          }
        },
        rules: importRules
      }
    ];
  }
  return [];
}

// src/configs/unusedImports.ts
var import_eslint_plugin_unused_imports = __toESM(require("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": import_eslint_plugin_unused_imports.default
        },
        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;