'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

const config = require('eslint-config-standard/.eslintrc.json');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }

const config__default = /*#__PURE__*/_interopDefaultLegacy(config);

const TSEquivalents = [
  "comma-spacing",
  "brace-style",
  "func-call-spacing",
  "indent",
  "keyword-spacing",
  "lines-between-class-members",
  "no-array-constructor",
  "no-dupe-class-members",
  "no-redeclare",
  "no-unused-vars",
  "no-unused-expressions",
  "no-useless-constructor",
  "no-use-before-define",
  "quotes",
  "semi",
  "space-before-function-paren",
  "space-infix-ops",
  "object-curly-spacing"
];
const VueEquivalents = [
  "array-bracket-spacing",
  "arrow-spacing",
  "block-spacing",
  "brace-style",
  "camelcase",
  "comma-dangle",
  "comma-spacing",
  "comma-style",
  "dot-location",
  "dot-notation",
  "eqeqeq",
  "func-call-spacing",
  "key-spacing",
  "keyword-spacing",
  "no-constant-condition",
  "no-empty-pattern",
  "no-extra-parens",
  "no-irregular-whitespace",
  "no-loss-of-precision",
  "no-sparse-arrays",
  "object-curly-newline",
  "object-curly-spacing",
  "object-property-newline",
  "object-shorthand",
  "operator-linebreak",
  "quote-props",
  "space-in-parens",
  "space-infix-ops",
  "space-unary-ops",
  "template-curly-spacing"
];
const configStandard = config__default;
const resolverExtensions = [".js", ".jsx", ".mjs", ".cjs", ".json"];
const resolverExtensionsWithTS = [".ts", ".tsx", ...resolverExtensions];

function defineConfig(config) {
  return config;
}
function defineRules(rules) {
  return rules;
}
function definePlugin(plugin) {
  return plugin;
}
const ruleFromStandard = (name) => {
  if (configStandard.rules === void 0)
    throw new Error("rules can not be undefined");
  const rule = configStandard.rules[name];
  if (rule === void 0)
    throw new Error("rule can not be undefined");
  if (typeof rule !== "object")
    return rule;
  return JSON.parse(JSON.stringify(rule));
};
function fromEntries(iterable) {
  return [...iterable].reduce((obj, [key, val]) => {
    obj[key] = val;
    return obj;
  }, {});
}

const bestPracticeRules = defineRules({
  "block-scoped-var": "error",
  "eqeqeq": ["error", "smart"],
  "no-alert": "warn",
  "vars-on-top": "error"
});

const eslintComments = defineRules({
  "eslint-comments/disable-enable-pair": ["error", { allowWholeFile: true }],
  "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",
  "eslint-comments/no-restricted-disable": "off",
  "eslint-comments/no-use": "off"
});

const ignorePatterns = [
  "*.min.*",
  "CHANGELOG.md",
  "dist",
  "LICENSE*",
  "output",
  "coverage",
  "public",
  "temp",
  "packages-lock.json",
  "pnpm-lock.yaml",
  "yarn.lock",
  "__snapshots__",
  "!.github",
  "!.vitepress",
  "!.vscode"
];
const core = defineConfig({
  plugins: ["@evan-yang", "html", "eslint-comments"],
  extends: ["standard"],
  ignorePatterns,
  rules: {
    "curly": ["error", "multi-or-nest", "consistent"],
    "quote-props": ["error", "consistent-as-needed"],
    "no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
    "no-param-reassign": "off",
    "camelcase": "off",
    "comma-dangle": ["error", "always-multiline"],
    "no-console": "error",
    "no-cond-assign": ["error", "always"],
    "no-return-await": "error",
    "operator-linebreak": ["error", "before"],
    "space-before-function-paren": ["error", "never"],
    "no-use-before-define": ["error", {
      functions: false,
      classes: false,
      variables: true
    }],
    "no-restricted-syntax": [
      "error",
      "DebuggerStatement",
      "LabeledStatement",
      "WithStatement"
    ],
    "spaced-comment": ["error", "always", {
      line: {
        markers: ["/"],
        exceptions: ["/", "#"]
      },
      block: {
        markers: ["!"],
        exceptions: ["*"],
        balanced: true
      }
    }],
    "sort-imports": [
      "error",
      {
        ignoreCase: false,
        ignoreDeclarationSort: true,
        ignoreMemberSort: false,
        memberSyntaxSortOrder: ["none", "all", "multiple", "single"],
        allowSeparatedGroups: false
      }
    ],
    ...eslintComments,
    ...bestPracticeRules
  }
});

