@fenge/eslint-config 0.1.0-beta.0

package/src/config/typescript.ts

@@ -0,0 +1,261 @@
+import process from "node:process";
+import * as fengeTsPlugin from "@fenge/eslint-plugin-ts";
+import tsParser from "@typescript-eslint/parser";
+import deprecationPlugin from "eslint-plugin-deprecation";
+import { javascript } from "./javascript.js";
+
+export function typescript(project?: string) {
+  const jsConfig = javascript()[0];
+
+  const getTsExtensionRules = () => {
+    // https://typescript-eslint.io/rules/?=extension
+    const extensionRuleKeys = [
+      "block-spacing",
+      "brace-style",
+      "class-methods-use-this",
+      "comma-dangle",
+      "comma-spacing",
+      "consistent-return",
+      "default-param-last",
+      "dot-notation",
+      "func-call-spacing",
+      "indent",
+      "init-declarations",
+      "key-spacing",
+      "keyword-spacing",
+      "lines-around-comment",
+      "lines-between-class-members",
+      "max-params",
+      "no-array-constructor",
+      "no-dupe-class-members",
+      "no-empty-function",
+      "no-extra-parens",
+      "no-extra-semi",
+      "no-implied-eval",
+      "no-invalid-this",
+      "no-loop-func",
+      // "no-loss-of-precision",
+      "no-magic-numbers",
+      "no-redeclare",
+      "no-restricted-imports",
+      "no-shadow",
+      "no-throw-literal",
+      "no-unused-expressions",
+      "no-unused-vars",
+      "no-use-before-define",
+      "no-useless-constructor",
+      "object-curly-spacing",
+      "only-throw-error", // this rule based on 'eslint/no-throw-literal'
+      "padding-line-between-statements",
+      "prefer-destructuring",
+      "prefer-promise-reject-errors",
+      "quotes",
+      "require-await",
+      "return-await", // this rule based on 'eslint/no-return-await' instead of 'eslint/return-await'
+      "semi",
+      "space-before-blocks",
+      "space-before-function-paren",
+      "space-infix-ops",
+    ] as const;
+    type ExtensionRuleKey = (typeof extensionRuleKeys)[number];
+    type JsConfigRuleKey = keyof typeof jsConfig.rules;
+
+    type JsExtensionKey = Extract<ExtensionRuleKey, JsConfigRuleKey>; // Extract
+    type TsExtensionKey = `@typescript-eslint/${JsExtensionKey}`;
+
+    type GetJsKey<T extends TsExtensionKey> =
+      T extends `@typescript-eslint/${infer K}` ? K : never;
+    type JsResult = {
+      [Key in JsExtensionKey]: "off";
+    };
+    type TsResult = {
+      [Key in TsExtensionKey]: (typeof jsConfig.rules)[GetJsKey<Key>];
+    };
+    type Result = JsResult & TsResult;
+
+    const extensionRuleKeySet = new Set<string>(extensionRuleKeys);
+    return Object.entries(jsConfig.rules)
+      .filter(([key]) => extensionRuleKeySet.has(key))
+      .reduce(
+        (prev, [jsRuleKey, jsRuleValue]) => ({
+          ...prev,
+          [jsRuleKey]: "off",
+          [`@typescript-eslint/${jsRuleKey}`]: jsRuleValue,
+        }),
+        {} as Result,
+      );
+  };
+
+  return [
+    {
+      ...jsConfig,
+      name: "fenge/typescript",
+      files: ["**/*.{ts,cts,mts,tsx}"],
+      languageOptions: {
+        ...jsConfig.languageOptions,
+        parser: tsParser, // Unfortunately parser cannot be a string. Eslint should support it. https://eslint.org/docs/latest/use/configure/configuration-files-new#configuring-a-custom-parser-and-its-options
+        parserOptions: {
+          ...jsConfig.languageOptions.parserOptions,
+          tsconfigRootDir: process.cwd(),
+          project: project ?? "tsconfig.json",
+        },
+      },
+      plugins: {
+        ...jsConfig.plugins,
+        deprecation: deprecationPlugin,
+        "@fenge-ts": fengeTsPlugin,
+      },
+      rules: {
+        ...jsConfig.rules,
+        ...getTsExtensionRules(),
+
+        // deprecation
+        "deprecation/deprecation": "error",
+        // fenge
+        "@fenge-ts/exact-map-set-type": "error",
+        "@fenge-ts/no-const-enum": "error",
+        "@fenge-ts/no-declares-in-ts-file": "error",
+        "@fenge-ts/no-export-assignment": "error",
+        "@fenge-ts/no-property-decorator": "error",
+        "@fenge-ts/no-untyped-empty-array": "error",
+        // typescript
+        "@typescript-eslint/adjacent-overload-signatures": "error",
+        // "@typescript-eslint/array-type": ["error", 'array-simple'], // The default option is 'array'. Not very sure if we need to change the option. So disabled it.
+        "@typescript-eslint/await-thenable": "error",
+        "@typescript-eslint/ban-types": "error",
+        "@typescript-eslint/consistent-generic-constructors": "error",
+        "@typescript-eslint/consistent-indexed-object-style": "error",
+        "@typescript-eslint/consistent-type-assertions": [
+          "error",
+          {
+            assertionStyle: "as",
+            objectLiteralTypeAssertions: "allow-as-parameter",
+          },
+        ],
+        "@typescript-eslint/consistent-type-definitions": [
+          "error",
+          "interface",
+        ], // TODO should we change to 'type'?
+        "@typescript-eslint/consistent-type-exports": "error",
+        // "@typescript-eslint/consistent-type-imports": "error,
+        "@typescript-eslint/dot-notation": ["error", { allowKeywords: true }],
+        "@typescript-eslint/method-signature-style": "error",
+        "@typescript-eslint/naming-convention": [
+          "error",
+          {
+            selector: "function",
+            format: ["camelCase", "PascalCase"],
+          },
+          {
+            selector: "variable",
+            types: ["function"],
+            format: ["camelCase", "PascalCase"], // decorators need PascalCase
+          },
+          {
+            selector: "class",
+            format: ["PascalCase"],
+          },
+          {
+            selector: "interface",
+            format: ["PascalCase"],
+          },
+          {
+            selector: "typeAlias",
+            format: ["PascalCase"],
+          },
+          {
+            selector: "typeParameter",
+            format: ["UPPER_CASE", "PascalCase"],
+          },
+        ],
+        "@typescript-eslint/no-array-delete": "error",
+        "@typescript-eslint/no-base-to-string": [
+          "error",
+          { ignoredTypeNames: [] },
+        ],
+        "@typescript-eslint/no-confusing-non-null-assertion": "error",
+        "@typescript-eslint/no-duplicate-enum-values": "error",
+        "@typescript-eslint/no-duplicate-type-constituents": "error",
+        "@typescript-eslint/no-empty-object-type": "error",
+        "@typescript-eslint/no-extra-non-null-assertion": "error",
+        "@typescript-eslint/no-floating-promises": [
+          "error",
+          {
+            ignoreVoid: false,
+          },
+        ],
+        "@typescript-eslint/no-for-in-array": "error",
+        "@typescript-eslint/no-import-type-side-effects": "error",
+        "@typescript-eslint/no-inferrable-types": "error",
+        "@typescript-eslint/no-misused-new": "error",
+        "@typescript-eslint/no-misused-promises": "error",
+        "@typescript-eslint/no-mixed-enums": "error",
+        "@typescript-eslint/no-namespace": "error",
+        "@typescript-eslint/no-non-null-asserted-optional-chain": "error",
+        "@typescript-eslint/no-non-null-assertion": "error",
+        "@typescript-eslint/no-require-imports": "error",
+        "@typescript-eslint/no-this-alias": "error",
+        "@typescript-eslint/no-unnecessary-condition": "error",
+        "@typescript-eslint/no-unnecessary-parameter-property-assignment":
+          "error",
+        "@typescript-eslint/no-unnecessary-template-expression": "error", // js also need this rule
+        "@typescript-eslint/no-unnecessary-type-assertion": "error",
+        "@typescript-eslint/no-unnecessary-type-constraint": "error",
+        "@typescript-eslint/no-unsafe-declaration-merging": "error",
+        // '@typescript-eslint/no-unsafe-function-type': "error",
+        // "@typescript-eslint/no-wrapper-object-types": "error",
+        "@typescript-eslint/only-throw-error": "error",
+        "@typescript-eslint/prefer-as-const": "error",
+        "@typescript-eslint/prefer-function-type": "error",
+        "@typescript-eslint/prefer-optional-chain": "error",
+        "@typescript-eslint/prefer-readonly": "error",
+        "@typescript-eslint/prefer-ts-expect-error": "error",
+        "@typescript-eslint/restrict-plus-operands": [
+          "error",
+          {
+            // allowAny: false,
+            allowBoolean: false,
+            allowNullish: false,
+            allowNumberAndString: false,
+            allowRegExp: false,
+          },
+        ],
+        // "@typescript-eslint/restrict-template-expressions": "error",
+        "@typescript-eslint/return-await": ["error", "always"],
+        "@typescript-eslint/switch-exhaustiveness-check": [
+          "error",
+          { requireDefaultForNonUnion: true },
+        ],
+        "@typescript-eslint/unbound-method": "error",
+        "@typescript-eslint/unified-signatures": "error",
+      },
+    },
+    {
+      name: "fenge/typescript/config",
+      files: ["**/*.config.{ts,cts,mts,tsx}"],
+      rules: {
+        "import/no-default-export": "off",
+      },
+    },
+    {
+      name: "fenge/typescript/declaration",
+      files: ["**/*.d.{ts,cts,mts,tsx}"],
+      rules: {
+        "import/no-default-export": "off",
+      },
+    },
+    {
+      // https://github.com/motemen/minimatch-cheat-sheet
+      name: "fenge/typescript/test",
+      files: [
+        "**/__tests__/**/*.{ts,cts,mts,tsx}",
+        "**/*.{test,spec}.{ts,cts,mts,tsx}",
+      ],
+      rules: {
+        "@typescript-eslint/no-floating-promises": "off",
+        "@typescript-eslint/unbound-method": "off",
+        "esm/no-phantom-dep-imports": ["error", { allowDevDependencies: true }],
+      },
+    },
+  ] as const;
+}

