katon-labs-eslint-config 0.0.2

package/README.md

@@ -0,0 +1,15 @@
+# eslint-config
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.1.27. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/dist/index.cjs

@@ -0,0 +1,595 @@
+"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, {
+  GLOB_ALL_SRC: () => GLOB_ALL_SRC,
+  GLOB_ASTRO: () => GLOB_ASTRO,
+  GLOB_ASTRO_TS: () => GLOB_ASTRO_TS,
+  GLOB_CSS: () => GLOB_CSS,
+  GLOB_EXCLUDE: () => GLOB_EXCLUDE,
+  GLOB_GRAPHQL: () => GLOB_GRAPHQL,
+  GLOB_HTML: () => GLOB_HTML,
+  GLOB_JS: () => GLOB_JS,
+  GLOB_JSON: () => GLOB_JSON,
+  GLOB_JSON5: () => GLOB_JSON5,
+  GLOB_JSONC: () => GLOB_JSONC,
+  GLOB_JSX: () => GLOB_JSX,
+  GLOB_LESS: () => GLOB_LESS,
+  GLOB_MARKDOWN: () => GLOB_MARKDOWN,
+  GLOB_MARKDOWN_CODE: () => GLOB_MARKDOWN_CODE,
+  GLOB_MARKDOWN_IN_MARKDOWN: () => GLOB_MARKDOWN_IN_MARKDOWN,
+  GLOB_POSTCSS: () => GLOB_POSTCSS,
+  GLOB_SCSS: () => GLOB_SCSS,
+  GLOB_SRC: () => GLOB_SRC,
+  GLOB_SRC_EXT: () => GLOB_SRC_EXT,
+  GLOB_STYLE: () => GLOB_STYLE,
+  GLOB_SVELTE: () => GLOB_SVELTE,
+  GLOB_SVG: () => GLOB_SVG,
+  GLOB_TESTS: () => GLOB_TESTS,
+  GLOB_TOML: () => GLOB_TOML,
+  GLOB_TS: () => GLOB_TS,
+  GLOB_TSX: () => GLOB_TSX,
+  GLOB_VUE: () => GLOB_VUE,
+  GLOB_XML: () => GLOB_XML,
+  GLOB_YAML: () => GLOB_YAML,
+  StylisticConfigDefaults: () => StylisticConfigDefaults,
+  default: () => src_default,
+  imports: () => imports,
+  katonlabs: () => katonlabs,
+  node: () => node,
+  perfectionist: () => perfectionist,
+  stylistic: () => stylistic,
+  typescript: () => typescript,
+  unicorn: () => unicorn,
+  vue: () => vue
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/factory.ts
+var import_eslint_flat_config_utils = require("eslint-flat-config-utils");
+
+// src/configs/typescript.ts
+var import_eslint_plugin = __toESM(require("@typescript-eslint/eslint-plugin"), 1);
+var import_parser = __toESM(require("@typescript-eslint/parser"), 1);
+
+// src/globs.ts
+var GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
+var GLOB_SRC = "**/*.?([cm])[jt]s?(x)";
+var GLOB_JS = "**/*.?([cm])js";
+var GLOB_JSX = "**/*.?([cm])jsx";
+var GLOB_TS = "**/*.?([cm])ts";
+var GLOB_TSX = "**/*.?([cm])tsx";
+var GLOB_STYLE = "**/*.{c,le,sc}ss";
+var GLOB_CSS = "**/*.css";
+var GLOB_POSTCSS = "**/*.{p,post}css";
+var GLOB_LESS = "**/*.less";
+var GLOB_SCSS = "**/*.scss";
+var GLOB_JSON = "**/*.json";
+var GLOB_JSON5 = "**/*.json5";
+var GLOB_JSONC = "**/*.jsonc";
+var GLOB_MARKDOWN = "**/*.md";
+var GLOB_MARKDOWN_IN_MARKDOWN = "**/*.md/*.md";
+var GLOB_SVELTE = "**/*.svelte";
+var GLOB_VUE = "**/*.vue";
+var GLOB_YAML = "**/*.y?(a)ml";
+var GLOB_TOML = "**/*.toml";
+var GLOB_XML = "**/*.xml";
+var GLOB_SVG = "**/*.svg";
+var GLOB_HTML = "**/*.htm?(l)";
+var GLOB_ASTRO = "**/*.astro";
+var GLOB_ASTRO_TS = "**/*.astro/*.ts";
+var GLOB_GRAPHQL = "**/*.{g,graph}ql";
+var GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
+var GLOB_TESTS = [
+  `**/__tests__/**/*.${GLOB_SRC_EXT}`,
+  `**/*.spec.${GLOB_SRC_EXT}`,
+  `**/*.test.${GLOB_SRC_EXT}`,
+  `**/*.bench.${GLOB_SRC_EXT}`,
+  `**/*.benchmark.${GLOB_SRC_EXT}`
+];
+var GLOB_ALL_SRC = [
+  GLOB_SRC,
+  GLOB_STYLE,
+  GLOB_JSON,
+  GLOB_JSON5,
+  GLOB_MARKDOWN,
+  GLOB_SVELTE,
+  GLOB_VUE,
+  GLOB_YAML,
+  GLOB_XML,
+  GLOB_HTML
+];
+var GLOB_EXCLUDE = [
+  "**/node_modules",
+  "**/dist",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/bun.lockb",
+  "**/output",
+  "**/coverage",
+  "**/temp",
+  "**/.temp",
+  "**/tmp",
+  "**/.tmp",
+  "**/.history",
+  "**/.vitepress/cache",
+  "**/.nuxt",
+  "**/.next",
+  "**/.svelte-kit",
+  "**/.vercel",
+  "**/.changeset",
+  "**/.idea",
+  "**/.cache",
+  "**/.output",
+  "**/.vite-inspect",
+  "**/.yarn",
+  "**/vite.config.*.timestamp-*",
+  "**/CHANGELOG*.md",
+  "**/*.min.*",
+  "**/LICENSE*",
+  "**/__snapshots__",
+  "**/auto-import?(s).d.ts",
+  "**/components.d.ts"
+];
+
+// src/configs/typescript.ts
+function typescript(options) {
+  const files = [GLOB_TS, GLOB_TSX, GLOB_VUE];
+  const fileTypeAware = options?.fileTypeAware ?? [GLOB_TS, GLOB_TSX, GLOB_VUE];
+  const tsconfigPath = options?.tsconfigPath ? options.tsconfigPath : void 0;
+  const isTypeAware = !!tsconfigPath;
+  const typeAwareRules = {
+    "@typescript-eslint/await-thenable": "error",
+    "@typescript-eslint/return-await": ["error", "in-try-catch"],
+    "@typescript-eslint/dot-notation": ["error", { allowKeywords: true }],
+    "@typescript-eslint/no-floating-promises": "error",
+    "@typescript-eslint/no-for-in-array": "error",
+    "@typescript-eslint/no-implied-eval": "error",
+    "@typescript-eslint/no-misused-promises": "error",
+    "@typescript-eslint/no-unnecessary-type-assertion": "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",
+    "@typescript-eslint/promise-function-async": "error",
+    "@typescript-eslint/restrict-plus-operands": "error",
+    "@typescript-eslint/strict-boolean-expressions": ["error", { allowNullableBoolean: true, allowNullableObject: true }]
+  };
+  function makeParser(typeAware, files2, ignores) {
+    return {
+      files: files2,
+      ...ignores ? { ignores } : {},
+      languageOptions: {
+        parser: import_parser.default,
+        parserOptions: {
+          extraFileExtensions: [".vue"],
+          sourceType: "module",
+          ...typeAware ? {
+            projectService: {
+              allowDefaultProject: ["./*.js"],
+              defaultProject: tsconfigPath
+            },
+            tsconfigRootDir: process.cwd()
+          } : {}
+        }
+      },
+      name: `katon-labs/typescript/${typeAware ? "type-aware-parser" : "parser"}`
+    };
+  }
+  return [
+    {
+      // Install the plugins without globs, so they can be configured separately.
+      name: "katon-labs/typescript/setup",
+      plugins: {
+        "@typescript-eslint": import_eslint_plugin.default
+      }
+    },
+    // assign type-aware parser for type-aware files and type-unaware parser for the rest
+    ...isTypeAware ? [
+      makeParser(false, files),
+      makeParser(true, fileTypeAware)
+    ] : [
+      makeParser(false, files)
+    ],
+    {
+      files,
+      name: "katon-labs/typescript/rules",
+      rules: {
+        ...import_eslint_plugin.default.configs["eslint-recommended"].overrides[0].rules,
+        ...import_eslint_plugin.default.configs.strict.rules,
+        "no-dupe-class-members": "off",
+        "no-redeclare": "off",
+        "no-use-before-define": "off",
+        "no-useless-constructor": "off",
+        "@typescript-eslint/ban-ts-comment": ["error", { "ts-expect-error": "allow-with-description" }],
+        "@typescript-eslint/consistent-type-definitions": ["error", "interface"],
+        "@typescript-eslint/consistent-type-imports": ["error", { disallowTypeAnnotations: true, prefer: "type-imports" }],
+        "@typescript-eslint/method-signature-style": ["error", "property"],
+        "@typescript-eslint/no-dynamic-delete": "off",
+        "@typescript-eslint/no-empty-object-type": ["error", { allowInterfaces: "always" }],
+        "@typescript-eslint/no-explicit-any": "off",
+        "@typescript-eslint/no-duplicate-type-constituents": "error"
+      }
+    },
+    ...isTypeAware ? [{
+      files: fileTypeAware,
+      name: "katon-labs/typescript/typeaware-rules",
+      rules: {
+        ...typeAwareRules
+      }
+    }] : []
+  ];
+}
+
+// src/configs/vue.ts
+var import_eslint_plugin_vue = __toESM(require("eslint-plugin-vue"), 1);
+var import_vue_eslint_parser = __toESM(require("vue-eslint-parser"), 1);
+var import_parser2 = __toESM(require("@typescript-eslint/parser"), 1);
+function vue() {
+  const files = [GLOB_VUE];
+  const indent = 2;
+  return [
+    {
+      name: "katon-labs/vue/setup",
+      plugins: {
+        "vue": import_eslint_plugin_vue.default
+      },
+      // This allows Vue plugin to work with auto imports
+      // https://github.com/vuejs/eslint-plugin-vue/pull/2422
+      languageOptions: {
+        globals: {
+          computed: "readonly",
+          defineEmits: "readonly",
+          defineExpose: "readonly",
+          defineProps: "readonly",
+          onMounted: "readonly",
+          onUnmounted: "readonly",
+          reactive: "readonly",
+          ref: "readonly",
+          shallowReactive: "readonly",
+          shallowRef: "readonly",
+          toRef: "readonly",
+          toRefs: "readonly",
+          watch: "readonly",
+          watchEffect: "readonly"
+        }
+      }
+    },
+    {
+      files,
+      name: "katon-labs/vue/rules",
+      languageOptions: {
+        parser: import_vue_eslint_parser.default,
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          },
+          extraFileExtensions: [".vue"],
+          parser: import_parser2.default,
+          sourceType: "module"
+        }
+      },
+      processor: import_eslint_plugin_vue.default.processors[".vue"],
+      rules: {
+        ...import_eslint_plugin_vue.default.configs.base.rules,
+        ...import_eslint_plugin_vue.default.configs.essential.rules,
+        ...import_eslint_plugin_vue.default.configs["vue3-recommended"].rules,
+        ...import_eslint_plugin_vue.default.configs["vue3-strongly-recommended"].rules,
+        ...import_eslint_plugin_vue.default.configs["vue3-essential"].rules,
+        "vue/block-order": ["error", {
+          order: ["script", "template", "style"]
+        }],
+        "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: ["defineOptions", "defineProps", "defineEmits", "defineSlots"]
+        }],
+        "vue/dot-location": ["error", "property"],
+        "vue/dot-notation": ["error", { allowKeywords: true }],
+        "vue/eqeqeq": ["error", "smart"],
+        "vue/html-indent": ["error", indent],
+        "vue/html-quotes": ["error", "double"],
+        "vue/max-attributes-per-line": ["error", { singleline: 2 }],
+        "vue/multi-word-component-names": "off",
+        "vue/no-dupe-keys": "error",
+        "vue/no-empty-pattern": "error",
+        "vue/no-irregular-whitespace": "error",
+        "vue/no-loss-of-precision": "error",
+        "vue/no-restricted-syntax": [
+          "error",
+          "DebuggerStatement",
+          "LabeledStatement",
+          "WithStatement"
+        ],
+        "vue/no-restricted-v-bind": ["error", "/^v-/"],
+        "vue/no-sparse-arrays": "error",
+        "vue/no-unused-refs": "error",
+        "vue/no-useless-v-bind": "error",
+        "vue/no-v-html": "off",
+        "vue/object-shorthand": [
+          "error",
+          "always",
+          {
+            avoidQuotes: true,
+            ignoreConstructors: false
+          }
+        ],
+        "vue/prefer-separate-static-class": "error",
+        "vue/prefer-template": "error",
+        "vue/prop-name-casing": ["error", "camelCase"],
+        "vue/no-root-v-if": "error",
+        "vue/no-multiple-template-root": "warn",
+        // this is deprecated
+        "vue/component-tags-order": "off",
+        // stylistic
+        "vue/array-bracket-spacing": ["error", "never"],
+        "vue/arrow-spacing": ["error", { after: true, before: true }],
+        "vue/block-spacing": ["error", "always"],
+        "vue/block-tag-newline": [
+          "error",
+          {
+            singleline: "always",
+            multiline: "always"
+          }
+        ],
+        "vue/brace-style": ["error", "stroustrup", { allowSingleLine: true }],
+        "vue/comma-dangle": ["error", "always-multiline"],
+        "vue/comma-spacing": ["error", { after: true, before: false }],
+        "vue/comma-style": ["error", "last"],
+        "vue/html-comment-content-spacing": ["error", "always", {
+          exceptions: ["-"]
+        }],
+        "vue/key-spacing": [
+          "error",
+          {
+            align: {
+              beforeColon: false,
+              afterColon: true,
+              on: "value"
+            }
+          }
+        ],
+        "vue/keyword-spacing": ["error", { after: true, before: true }],
+        "vue/object-curly-spacing": ["error", "always"],
+        "vue/object-property-newline": ["error", { allowMultiplePropertiesPerLine: true }],
+        "vue/operator-linebreak": ["error", "before"],
+        "vue/padding-line-between-blocks": ["error", "always"],
+        "vue/quote-props": ["error", "consistent-as-needed"],
+        "vue/space-in-parens": ["error", "never"],
+        "vue/template-curly-spacing": "error"
+      }
+    }
+  ];
+}
+
+// src/configs/imports.ts
+var import_eslint_plugin_import_x = __toESM(require("eslint-plugin-import-x"), 1);
+function imports() {
+  return [
+    {
+      name: "katon-labs/imports/rules",
+      plugins: {
+        import: import_eslint_plugin_import_x.default
+      },
+      rules: {
+        "import/first": "error",
+        "import/no-duplicates": "error",
+        "import/no-mutable-exports": "error",
+        "import/no-named-default": "error",
+        "import/no-self-import": "error",
+        "import/no-webpack-loader-syntax": "error",
+        // stylistic
+        "import/newline-after-import": ["error", { count: 1 }]
+      }
+    }
+  ];
+}
+
+// src/configs/unicorn.ts
+var import_eslint_plugin_unicorn = __toESM(require("eslint-plugin-unicorn"), 1);
+function unicorn() {
+  return [
+    {
+      name: "katon-labs/unicorn/rules",
+      plugins: {
+        unicorn: import_eslint_plugin_unicorn.default
+      },
+      rules: {
+        "unicorn/consistent-empty-array-spread": "error",
+        "unicorn/error-message": "error",
+        "unicorn/escape-case": "error",
+        "unicorn/new-for-builtins": "error",
+        "unicorn/no-instanceof-array": "error",
+        "unicorn/no-new-array": "error",
+        "unicorn/prefer-includes": "error",
+        "unicorn/prefer-node-protocol": "error",
+        "unicorn/prefer-number-properties": "error",
+        "unicorn/prefer-string-starts-ends-with": "error",
+        "unicorn/prefer-type-error": "error",
+        "unicorn/throw-new-error": "error"
+      }
+    }
+  ];
+}
+
+// src/configs/perfectionist.ts
+var import_eslint_plugin_perfectionist = __toESM(require("eslint-plugin-perfectionist"), 1);
+function perfectionist() {
+  return [
+    {
+      name: "katon-labs/perfectionist/rules",
+      plugins: {
+        "perfectionist": import_eslint_plugin_perfectionist.default
+      },
+      rules: {
+        "perfectionist/sort-exports": ["error", { order: "asc", type: "natural" }],
+        "perfectionist/sort-imports": ["error", {
+          groups: [
+            "type",
+            ["parent-type", "sibling-type", "index-type"],
+            "builtin",
+            "external",
+            ["internal", "internal-type"],
+            ["parent", "sibling", "index"],
+            "side-effect",
+            "object",
+            "unknown"
+          ],
+          newlinesBetween: "ignore",
+          order: "asc",
+          type: "natural"
+        }],
+        "perfectionist/sort-named-exports": ["error", { order: "asc", type: "natural" }],
+        "perfectionist/sort-named-imports": ["error", { order: "asc", type: "natural" }]
+      }
+    }
+  ];
+}
+
+// src/configs/node.ts
+var import_eslint_plugin_n = __toESM(require("eslint-plugin-n"), 1);
+function node() {
+  return [
+    {
+      name: "katon-labs/node/rules",
+      plugins: {
+        "node": import_eslint_plugin_n.default
+      },
+      rules: {
+        "node/handle-callback-err": ["error", "^(err|error)$"],
+        "node/no-deprecated-api": "error",
+        "node/no-exports-assign": "error",
+        "node/no-new-require": "error",
+        "node/no-path-concat": "error",
+        "node/prefer-global/buffer": ["error", "never"],
+        "node/prefer-global/process": ["error", "never"]
+      }
+    }
+  ];
+}
+
+// src/configs/stylistic.ts
+var import_eslint_plugin2 = __toESM(require("@stylistic/eslint-plugin"), 1);
+var StylisticConfigDefaults = {
+  indent: 2,
+  jsx: true,
+  quotes: "single",
+  semi: false
+};
+function stylistic() {
+  const {
+    indent,
+    jsx,
+    quotes,
+    semi
+  } = StylisticConfigDefaults;
+  const config = import_eslint_plugin2.default.configs.customize({
+    indent,
+    jsx,
+    quotes,
+    semi
+  });
+  return [
+    {
+      name: "katon-labs/stylistic/rules",
+      plugins: {
+        "@stylistic": import_eslint_plugin2.default
+      },
+      rules: {
+        ...config.rules
+      }
+    }
+  ];
+}
+
+// src/factory.ts
+function katonlabs(options = {}) {
+  const { ts } = options;
+  const configs = [];
+  configs.push(typescript(ts));
+  configs.push(vue());
+  configs.push(imports());
+  configs.push(unicorn());
+  configs.push(perfectionist());
+  configs.push(node());
+  configs.push(stylistic());
+  let composer = new import_eslint_flat_config_utils.FlatConfigComposer();
+  composer.append(...configs);
+  return composer;
+}
+
+// src/index.ts
+var src_default = katonlabs;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GLOB_ALL_SRC,
+  GLOB_ASTRO,
+  GLOB_ASTRO_TS,
+  GLOB_CSS,
+  GLOB_EXCLUDE,
+  GLOB_GRAPHQL,
+  GLOB_HTML,
+  GLOB_JS,
+  GLOB_JSON,
+  GLOB_JSON5,
+  GLOB_JSONC,
+  GLOB_JSX,
+  GLOB_LESS,
+  GLOB_MARKDOWN,
+  GLOB_MARKDOWN_CODE,
+  GLOB_MARKDOWN_IN_MARKDOWN,
+  GLOB_POSTCSS,
+  GLOB_SCSS,
+  GLOB_SRC,
+  GLOB_SRC_EXT,
+  GLOB_STYLE,
+  GLOB_SVELTE,
+  GLOB_SVG,
+  GLOB_TESTS,
+  GLOB_TOML,
+  GLOB_TS,
+  GLOB_TSX,
+  GLOB_VUE,
+  GLOB_XML,
+  GLOB_YAML,
+  StylisticConfigDefaults,
+  imports,
+  katonlabs,
+  node,
+  perfectionist,
+  stylistic,
+  typescript,
+  unicorn,
+  vue
+});