@bfra.me/eslint-config 0.1.0

package/lib/index.js

@@ -0,0 +1,534 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/define-config.ts
+import { FlatConfigComposer } from "eslint-flat-config-utils";
+import { isPackageExists } from "local-pkg";
+
+// src/configs/command.ts
+import config from "eslint-plugin-command/config";
+async function command() {
+  return [
+    {
+      ...config(),
+      name: "@bfra.me/command"
+    }
+  ];
+}
+__name(command, "command");
+
+// src/configs/epilogue.ts
+async function epilogue() {
+  return [
+    {
+      name: "@bfra.me/epilogue/dts",
+      files: [
+        "**/*.d.?([cm])ts"
+      ],
+      rules: {
+        "eslint-comments/no-unlimited-disable": "off",
+        "import/no-duplicates": "off",
+        "no-restricted-syntax": "off",
+        "unused-imports/no-unused-vars": "off"
+      }
+    }
+  ];
+}
+__name(epilogue, "epilogue");
+
+// src/plugins.ts
+import { default as default2 } from "@eslint-community/eslint-plugin-eslint-comments";
+import { default as default3 } from "eslint-plugin-import-x";
+import { default as default4 } from "eslint-plugin-jsdoc";
+import { default as default5 } from "eslint-plugin-perfectionist";
+import { default as default6 } from "eslint-plugin-unused-imports";
+// @__NO_SIDE_EFFECTS__
+async function interopDefault(m) {
+  const resolved = await m;
+  return resolved.default || resolved;
+}
+__name(interopDefault, "interopDefault");
+
+// src/configs/eslint-comments.ts
+async function eslintComments() {
+  return [
+    {
+      name: "@bfra.me/eslint-comments/rules",
+      plugins: {
+        "eslint-comments": default2
+      },
+      rules: {
+        "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"
+      }
+    }
+  ];
+}
+__name(eslintComments, "eslintComments");
+
+// src/globs.ts
+var GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
+var GLOB_SRC = "**/*.?([cm])[jt]s?(x)";
+var GLOB_TS = "**/*.?([cm])ts";
+var GLOB_TSX = "**/*.tsx";
+var GLOB_EXCLUDE = [
+  "**/node_modules",
+  "**/dist",
+  "**/coverage",
+  "**/out",
+  "**/temp",
+  "**/.idea",
+  "**/.next",
+  "**/.nuxt",
+  "**/.output",
+  "**/.svelte-kit",
+  "**/.tsup",
+  "**/.vercel",
+  "**/.vitepress/cache",
+  "**/.vite-inspect",
+  "**/.yarn",
+  "**/__snapshots__",
+  "**/test/fixtures",
+  "**/auto-import?(s).d.ts",
+  "**/.changeset/*.md",
+  "**/CHANGELOG*.md",
+  "**/changelog*.md",
+  "**/components.d.ts",
+  "**/devcontainer-lock.json",
+  "**/LICENSE*",
+  "**/license*",
+  "**/*.min.*",
+  "**/package-lock.json",
+  "**/pnpm-lock.yaml",
+  "**/typed-router.d.ts",
+  "**/yarn.lock",
+  "**/bun.lockb"
+];
+var GLOB_TESTS = [
+  `**/__tests__/**/*.${GLOB_SRC_EXT}`,
+  `**/*.spec.${GLOB_SRC_EXT}`,
+  `**/*.test.${GLOB_SRC_EXT}`,
+  `**/*.bench.${GLOB_SRC_EXT}`,
+  `**/*.benchmark.${GLOB_SRC_EXT}`
+];
+
+// src/configs/ignores.ts
+async function ignores(ignores1 = []) {
+  return [
+    {
+      name: "@bfra.me/ignores",
+      ignores: [
+        ...GLOB_EXCLUDE,
+        ...ignores1
+      ]
+    }
+  ];
+}
+__name(ignores, "ignores");
+
+// src/configs/imports.ts
+async function imports() {
+  return [
+    {
+      name: "@bfra.me/imports",
+      plugins: {
+        "import-x": default3
+      },
+      rules: {
+        "import-x/first": "error",
+        "import-x/no-duplicates": "error",
+        "import-x/no-mutable-exports": "error",
+        "import-x/no-named-default": "error",
+        "import-x/no-self-import": "error",
+        "import-x/no-useless-path-segments": "error",
+        "import-x/no-webpack-loader-syntax": "error"
+      }
+    }
+  ];
+}
+__name(imports, "imports");
+
+// src/configs/javascript.ts
+import globals from "globals";
+async function javascript(options = {}) {
+  const { isInEditor: isInEditor2 = false, overrides = {} } = options;
+  return [
+    {
+      name: "@bfra.me/javascript/options",
+      languageOptions: {
+        ecmaVersion: 2022,
+        globals: {
+          ...globals.browser,
+          ...globals.es2021,
+          ...globals.node
+        },
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          },
+          ecmaVersion: 2022,
+          sourceType: "module"
+        },
+        sourceType: "module"
+      },
+      linterOptions: {
+        reportUnusedDisableDirectives: true
+      }
+    },
+    {
+      name: "@bfra.me/javascript/rules",
+      plugins: {
+        "unused-imports": default6
+      },
+      rules: {
+        camelcase: "off",
+        "no-unused-vars": "off",
+        "unused-imports/no-unused-imports": isInEditor2 ? "off" : "error",
+        "unused-imports/no-unused-vars": [
+          "error",
+          {
+            args: "after-used",
+            argsIgnorePattern: "^_",
+            ignoreRestSiblings: true,
+            vars: "all",
+            varsIgnorePattern: "^_"
+          }
+        ],
+        ...overrides
+      }
+    }
+  ];
+}
+__name(javascript, "javascript");
+
+// src/configs/jsdoc.ts
+async function jsdoc() {
+  return [
+    {
+      plugins: {
+        jsdoc: default4
+      },
+      rules: {
+        "jsdoc/check-access": "warn",
+        "jsdoc/check-param-names": "warn",
+        "jsdoc/check-property-names": "warn",
+        "jsdoc/check-types": "warn",
+        "jsdoc/empty-tags": "warn",
+        "jsdoc/implements-on-classes": "warn",
+        "jsdoc/no-defaults": "warn",
+        "jsdoc/no-multi-asterisks": "warn",
+        "jsdoc/require-param-name": "warn",
+        "jsdoc/require-property": "warn",
+        "jsdoc/require-property-description": "warn",
+        "jsdoc/require-property-name": "warn",
+        "jsdoc/require-returns-check": "warn",
+        "jsdoc/require-returns-description": "warn",
+        "jsdoc/require-yields-check": "warn"
+      }
+    }
+  ];
+}
+__name(jsdoc, "jsdoc");
+
+// src/configs/perfectionist.ts
+async function perfectionist() {
+  return [
+    {
+      name: "@bfra.me/perfectionist",
+      plugins: {
+        perfectionist: default5
+      },
+      rules: {
+        "perfectionist/sort-exports": [
+          "error",
+          {
+            type: "natural"
+          }
+        ]
+      }
+    }
+  ];
+}
+__name(perfectionist, "perfectionist");
+
+// src/configs/typescript.ts
+import process from "node:process";
+var TypeAwareRules = {
+  "@typescript-eslint/await-thenable": "error",
+  "@typescript-eslint/dot-notation": [
+    "error",
+    {
+      allowKeywords: true
+    }
+  ],
+  "@typescript-eslint/no-for-in-array": "error",
+  "@typescript-eslint/no-unnecessary-qualifier": "error",
+  "@typescript-eslint/no-unnecessary-type-assertion": "error",
+  "@typescript-eslint/prefer-includes": "error",
+  "@typescript-eslint/prefer-string-starts-ends-with": "error",
+  "@typescript-eslint/promise-function-async": "error",
+  "@typescript-eslint/require-array-sort-compare": "error",
+  "@typescript-eslint/restrict-plus-operands": "error",
+  "@typescript-eslint/unbound-method": "error"
+};
+async function typescript(options = {}) {
+  const { overrides = {}, parserOptions = {}, typeAware = {
+    overrides: {}
+  } } = options;
+  const files = options.files ?? [
+    GLOB_TS,
+    GLOB_TSX
+  ];
+  const typeAwareFiles = typeAware.files ?? [
+    GLOB_TS,
+    GLOB_TSX
+  ];
+  const typeAwareIgnores = typeAware.ignores ?? [
+    "**/*.md/**",
+    "**/*.astro/*.ts"
+  ];
+  const tsconfigPath = options.tsconfigPath ?? void 0;
+  const isTypeAware = Boolean(tsconfigPath);
+  const tselint = await interopDefault(import("typescript-eslint"));
+  const generateTsConfig = /* @__PURE__ */ __name((kind, files2, ignores2) => ({
+    name: `@bfra.me/typescript/${kind === "type-aware" ? "type-aware-" : ""}parser`,
+    files: files2,
+    ...ignores2 ? {
+      ignores: ignores2
+    } : {},
+    languageOptions: {
+      parser: tselint.parser,
+      parserOptions: {
+        sourceType: "module",
+        ...kind === "type-aware" ? {
+          projectService: {
+            allowDefaultProject: [
+              "./*.js"
+            ],
+            defaultProject: tsconfigPath
+          },
+          tsconfigRootDir: process.cwd()
+        } : {},
+        ...parserOptions
+      }
+    }
+  }), "generateTsConfig");
+  return [
+    {
+      name: "@bfra.me/typescript/plugins",
+      plugins: {
+        "@typescript-eslint": tselint.plugin
+      }
+    },
+    ...isTypeAware ? [
+      generateTsConfig("default", files),
+      generateTsConfig("type-aware", typeAwareFiles, typeAwareIgnores)
+    ] : [
+      generateTsConfig("default", files)
+    ],
+    {
+      name: "@bfra.me/typescript/rules",
+      files,
+      rules: {
+        ...tselint.configs.eslintRecommended.rules,
+        "@typescript-eslint/array-type": "error",
+        "@typescript-eslint/ban-ts-comment": [
+          "error",
+          {
+            "ts-expect-error": "allow-with-description"
+          }
+        ],
+        "@typescript-eslint/consistent-type-assertions": "error",
+        "@typescript-eslint/consistent-type-imports": [
+          "error",
+          {
+            disallowTypeAnnotations: false,
+            fixStyle: "inline-type-imports"
+          }
+        ],
+        "@typescript-eslint/explicit-function-return-type": [
+          "error",
+          {
+            allowExpressions: true,
+            allowHigherOrderFunctions: true,
+            allowIIFEs: true
+          }
+        ],
+        "@typescript-eslint/explicit-member-accessibility": [
+          "error",
+          {
+            accessibility: "no-public"
+          }
+        ],
+        "@typescript-eslint/no-array-constructor": "error",
+        "@typescript-eslint/no-empty-object-type": [
+          "error",
+          {
+            allowInterfaces: "always"
+          }
+        ],
+        "@typescript-eslint/no-explicit-any": "off",
+        "@typescript-eslint/no-extraneous-class": "error",
+        "@typescript-eslint/no-inferrable-types": "error",
+        "@typescript-eslint/no-misused-new": "error",
+        "@typescript-eslint/no-namespace": "error",
+        "@typescript-eslint/no-non-null-assertion": "warn",
+        "@typescript-eslint/no-require-imports": "error",
+        "@typescript-eslint/no-unused-vars": "error",
+        "@typescript-eslint/no-useless-constructor": "error",
+        "@typescript-eslint/prefer-for-of": "warn",
+        "@typescript-eslint/prefer-function-type": "warn",
+        ...overrides
+      }
+    },
+    ...isTypeAware ? [
+      {
+        name: "@bfra.me/typescript/type-aware-rules",
+        files: typeAwareFiles,
+        ignores: typeAwareIgnores,
+        rules: {
+          ...TypeAwareRules,
+          ...typeAware?.overrides
+        }
+      }
+    ] : []
+  ];
+}
+__name(typescript, "typescript");
+
+// src/configs/vitest.ts
+async function vitest(options = {}) {
+  const { files = GLOB_TESTS, isInEditor: isInEditor2 = false, overrides = {} } = options;
+  const [vitestPlugin, noOnlyTests] = await Promise.all([
+    interopDefault(import("@vitest/eslint-plugin")),
+    // @ts-expect-error - No types
+    interopDefault(import("eslint-plugin-no-only-tests"))
+  ]);
+  return [
+    {
+      name: "@bfra.me/vitest/plugin",
+      plugins: {
+        vitest: {
+          ...vitestPlugin,
+          rules: {
+            ...vitestPlugin.rules,
+            ...noOnlyTests.rules
+          }
+        }
+      }
+    },
+    {
+      name: "@bfra.me/vitest/rules",
+      files,
+      rules: {
+        // ...vitestPlugin.configs.recommended.rules,
+        "@typescript-eslint/explicit-function-return-type": "off",
+        "no-unused-expressions": "off",
+        "vitest/no-only-tests": isInEditor2 ? "warn" : "error",
+        ...overrides
+      }
+    }
+  ];
+}
+__name(vitest, "vitest");
+
+// src/env.ts
+import { env } from "node:process";
+import isInCI from "is-in-ci";
+var isInGitLifecycle = !!(env.GIT_PARAMS || env.VSCODE_GIT_COMMAND || env.npm_lifecycle_script?.startsWith("lint-staged"));
+var isInEditor = !isInCI && !isInGitLifecycle && !!(env.VSCODE_PID || env.VSCODE_CWD || env.JETBRAINS_IDE || env.VIM || env.NVIM);
+
+// src/define-config.ts
+var AllowedConfigPropertiesForOptions = Object.keys({});
+async function defineConfig(options = {}, ...userConfigs) {
+  const { gitignore: enableGitignore = true, typescript: enableTypeScript = isPackageExists("typescript") } = options;
+  const isInEditor2 = options.isInEditor ?? isInEditor;
+  if (isInEditor2) console.log("[@bfra.me/eslint-config] Editor specific config is enabled. Some rules may be disabled.");
+  const configs = [];
+  if (enableGitignore) {
+    const gitignoreOptions = typeof enableGitignore !== "boolean" ? enableGitignore : {
+      strict: false
+    };
+    configs.push(interopDefault(import("eslint-config-flat-gitignore")).then((p) => [
+      p({
+        name: "@bfra.me/gitignore",
+        ...gitignoreOptions
+      })
+    ]));
+  }
+  configs.push(ignores(options.ignores), javascript({
+    isInEditor: isInEditor2,
+    overrides: getOverrides(options, "javascript")
+  }), eslintComments(), jsdoc(), imports(), command(), perfectionist());
+  const typescriptOptions = resolveSubOptions(options, "typescript");
+  if (enableTypeScript) {
+    configs.push(typescript({
+      ...typescriptOptions,
+      overrides: getOverrides(options, "typescript")
+    }));
+  }
+  if (options.vitest) {
+    configs.push(vitest({
+      overrides: getOverrides(options, "vitest")
+    }));
+  }
+  configs.push(epilogue());
+  const optionsConfig = AllowedConfigPropertiesForOptions.reduce((config2, key) => {
+    if (key in options) {
+      config2[key] = options[key];
+    }
+    return config2;
+  }, {});
+  if (Object.keys(optionsConfig).length) {
+    configs.push([
+      optionsConfig
+    ]);
+  }
+  const composer = new FlatConfigComposer().append(...configs, ...userConfigs);
+  return composer;
+}
+__name(defineConfig, "defineConfig");
+function resolveSubOptions(options, key) {
+  return typeof options[key] === "boolean" ? {} : options[key] || {};
+}
+__name(resolveSubOptions, "resolveSubOptions");
+function getOverrides(options, key) {
+  const sub = resolveSubOptions(options, key);
+  return "overrides" in sub ? sub.overrides : {};
+}
+__name(getOverrides, "getOverrides");
+
+// src/index.ts
+var src_default = defineConfig();
+export {
+  GLOB_EXCLUDE,
+  GLOB_SRC,
+  GLOB_SRC_EXT,
+  GLOB_TESTS,
+  GLOB_TS,
+  GLOB_TSX,
+  command,
+  src_default as default,
+  defineConfig,
+  epilogue,
+  eslintComments,
+  ignores,
+  imports,
+  isInEditor,
+  isInGitLifecycle,
+  javascript,
+  jsdoc,
+  perfectionist,
+  typescript,
+  vitest
+};
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@bfra.me/eslint-config",
+  "version": "0.1.0",
+  "description": "Shared ESLint configuration for bfra.me",
+  "keywords": [
+    "bfra.me",
+    "config",
+    "eslint",
+    "eslint-config",
+    "shared",
+    "typescript",
+    "works"
+  ],
+  "homepage": "https://github.com/bfra-me/works/tree/main/packages/eslint-config#readme",
+  "bugs": "https://github.com/bfra-me/works/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bfra-me/works.git",
+    "directory": "packages/eslint-config"
+  },
+  "license": "MIT",
+  "author": "Marcus R. Brown <contact@bfra.me>",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "source": "./src/index.ts",
+      "import": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "files": [
+    "src",
+    "lib",
+    "!**/*.map"
+  ],
+  "prettier": "@bfra.me/prettier-config",
+  "dependencies": {
+    "@eslint-community/eslint-plugin-eslint-comments": "4.4.0",
+    "eslint-config-flat-gitignore": "0.3.0",
+    "eslint-flat-config-utils": "0.4.0",
+    "eslint-plugin-command": "0.2.5",
+    "eslint-plugin-import-x": "4.2.1",
+    "eslint-plugin-jsdoc": "50.2.3",
+    "eslint-plugin-perfectionist": "3.6.0",
+    "eslint-plugin-unused-imports": "4.1.4",
+    "globals": "15.9.0",
+    "is-in-ci": "1.0.0",
+    "local-pkg": "0.5.0",
+    "typescript-eslint": "8.5.0"
+  },
+  "devDependencies": {
+    "@eslint/config-inspector": "0.5.4",
+    "@eslint/js": "9.10.0",
+    "@types/eslint__js": "8.42.3",
+    "@types/fs-extra": "11.0.4",
+    "@types/node": "20.16.1",
+    "@vitest/eslint-plugin": "1.1.4",
+    "eslint": "9.11.0",
+    "eslint-plugin-no-only-tests": "3.3.0",
+    "eslint-typegen": "0.3.2",
+    "execa": "9.4.0",
+    "fast-glob": "3.3.2",
+    "fs-extra": "11.2.0",
+    "jiti": "1.21.6",
+    "prettier": "3.3.3",
+    "tsup": "8.3.0",
+    "tsx": "4.19.1",
+    "type-fest": "4.26.0",
+    "vitest": "2.1.0",
+    "@bfra.me/eslint-config": "0.1.0",
+    "@bfra.me/prettier-config": "0.7.3",
+    "@bfra.me/tsconfig": "0.8.1"
+  },
+  "peerDependencies": {
+    "@vitest/eslint-plugin": "^1.1.4",
+    "eslint": "^9.10.0",
+    "eslint-plugin-no-only-tests": "^3.3.0"
+  },
+  "peerDependenciesMeta": {
+    "@vitest/eslint-plugin": {
+      "optional": true
+    },
+    "eslint-plugin-no-only-tests": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "pnpm run generate-types && tsup",
+    "dev": "eslint-config-inspector --config ./inspector/eslint.config.ts",
+    "generate-types": "tsx ./scripts/generate-types.ts",
+    "test": "vitest"
+  }
+}