const unicornRules = defineRules({
  "unicorn/error-message": "error",
  "unicorn/escape-case": "error",
  "unicorn/no-array-instanceof": "error",
  "unicorn/no-new-buffer": "error",
  "unicorn/no-unsafe-regex": "off",
  "unicorn/number-literal-case": "error",
  "unicorn/prefer-exponentiation-operator": "error",
  "unicorn/prefer-includes": "error",
  "unicorn/prefer-starts-ends-with": "error",
  "unicorn/prefer-text-content": "error",
  "unicorn/prefer-type-error": "error",
  "unicorn/throw-new-error": "error"
});

const esnext = defineConfig({
  env: {
    es6: true,
    browser: true,
    node: true,
    es2021: true
  },
  parserOptions: {
    ecmaVersion: 2021,
    sourceType: "module"
  },
  extends: [
    "plugin:@evan-yang/core",
    "plugin:import/recommended",
    "plugin:promise/recommended"
  ],
  plugins: ["unicorn"],
  settings: {
    "import/resolver": {
      node: {
        extensions: resolverExtensions
      }
    }
  },
  overrides: [
    {
      files: ["scripts/**/*"],
      rules: {
        "no-console": "off"
      }
    },
    {
      files: ["*.test.ts", "*.test.js", "*.spec.ts", "*.spec.js"],
      rules: {
        "no-unused-expressions": "off"
      }
    }
  ],
  rules: {
    "no-var": "error",
    "prefer-const": [
      "error",
      {
        destructuring: "any",
        ignoreReadBeforeAssign: true
      }
    ],
    "prefer-arrow-callback": [
      "error",
      {
        allowNamedFunctions: false,
        allowUnboundThis: true
      }
    ],
    "object-shorthand": [
      "error",
      "always",
      {
        ignoreConstructors: false,
        avoidQuotes: true
      }
    ],
    "prefer-rest-params": "error",
    "prefer-spread": "error",
    "prefer-template": "error",
    "arrow-parens": ["error", "as-needed", { requireForBlockBody: true }],
    "generator-star-spacing": ["error", { before: true, after: false }],
    "import/order": [
      "error",
      {
        groups: [
          "builtin",
          "external",
          "internal",
          "parent",
          "sibling",
          "index",
          "type"
        ],
        pathGroups: [
          {
            pattern: "@/**",
            group: "external",
            position: "after"
          },
          {
            pattern: "~/**",
            group: "external",
            position: "after"
          }
        ],
        pathGroupsExcludedImportTypes: ["type"]
      }
    ],
    "import/first": "error",
    "import/no-mutable-exports": "error",
    "import/no-unresolved": "off",
    "import/no-absolute-path": "off",
    "import/no-named-as-default-member": "off",
    "promise/always-return": "off",
    "promise/catch-or-return": "off",
    ...unicornRules
  }
});