package/src/eslint.config.spec.ts

@@ -0,0 +1,32 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import config from "./eslint.config.js";
+
+await describe("eslint.config", async () => {
+  await it("length of default export should be 9", () => {
+    assert.strictEqual(config.length, 9);
+  });
+  await it("no warns", () => {
+    config.forEach((configItem) => {
+      if (
+        "rules" in configItem &&
+        typeof configItem.rules === "object" &&
+        configItem.rules
+      ) {
+        Object.values(configItem.rules).forEach((value) => {
+          assert.notStrictEqual(getValueString(value), "warn");
+        });
+      }
+    });
+  });
+});
+
+function getValueString(value: unknown): string {
+  if (typeof value === "string") {
+    return value;
+  } else if (Array.isArray(value) && typeof value[0] === "string") {
+    return value[0];
+  } else {
+    throw new Error("unknown value");
+  }
+}

package/src/eslint.config.ts

@@ -0,0 +1,100 @@
+import { gitignore } from "./config/gitignore.js";
+import { ignore } from "./config/ignore.js";
+import { javascript } from "./config/javascript.js";
+import { packagejson } from "./config/packagejson.js";
+import { typescript } from "./config/typescript.js";
+
+type JsRuleKey = keyof ReturnType<typeof javascript>[0]["rules"];
+type TsRuleKey = keyof ReturnType<typeof typescript>[0]["rules"];
+type PkgRuleKey = keyof ReturnType<typeof packagejson>[0]["rules"];
+
+interface Options<T extends string> {
+  pick?: T[];
+  omit?: T[];
+  extend?: Record<
+    string,
+    "error" | "warn" | "off" | ["error" | "warn", ...unknown[]]
+  >;
+  override?: Partial<
+    Record<T, "error" | "warn" | "off" | ["error" | "warn", ...unknown[]]>
+  >;
+}
+
+export class Builder {
+  private readonly configs: object[] = [...gitignore(), ...ignore()];
+
+  toConfig() {
+    return this.configs;
+  }
+
+  private setup(
+    [mainConfig, ...otherConfigs]: readonly [
+      { plugins: object; rules: object },
+      ...object[],
+    ],
+    { pick, omit, extend = {}, override = {} }: Options<string>,
+  ) {
+    const select = (ruleKey: string) => {
+      if (!pick && !omit) {
+        return true;
+      } else if (pick && !omit) {
+        return pick.includes(ruleKey);
+      } else if (!pick && omit) {
+        return !omit.includes(ruleKey);
+      } else {
+        throw new Error("You cannot specify both pick and omit");
+      }
+    };
+    const rules = Object.fromEntries(
+      Object.entries(mainConfig.rules).filter(([ruleKey]) => select(ruleKey)),
+    );
+    // check `override` field
+    Object.keys(override).forEach((key) => {
+      if (!(key in rules)) {
+        throw new Error(`The overriding rule key ${key} is not existing.`);
+      }
+    });
+    // check `extend` field
+    Object.keys(extend).forEach((key) => {
+      if (key in rules) {
+        throw new Error(`The extending rule key ${key} is already existing.`);
+      }
+      if (key.includes("/")) {
+        const pluginName = key.split("/")[0];
+        if (!pluginName)
+          throw new Error(`The extending rule key '${key}' is invalid`);
+        if (!(pluginName in mainConfig.plugins)) {
+          const supportedPlugins = Object.keys(mainConfig.plugins)
+            .map((k) => `'${k}'`)
+            .join(",");
+          throw new Error(
+            `The plugin name '${pluginName}' of extending rule key '${key}' is not supported. Only ${supportedPlugins} plugins are supported.`,
+          );
+        }
+      }
+    });
+    this.configs.push(
+      { ...mainConfig, rules: { ...rules, ...override, ...extend } },
+      ...otherConfigs,
+    );
+    return this;
+  }
+
+  enableTypescript(options: Options<TsRuleKey> & { project?: string } = {}) {
+    return this.setup(typescript(options.project), options);
+  }
+
+  enableJavascript(options: Options<JsRuleKey> = {}) {
+    return this.setup(javascript(), options);
+  }
+
+  enablePackagejson(options: Options<PkgRuleKey> = {}) {
+    return this.setup(packagejson(), options);
+  }
+}
+
+export default new Builder()
+  .enablePackagejson()
+  .enableJavascript()
+  .enableTypescript()
+  .toConfig();