package/readme.md

@@ -0,0 +1,37 @@
+# @bfra.me/eslint-config
+
+> Shared ESLint configuration for bfra.me.
+
+## Install
+
+### NPM
+
+```sh
+npm install --save-dev @bfra.me/eslint-config eslint
+```
+
+### PNPM
+
+```sh
+pnpm add --save-dev @bfra.me/eslint-config eslint
+```
+
+### Yarn
+
+```sh
+yarn add --dev @bfra.me/eslint-config eslint
+```
+
+## Usage
+
+Add or update your `eslint.config.js` file to include the following:
+
+```ts
+import preset from "@bfra.me/eslint-config"
+
+export default preset()
+```
+
+## License
+
+[MIT](../../LICENSE.md)

package/src/configs/command.ts

@@ -0,0 +1,11 @@
+import config from 'eslint-plugin-command/config'
+import type {Config} from '../types'
+
+export async function command(): Promise<Config[]> {
+  return [
+    {
+      ...config(),
+      name: '@bfra.me/command',
+    },
+  ]
+}

package/src/configs/epilogue.ts

@@ -0,0 +1,16 @@
+import type {Config} from '../types'
+
+export async function epilogue(): Promise<Config[]> {
+  return [
+    {
+      name: '@bfra.me/epilogue/dts',
+      files: ['**/*.d.?([cm])ts'],
+      rules: {
+        'eslint-comments/no-unlimited-disable': 'off',
+        'import/no-duplicates': 'off',
+        'no-restricted-syntax': 'off',
+        'unused-imports/no-unused-vars': 'off',
+      },
+    },
+  ]
+}