const reactRules = defineRules({
  "react/button-has-type": "off",
  "react/display-name": ["error", { ignoreTranspilerName: false }],
  "react/default-props-match-prop-types": "error",
  "react/forbid-foreign-prop-types": "error",
  "react/forbid-prop-types": ["error", { forbid: ["any", "array"] }],
  "react/function-component-definition": [
    "error",
    { namedComponents: "arrow-function", unnamedComponents: "arrow-function" }
  ],
  "react/jsx-fragments": ["error", "syntax"],
  "react/no-access-state-in-setstate": "error",
  "react/no-array-index-key": "error",
  "react/no-did-update-set-state": "error",
  "react/no-redundant-should-component-update": "error",
  "react/no-this-in-sfc": "error",
  "react/no-typos": "error",
  "react/no-unsafe": ["error", { checkAliases: true }],
  "react/no-unused-prop-types": "error",
  "react/no-unused-state": "error",
  "react/no-will-update-set-state": "error",
  "react/prefer-es6-class": "error",
  "react/prefer-stateless-function": ["error", { ignorePureComponents: true }],
  "react/self-closing-comp": "error",
  "react/state-in-constructor": ["error", "never"],
  "react/style-prop-object": "error",
  "react/void-dom-elements-no-children": "error",
  "react/jsx-newline": "off",
  "react/jsx-no-script-url": "error",
  "react/jsx-no-constructed-context-values": "error",
  "react/jsx-boolean-value": "error",
  "react/jsx-child-element-spacing": "error",
  "react/jsx-closing-bracket-location": ["error", { location: "tag-aligned" }],
  "react/jsx-closing-tag-location": "error",
  "react/jsx-curly-brace-presence": ["error", { propElementValues: "always" }],
  "react/jsx-curly-spacing": ["error", "never", { allowMultiline: true }],
  "react/jsx-equals-spacing": ["error", "never"],
  "react/jsx-filename-extension": ["error", { extensions: [".jsx", ".tsx"] }],
  "react/jsx-indent-props": ["error", 2],
  "react/jsx-indent": ["error", 2],
  "react/jsx-key": [
    "error",
    {
      checkFragmentShorthand: true,
      checkKeyMustBeforeSpread: true
    }
  ],
  "react/jsx-first-prop-new-line": ["error", "multiline"],
  "react/jsx-max-props-per-line": ["error", { maximum: { single: 5, multi: 1 } }],
  "react/jsx-no-useless-fragment": ["error", { allowExpressions: true }],
  "react/jsx-one-expression-per-line": "off",
  "react/jsx-pascal-case": [
    "error",
    {
      allowNamespace: true,
      allowLeadingUnderscore: true
    }
  ],
  "react/jsx-props-no-multi-spaces": "error",
  "react/jsx-tag-spacing": "error",
  "react/jsx-wrap-multilines": "error"
});

const react = defineConfig({
  overrides: [
    {
      files: ["*.jsx", "*.tsx"],
      extends: [
        "plugin:react/recommended",
        "plugin:react/jsx-runtime",
        "plugin:react-hooks/recommended"
      ],
      settings: {
        react: {
          version: "17"
        }
      },
      rules: {
        "jsx-quotes": [
          "error",
          "prefer-double"
        ],
        "react/prop-types": "off",
        "react/no-unknown-property": "off",
        ...reactRules
      }
    }
  ]
});

const next = defineConfig({
  extends: [
    "plugin:@evan-yang/typescript",
    "plugin:@evan-yang/react",
    "plugin:@evan-yang/json",
    "plugin:@evan-yang/yml",
    "plugin:@next/next/recommended"
  ],
  plugins: ["jsx-a11y"],
  rules: {
    "import/no-anonymous-default-export": "warn",
    "jsx-a11y/alt-text": [
      "warn",
      {
        elements: ["img"],
        img: ["Image"]
      }
    ],
    "jsx-a11y/aria-props": "warn",
    "jsx-a11y/aria-proptypes": "warn",
    "jsx-a11y/aria-unsupported-elements": "warn",
    "jsx-a11y/role-has-required-aria-props": "warn",
    "jsx-a11y/role-supports-aria-props": "warn"
  }
});

const json = defineConfig({
  extends: [
    "plugin:jsonc/recommended-with-jsonc"
  ],
  overrides: [
    {
      files: ["*.json", "*.json5", "*.jsonc"],
      parser: "jsonc-eslint-parser",
      rules: {
        "strict": "off",
        "no-unused-expressions": "off",
        "no-irregular-whitespace": "off"
      }
    },
    {
      files: ["package.json"],
      parser: "jsonc-eslint-parser",
      rules: {
        "jsonc/sort-keys": [
          "error",
          {
            pathPattern: "^$",
            order: [
              "name",
              "type",
              "version",
              "private",
              "packageManager",
              "description",
              "keywords",
              "license",
              "author",
              "repository",
              "funding",
              "main",
              "module",
              "types",
              "unpkg",
              "jsdelivr",
              "exports",
              "files",
              "bin",
              "sideEffects",
              "scripts",
              "peerDependencies",
              "peerDependenciesMeta",
              "dependencies",
              "optionalDependencies",
              "devDependencies",
              "husky",
              "lint-staged",
              "eslintConfig"
            ]
          },
          {
            pathPattern: "^(?:dev|peer|optional|bundled)?[Dd]ependencies$",
            order: { type: "asc" }
          }
        ]
      }
    }
  ]
});