package/src/typing.d.ts

@@ -0,0 +1,8 @@
+declare module "eslint-plugin-*" {
+  declare const plugin: unknown;
+  export default plugin;
+}
+declare module "confusing-browser-globals" {
+  declare const keys: string[];
+  export default keys;
+}

package/test/no-duplicated.spec.ts

@@ -0,0 +1,61 @@
+import assert from "node:assert";
+import fs from "node:fs/promises";
+import { describe, it } from "node:test";
+import prettier from "prettier";
+import { javascript } from "../src/config/javascript.js";
+import { typescript } from "../src/config/typescript.js";
+
+function count(content: string, substring: string) {
+  return (content.match(new RegExp(`"${substring}"`, "g")) ?? []).length;
+}
+
+await describe("no duplicated", async () => {
+  await it("no duplicated js rules is defined", async () => {
+    const configContent = await prettier.format(
+      (await fs.readFile("./src/config/javascript.ts", "utf-8")).replace(
+        "// prettier-ignore",
+        "",
+      ),
+      { parser: "typescript", quoteProps: "consistent" },
+    );
+
+    Object.keys(javascript()[0].rules)
+      .filter(
+        (rule) =>
+          !["import/no-default-export", "esm/no-phantom-dep-imports"].includes(
+            rule,
+          ),
+      )
+      .forEach((rule) => {
+        assert.strictEqual(count(configContent, rule), 1);
+      });
+  });
+
+  await it("no duplicated ts rules is defined", async () => {
+    const configContent = await prettier.format(
+      (await fs.readFile("./src/config/typescript.ts", "utf-8")).replace(
+        "// prettier-ignore",
+        "",
+      ),
+      { parser: "typescript", quoteProps: "consistent" },
+    );
+
+    typescript()
+      .flatMap((c) => Object.keys(c.rules))
+      .forEach((rule) => {
+        if (
+          [
+            // "@typescript-eslint/consistent-type-assertions",
+            "@typescript-eslint/no-floating-promises",
+            // "@typescript-eslint/no-non-null-assertion",
+            "@typescript-eslint/unbound-method",
+            "import/no-default-export",
+          ].includes(rule)
+        ) {
+          assert.strictEqual(count(configContent, rule), 2);
+        } else {
+          assert.strictEqual(count(configContent, rule) <= 1, true);
+        }
+      });
+  });
+});

package/test/prettier.spec.ts

@@ -0,0 +1,42 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import prettierConfig from "eslint-config-prettier";
+import { javascript } from "../src/config/javascript.js";
+import { packagejson } from "../src/config/packagejson.js";
+import { typescript } from "../src/config/typescript.js";
+
+await describe("prettier", async () => {
+  await it("prettier config should be standard", () => {
+    const properties = Object.keys(prettierConfig);
+    assert.deepStrictEqual(properties, ["rules"]);
+
+    const ruleValues = [...new Set(Object.values(prettierConfig.rules))];
+    assert.strictEqual(ruleValues.length, 2);
+    assert.strictEqual(ruleValues.includes(0), true);
+    assert.strictEqual(ruleValues.includes("off"), true);
+  });
+
+  await it("should not have prettier-conflicted rules", () => {
+    const included = (rule: string) => rule in prettierConfig.rules;
+
+    // 1
+    const jsForbidRule = Object.keys(javascript()[0].rules).find((rule) =>
+      included(rule),
+    );
+    assert.strictEqual(jsForbidRule, undefined);
+
+    // 2
+    assert.strictEqual(typeof typescript()[0], "object");
+    assert.strictEqual(typescript().length, 4);
+    const tsForbidRule = typescript()
+      .flatMap((config) => Object.keys(config.rules))
+      .find((rule) => included(rule));
+    assert.strictEqual(tsForbidRule, undefined);
+
+    // 3
+    const packagejsonRule = Object.keys(packagejson()[0].rules).find((rule) =>
+      included(rule),
+    );
+    assert.strictEqual(packagejsonRule, undefined);
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig",
+  "include": ["src"],
+  "exclude": ["**/*.spec.ts", "**/*.test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig"
+}