const vue = defineConfig({
  overrides: [
    {
      files: ["*.vue"],
      parser: "vue-eslint-parser",
      parserOptions: {
        parser: "@typescript-eslint/parser"
      },
      extends: ["plugin:vue/vue3-recommended"],
      env: {
        "vue/setup-compiler-macros": true
      },
      rules: {
        "no-undef": "off",
        "no-unused-vars": "off",
        ...fromEntries(VueEquivalents.map((name) => [`vue/${name}`, ruleFromStandard(name)])),
        "vue/quote-props": ["error", "consistent-as-needed"],
        "vue/no-unused-vars": ["error", { ignorePattern: "^_" }],
        "vue/camelcase": "off",
        "vue/comma-dangle": ["error", "always-multiline"],
        "vue/max-attributes-per-line": ["warn", { singleline: 5 }],
        "vue/no-v-html": "off",
        "vue/require-default-prop": "off",
        "vue/multi-word-component-names": "off",
        "vue/block-tag-newline": ["error", {
          singleline: "always",
          multiline: "always"
        }],
        "vue/component-name-in-template-casing": ["error", "PascalCase"],
        "vue/component-options-name-casing": ["error", "PascalCase"],
        "vue/custom-event-name-casing": ["error", "camelCase"],
        "vue/define-macros-order": ["error", {
          order: ["defineProps", "defineEmits"]
        }],
        "vue/html-comment-content-spacing": ["error", "always", {
          exceptions: ["-"]
        }],
        "vue/no-restricted-v-bind": ["error", "/^v-/"],
        "vue/no-useless-v-bind": "error",
        "vue/no-v-text-v-html-on-component": "error",
        "vue/padding-line-between-blocks": ["error", "always"],
        "vue/prefer-separate-static-class": "error"
      }
    }
  ]
});

const yml = defineConfig({
  extends: [
    "plugin:yml/standard"
  ],
  rules: {
    "yml/quotes": ["error", { prefer: "single", avoidEscape: false }],
    "yml/no-empty-document": "off",
    "yml/no-empty-mapping-value": "off"
  }
});

const markdown = defineConfig({
  extends: [
    "plugin:markdown/recommended"
  ],
  overrides: [
    {
      files: ["**/*.md/*.*"],
      rules: {
        "no-alert": "off",
        "no-console": "off",
        "no-restricted-imports": "off",
        "no-undef": "off",
        "no-unused-vars": "off",
        "no-unused-expressions": "off",
        "react/jsx-no-undef": "off",
        "import/no-unresolved": "off",
        "@typescript-eslint/no-redeclare": "off",
        "@typescript-eslint/no-unused-vars": "off",
        "@typescript-eslint/no-use-before-define": "off",
        "@typescript-eslint/no-var-requires": "off"
      }
    }
  ]
});

const typescript = defineConfig({
  extends: [
    "plugin:@evan-yang/esnext",
    "plugin:import/typescript"
  ],
  settings: {
    "import/extensions": resolverExtensionsWithTS,
    "import/external-module-folders": ["node_modules", "node_modules/@types"],
    "import/parsers": {
      "@typescript-eslint/parser": [".ts", ".tsx"]
    },
    "import/resolver": {
      node: {
        extensions: resolverExtensionsWithTS
      },
      typescript: {
        alwaysTryTypes: true
      }
    }
  },
  overrides: [
    {
      files: ["*.d.ts"],
      rules: {
        "import/no-duplicates": "off"
      }
    },
    {
      files: ["*.ts", "*.tsx"],
      extends: ["plugin:@typescript-eslint/recommended"],
      rules: {
        ...fromEntries(TSEquivalents.map((name) => [name, "off"])),
        ...fromEntries(TSEquivalents.map((name) => [`@typescript-eslint/${name}`, ruleFromStandard(name)])),
        "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
        "@typescript-eslint/no-use-before-define": ["error", {
          functions: false,
          classes: false,
          enums: false,
          variables: true,
          typedefs: false
        }],
        "@typescript-eslint/comma-dangle": ["error", "always-multiline"],
        "@typescript-eslint/space-before-function-paren": ["error", "never"],
        "@typescript-eslint/ban-ts-comment": ["error", { "ts-ignore": "allow-with-description" }],
        "@typescript-eslint/member-delimiter-style": [
          "error",
          {
            multiline: { delimiter: "none" },
            singleline: { delimiter: "comma", requireLast: false }
          }
        ],
        "@typescript-eslint/type-annotation-spacing": "error",
        "@typescript-eslint/consistent-type-imports": ["error", { prefer: "type-imports", disallowTypeAnnotations: false }],
        "@typescript-eslint/consistent-indexed-object-style": ["error", "record"],
        "@typescript-eslint/consistent-type-definitions": ["error", "interface"],
        "@typescript-eslint/prefer-ts-expect-error": "error",
        "@typescript-eslint/naming-convention": "off",
        "@typescript-eslint/explicit-function-return-type": "off",
        "@typescript-eslint/explicit-member-accessibility": "off",
        "@typescript-eslint/no-explicit-any": "off",
        "@typescript-eslint/parameter-properties": "off",
        "@typescript-eslint/no-empty-interface": "off",
        "@typescript-eslint/ban-ts-ignore": "off",
        "@typescript-eslint/no-empty-function": "off",
        "@typescript-eslint/no-non-null-assertion": "off",
        "@typescript-eslint/explicit-module-boundary-types": "off",
        "@typescript-eslint/ban-types": "off",
        "@typescript-eslint/no-var-requires": "off",
        "@typescript-eslint/no-namespace": "off"
      }
    }
  ]
});

const typescriptTypeChecking = defineConfig({
  overrides: [
    {
      files: ["*.ts", "*.tsx"],
      rules: {
        "@typescript-eslint/await-thenable": "error",
        "@typescript-eslint/no-floating-promises": "error",
        "@typescript-eslint/no-for-in-array": "error",
        "no-implied-eval": "off",
        "@typescript-eslint/no-implied-eval": "error",
        "@typescript-eslint/no-misused-promises": "error",
        "@typescript-eslint/no-unsafe-argument": "error",
        "@typescript-eslint/no-unsafe-assignment": "error",
        "@typescript-eslint/no-unsafe-call": "error",
        "@typescript-eslint/no-unsafe-member-access": "error",
        "@typescript-eslint/no-unsafe-return": "error",
        "require-await": "off",
        "@typescript-eslint/require-await": "error",
        "@typescript-eslint/restrict-plus-operands": "error",
        "@typescript-eslint/restrict-template-expressions": "error",
        "@typescript-eslint/unbound-method": "error",
        "@typescript-eslint/no-unnecessary-condition": ["error"],
        "@typescript-eslint/no-unnecessary-type-assertion": "error",
        "@typescript-eslint/no-unnecessary-type-arguments": "error",
        "@typescript-eslint/prefer-includes": "error",
        "@typescript-eslint/prefer-readonly": [
          "error",
          { onlyInlineLambdas: false }
        ],
        "@typescript-eslint/promise-function-async": "error",
        "dot-notation": "off",
        "@typescript-eslint/dot-notation": "error",
        "no-throw-literal": "off",
        "@typescript-eslint/no-throw-literal": "error"
      }
    }
  ]
});

const plugin = definePlugin({
  rules: {},
  configs: {
    core,
    esnext,
    vue,
    react,
    next,
    typescript,
    typescriptTypeChecking,
    yml,
    json,
    markdown
  }
});
const { rules, configs } = plugin;

exports.configs = configs;
exports.rules = rules;