@fenge/eslint-config 0.8.3 → 0.9.1

package/dist/config/ts/base.d.ts

@@ -331,12 +331,157 @@ export declare function getTsBase(): {
         readonly unicorn: import("eslint").ESLint.Plugin & {
             configs: {
                 recommended: import("eslint").Linter.FlatConfig;
+                unopinionated: import("eslint").Linter.FlatConfig;
                 all: import("eslint").Linter.FlatConfig;
                 "flat/all": import("eslint").Linter.FlatConfig;
                 "flat/recommended": import("eslint").Linter.FlatConfig;
             };
         };
-        readonly "es-x": unknown;
+        readonly "es-x": {
+            meta: {
+                name: string;
+                version: string;
+            };
+            configs: {
+                "flat/no-array-grouping": import("eslint").Linter.Config;
+                "flat/no-arraybuffer-base64": import("eslint").Linter.Config;
+                "flat/no-change-array-by-copy": import("eslint").Linter.Config;
+                "flat/no-class-fields": import("eslint").Linter.Config;
+                "flat/no-explicit-resource-management": import("eslint").Linter.Config;
+                "flat/no-float16array": import("eslint").Linter.Config;
+                "flat/no-import-attributes": import("eslint").Linter.Config;
+                "flat/no-intl-locale-info": import("eslint").Linter.Config;
+                "flat/no-intl-numberformat-v3": import("eslint").Linter.Config;
+                "flat/no-is-usv-string": import("eslint").Linter.Config;
+                "flat/no-iterator-helpers": import("eslint").Linter.Config;
+                "flat/no-json-parse-with-source": import("eslint").Linter.Config;
+                "flat/no-new-in-es5": import("eslint").Linter.Config;
+                "flat/no-new-in-es2015": import("eslint").Linter.Config;
+                "flat/no-new-in-es2015-intl-api": import("eslint").Linter.Config;
+                "flat/no-new-in-es2016": import("eslint").Linter.Config;
+                "flat/no-new-in-es2016-intl-api": import("eslint").Linter.Config;
+                "flat/no-new-in-es2017": import("eslint").Linter.Config;
+                "flat/no-new-in-es2017-intl-api": import("eslint").Linter.Config;
+                "flat/no-new-in-es2018": import("eslint").Linter.Config;
+                "flat/no-new-in-es2018-intl-api": import("eslint").Linter.Config;
+                "flat/no-new-in-es2019": import("eslint").Linter.Config;
+                "flat/no-new-in-es2019-intl-api": import("eslint").Linter.Config;
+                "flat/no-new-in-es2020": import("eslint").Linter.Config;
+                "flat/no-new-in-es2020-intl-api": import("eslint").Linter.Config;
+                "flat/no-new-in-es2021": import("eslint").Linter.Config;
+                "flat/no-new-in-es2021-intl-api": import("eslint").Linter.Config;
+                "flat/no-new-in-es2022": import("eslint").Linter.Config;
+                "flat/no-new-in-es2022-intl-api": import("eslint").Linter.Config;
+                "flat/no-new-in-es2023": import("eslint").Linter.Config;
+                "flat/no-new-in-es2023-intl-api": import("eslint").Linter.Config;
+                "flat/no-new-in-es2024": import("eslint").Linter.Config;
+                "flat/no-new-in-es2024-intl-api": import("eslint").Linter.Config;
+                "flat/no-new-in-es2025": import("eslint").Linter.Config;
+                "flat/no-new-in-es2025-intl-api": import("eslint").Linter.Config;
+                "flat/no-new-in-esnext": import("eslint").Linter.Config;
+                "flat/no-new-in-esnext-intl-api": import("eslint").Linter.Config;
+                "flat/no-relative-indexing-method": import("eslint").Linter.Config;
+                "flat/no-set-methods": import("eslint").Linter.Config;
+                "flat/no-string-matchall": import("eslint").Linter.Config;
+                "flat/no-temporal": import("eslint").Linter.Config;
+                "flat/no-upsert": import("eslint").Linter.Config;
+                "flat/restrict-to-es-intl-api-1st-edition": import("eslint").Linter.Config;
+                "flat/restrict-to-es3": import("eslint").Linter.Config;
+                "flat/restrict-to-es5": import("eslint").Linter.Config;
+                "flat/restrict-to-es2015": import("eslint").Linter.Config;
+                "flat/restrict-to-es2015-intl-api": import("eslint").Linter.Config;
+                "flat/restrict-to-es2016": import("eslint").Linter.Config;
+                "flat/restrict-to-es2016-intl-api": import("eslint").Linter.Config;
+                "flat/restrict-to-es2017": import("eslint").Linter.Config;
+                "flat/restrict-to-es2017-intl-api": import("eslint").Linter.Config;
+                "flat/restrict-to-es2018": import("eslint").Linter.Config;
+                "flat/restrict-to-es2018-intl-api": import("eslint").Linter.Config;
+                "flat/restrict-to-es2019": import("eslint").Linter.Config;
+                "flat/restrict-to-es2019-intl-api": import("eslint").Linter.Config;
+                "flat/restrict-to-es2020": import("eslint").Linter.Config;
+                "flat/restrict-to-es2020-intl-api": import("eslint").Linter.Config;
+                "flat/restrict-to-es2021": import("eslint").Linter.Config;
+                "flat/restrict-to-es2021-intl-api": import("eslint").Linter.Config;
+                "flat/restrict-to-es2022": import("eslint").Linter.Config;
+                "flat/restrict-to-es2022-intl-api": import("eslint").Linter.Config;
+                "flat/restrict-to-es2023": import("eslint").Linter.Config;
+                "flat/restrict-to-es2023-intl-api": import("eslint").Linter.Config;
+                "flat/restrict-to-es2024": import("eslint").Linter.Config;
+                "flat/restrict-to-es2024-intl-api": import("eslint").Linter.Config;
+                "no-array-grouping": import("eslint").Linter.LegacyConfig;
+                "no-arraybuffer-base64": import("eslint").Linter.LegacyConfig;
+                "no-change-array-by-copy": import("eslint").Linter.LegacyConfig;
+                "no-class-fields": import("eslint").Linter.LegacyConfig;
+                "no-explicit-resource-management": import("eslint").Linter.LegacyConfig;
+                "no-float16array": import("eslint").Linter.LegacyConfig;
+                "no-import-attributes": import("eslint").Linter.LegacyConfig;
+                "no-intl-locale-info": import("eslint").Linter.LegacyConfig;
+                "no-intl-numberformat-v3": import("eslint").Linter.LegacyConfig;
+                "no-is-usv-string": import("eslint").Linter.LegacyConfig;
+                "no-iterator-helpers": import("eslint").Linter.LegacyConfig;
+                "no-json-parse-with-source": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es5": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2015": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2015-intl-api": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2016": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2016-intl-api": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2017": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2017-intl-api": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2018": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2018-intl-api": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2019": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2019-intl-api": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2020": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2020-intl-api": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2021": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2021-intl-api": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2022": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2022-intl-api": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2023": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2023-intl-api": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2024": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2024-intl-api": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2025": import("eslint").Linter.LegacyConfig;
+                "no-new-in-es2025-intl-api": import("eslint").Linter.LegacyConfig;
+                "no-new-in-esnext": import("eslint").Linter.LegacyConfig;
+                "no-new-in-esnext-intl-api": import("eslint").Linter.LegacyConfig;
+                "no-relative-indexing-method": import("eslint").Linter.LegacyConfig;
+                "no-set-methods": import("eslint").Linter.LegacyConfig;
+                "no-string-matchall": import("eslint").Linter.LegacyConfig;
+                "no-temporal": import("eslint").Linter.LegacyConfig;
+                "no-upsert": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es-intl-api-1st-edition": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es3": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es5": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2015": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2015-intl-api": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2016": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2016-intl-api": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2017": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2017-intl-api": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2018": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2018-intl-api": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2019": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2019-intl-api": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2020": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2020-intl-api": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2021": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2021-intl-api": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2022": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2022-intl-api": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2023": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2023-intl-api": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2024": import("eslint").Linter.LegacyConfig;
+                "restrict-to-es2024-intl-api": import("eslint").Linter.LegacyConfig;
+                readonly "no-5": import("eslint").Linter.LegacyConfig;
+                readonly "no-2015": import("eslint").Linter.LegacyConfig;
+                readonly "no-2016": import("eslint").Linter.LegacyConfig;
+                readonly "no-2017": import("eslint").Linter.LegacyConfig;
+                readonly "no-2018": import("eslint").Linter.LegacyConfig;
+                readonly "no-2019": import("eslint").Linter.LegacyConfig;
+            };
+            rules: Record<string, import("eslint").Rule.RuleModule>;
+        };
         readonly "eslint-comments": typeof import("@eslint-community/eslint-plugin-eslint-comments");
         readonly esm: typeof import("eslint-plugin-esm");
         readonly "simple-import-sort": import("eslint").ESLint.Plugin;
@@ -476,63 +621,29 @@ export declare function getTsBase(): {
         readonly "@typescript-eslint/unbound-method": "error";
         readonly "@typescript-eslint/unified-signatures": "error";
         readonly "@typescript-eslint/use-unknown-in-catch-callback-variable": "error";
-        readonly "default-param-last": "off";
-        readonly "init-declarations": "off";
-        readonly "max-params": "off";
-        readonly "no-empty-function": "off";
-        readonly "no-invalid-this": "off";
-        readonly "no-shadow": "off";
-        readonly "no-useless-constructor": "off";
         readonly "require-await": "off";
-        readonly "no-array-constructor": "off";
-        readonly "no-dupe-class-members": "off";
         readonly "no-implied-eval": "off";
         readonly "no-redeclare": "off";
         readonly "no-throw-literal": "off";
-        readonly "no-unused-expressions": "off";
         readonly "no-unused-vars": "off";
-        readonly "no-use-before-define": "off";
         readonly "prefer-promise-reject-errors": "off";
-        readonly "@typescript-eslint/default-param-last": "error";
-        readonly "@typescript-eslint/init-declarations": "error";
-        readonly "@typescript-eslint/max-params": readonly ["error", {
-            readonly max: 4;
-        }];
-        readonly "@typescript-eslint/no-array-constructor": "error";
-        readonly "@typescript-eslint/no-dupe-class-members": "error";
-        readonly "@typescript-eslint/no-empty-function": "error";
         readonly "@typescript-eslint/no-implied-eval": "error";
-        readonly "@typescript-eslint/no-invalid-this": "error";
         readonly "@typescript-eslint/no-redeclare": readonly ["error", {
             readonly builtinGlobals: false;
         }];
-        readonly "@typescript-eslint/no-shadow": readonly ["error", {
-            readonly ignoreOnInitialization: true;
-        }];
-        readonly "@typescript-eslint/no-unused-expressions": readonly ["error", {
-            readonly enforceForJSX: true;
-            readonly allowShortCircuit: true;
-            readonly allowTernary: true;
-            readonly allowTaggedTemplates: true;
-        }];
         readonly "@typescript-eslint/no-unused-vars": readonly ["error", {
             readonly args: "none";
             readonly caughtErrors: "none";
             readonly ignoreRestSiblings: true;
             readonly vars: "all";
         }];
-        readonly "@typescript-eslint/no-use-before-define": readonly ["error", {
-            readonly functions: false;
-            readonly classes: false;
-            readonly variables: false;
-        }];
-        readonly "@typescript-eslint/no-useless-constructor": "error";
         readonly "@typescript-eslint/prefer-promise-reject-errors": "error";
         readonly "@typescript-eslint/require-await": "error";
         readonly "arrow-body-style": readonly ["error", "as-needed"];
         readonly "simple-import-sort/exports": "error";
         readonly "unicorn/prefer-node-protocol": "error";
         readonly "unicorn/escape-case": "error";
+        readonly "default-param-last": "error";
         readonly "for-direction": "error";
         readonly "func-name-matching": "error";
         readonly "func-names": "error";
@@ -540,18 +651,23 @@ export declare function getTsBase(): {
             readonly allowArrowFunctions: true;
         }];
         readonly "getter-return": "error";
+        readonly "init-declarations": "error";
         readonly "logical-assignment-operators": readonly ["error", "always", {
             readonly enforceForIfStatements: true;
         }];
         readonly "max-depth": readonly ["error", {
             readonly max: 5;
         }];
+        readonly "max-params": readonly ["error", {
+            readonly max: 4;
+        }];
         readonly "no-bitwise": "error";
         readonly "no-console": "error";
         readonly "no-constant-binary-expression": "error";
         readonly "no-dupe-else-if": "error";
         readonly "no-duplicate-imports": "error";
         readonly "no-empty-static-block": "error";
+        readonly "no-empty-function": "error";
         readonly "no-implicit-coercion": readonly ["error", {
             readonly disallowTemplateShorthand: true;
             readonly allow: readonly ["!!"];
@@ -559,6 +675,7 @@ export declare function getTsBase(): {
         readonly "no-inner-declarations": readonly ["error", "functions", {
             readonly blockScopedFunctions: "disallow";
         }];
+        readonly "no-invalid-this": "error";
         readonly "no-lonely-if": "error";
         readonly "no-multi-assign": "error";
         readonly "no-new-native-nonconstructor": "error";
@@ -567,6 +684,10 @@ export declare function getTsBase(): {
         readonly "no-param-reassign": "error";
         readonly "no-plusplus": "error";
         readonly "no-setter-return": "error";
+        readonly "no-shadow": readonly ["error", {
+            readonly ignoreOnInitialization: true;
+        }];
+        readonly "no-unassigned-vars": "error";
         readonly "no-unsafe-optional-chaining": readonly ["error", {
             readonly disallowArithmeticOperators: true;
         }];
@@ -576,6 +697,7 @@ export declare function getTsBase(): {
         readonly "no-useless-call": "error";
         readonly "no-useless-catch": "error";
         readonly "no-useless-computed-key": "error";
+        readonly "no-useless-constructor": "error";
         readonly "no-useless-escape": "error";
         readonly "no-useless-rename": "error";
         readonly "no-useless-return": "error";
@@ -797,6 +919,12 @@ export declare function getTsBase(): {
         readonly "unicorn/no-accessor-recursion": "error";
         readonly "unicorn/no-array-callback-reference": "error";
         readonly "unicorn/no-array-method-this-argument": "error";
+        readonly "unicorn/no-array-reverse": readonly ["error", {
+            readonly allowExpressionStatement: false;
+        }];
+        readonly "unicorn/no-array-sort": readonly ["error", {
+            readonly allowExpressionStatement: false;
+        }];
         readonly "unicorn/no-await-in-promise-methods": "error";
         readonly "unicorn/no-for-loop": "error";
         readonly "unicorn/no-instanceof-builtins": "error";
@@ -815,15 +943,20 @@ export declare function getTsBase(): {
         readonly "unicorn/no-unnecessary-await": "error";
         readonly "unicorn/no-unreadable-array-destructuring": "error";
         readonly "unicorn/no-unreadable-iife": "error";
+        readonly "unicorn/no-useless-error-capture-stack-trace": "error";
         readonly "unicorn/no-useless-fallback-in-spread": "error";
         readonly "unicorn/no-useless-promise-resolve-reject": "error";
         readonly "unicorn/no-useless-spread": "error";
         readonly "unicorn/no-useless-switch-case": "error";
         readonly "unicorn/no-zero-fractions": "error";
         readonly "unicorn/prefer-array-flat-map": "error";
+        readonly "unicorn/prefer-bigint-literals": "error";
+        readonly "unicorn/prefer-class-fields": "error";
+        readonly "unicorn/prefer-classlist-toggle": "error";
         readonly "unicorn/prefer-date-now": "error";
         readonly "unicorn/prefer-export-from": "error";
         readonly "unicorn/prefer-global-this": "error";
+        readonly "unicorn/prefer-import-meta-properties": "error";
         readonly "unicorn/prefer-includes": "error";
         readonly "unicorn/prefer-logical-operator-over-ternary": "error";
         readonly "unicorn/prefer-math-min-max": "error";
@@ -839,6 +972,8 @@ export declare function getTsBase(): {
         readonly "unicorn/prefer-string-slice": "error";
         readonly "unicorn/prefer-ternary": "error";
         readonly "unicorn/require-array-join-separator": "error";
+        readonly "unicorn/require-module-attributes": "error";
+        readonly "unicorn/require-module-specifiers": "error";
         readonly "unicorn/require-number-to-fixed-digits-argument": "error";
         readonly "unicorn/text-encoding-identifier-case": "error";
         readonly "unicorn/throw-new-error": "error";
@@ -852,6 +987,7 @@ export declare function getTsBase(): {
         readonly "@fenge/no-top-level-arrow-function": "error";
         readonly "@fenge/no-triple-slash-directive": "error";
         readonly "@fenge/no-unnecessary-template-string": "error";
+        readonly "@fenge/no-used-underscore-param": "error";
         readonly "@typescript-eslint/ban-ts-comment": readonly ["error", {
             readonly "ts-expect-error": true;
             readonly "ts-ignore": true;
@@ -883,6 +1019,7 @@ export declare function getTsBase(): {
             readonly capIsNew: false;
             readonly properties: true;
         }];
+        readonly "no-array-constructor": "error";
         readonly "no-async-promise-executor": "error";
         readonly "no-caller": "error";
         readonly "no-case-declarations": "error";
@@ -897,6 +1034,7 @@ export declare function getTsBase(): {
         readonly "no-debugger": "error";
         readonly "no-delete-var": "error";
         readonly "no-dupe-args": "error";
+        readonly "no-dupe-class-members": "error";
         readonly "no-dupe-keys": "error";
         readonly "no-duplicate-case": "error";
         readonly "no-useless-backreference": "error";
@@ -954,6 +1092,17 @@ export declare function getTsBase(): {
         readonly "no-unreachable-loop": "error";
         readonly "no-unsafe-finally": "error";
         readonly "no-unsafe-negation": "error";
+        readonly "no-unused-expressions": readonly ["error", {
+            readonly enforceForJSX: true;
+            readonly allowShortCircuit: true;
+            readonly allowTernary: true;
+            readonly allowTaggedTemplates: true;
+        }];
+        readonly "no-use-before-define": readonly ["error", {
+            readonly functions: false;
+            readonly classes: false;
+            readonly variables: false;
+        }];
         readonly "no-void": "error";
         readonly "no-with": "error";
         readonly "one-var": readonly ["error", {

package/dist/config/ts/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/config/ts/base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,yBAAyB,CAAC;AAGzD,wBAAgB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoQxB"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/config/ts/base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,yBAAyB,CAAC;AAGzD,wBAAgB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqQxB"}

package/dist/config/ts/base.js

@@ -5,28 +5,29 @@ export function getTsBase() {
     const getTsExtensionRules = () => {
         // Key is js rule, value is ts rule
         // https://typescript-eslint.io/rules/?=extension
+        // Some rules are implemented by eslint core, so we comment them out.
         const extensionRuleMap = {
-            "class-methods-use-this": "@typescript-eslint/class-methods-use-this",
+            // "class-methods-use-this": "@typescript-eslint/class-methods-use-this", // 9.23.0
             "consistent-return": "@typescript-eslint/consistent-return",
-            "default-param-last": "@typescript-eslint/default-param-last",
+            // "default-param-last": "@typescript-eslint/default-param-last", // 9.23.0
             "dot-notation": "@typescript-eslint/dot-notation",
-            "init-declarations": "@typescript-eslint/init-declarations",
-            "max-params": "@typescript-eslint/max-params",
-            "no-array-constructor": "@typescript-eslint/no-array-constructor",
-            "no-dupe-class-members": "@typescript-eslint/no-dupe-class-members",
-            "no-empty-function": "@typescript-eslint/no-empty-function",
+            // "init-declarations": "@typescript-eslint/init-declarations", // 9.24.0
+            // "max-params": "@typescript-eslint/max-params", // 9.27.0
+            // "no-array-constructor": "@typescript-eslint/no-array-constructor", // 9.24.0
+            // "no-dupe-class-members": "@typescript-eslint/no-dupe-class-members", // 9.24.0
+            // "no-empty-function": "@typescript-eslint/no-empty-function", // 9.25.0
             "no-implied-eval": "@typescript-eslint/no-implied-eval",
-            "no-invalid-this": "@typescript-eslint/no-invalid-this",
-            "no-loop-func": "@typescript-eslint/no-loop-func",
-            // "no-loss-of-precision": "@typescript-eslint/no-loss-of-precision", // This rule has been deprecated
-            "no-magic-numbers": "@typescript-eslint/no-magic-numbers",
+            // "no-invalid-this": "@typescript-eslint/no-invalid-this", // 9.25.0
+            // "no-loop-func": "@typescript-eslint/no-loop-func", // 9.25.0
+            // "no-loss-of-precision": "@typescript-eslint/no-loss-of-precision", // 9.24.0. And this rule has been deprecated
+            // "no-magic-numbers": "@typescript-eslint/no-magic-numbers", // 9.28.0
             "no-redeclare": "@typescript-eslint/no-redeclare",
             "no-restricted-imports": "@typescript-eslint/no-restricted-imports",
-            "no-shadow": "@typescript-eslint/no-shadow",
-            "no-unused-expressions": "@typescript-eslint/no-unused-expressions",
+            // "no-shadow": "@typescript-eslint/no-shadow", // 9.28.0
+            // "no-unused-expressions": "@typescript-eslint/no-unused-expressions", // 9.25.0
             "no-unused-vars": "@typescript-eslint/no-unused-vars",
-            "no-use-before-define": "@typescript-eslint/no-use-before-define",
-            "no-useless-constructor": "@typescript-eslint/no-useless-constructor",
+            // "no-use-before-define": "@typescript-eslint/no-use-before-define", // 9.28.0
+            // "no-useless-constructor": "@typescript-eslint/no-useless-constructor", // 9.23.0
             "no-throw-literal": "@typescript-eslint/only-throw-error",
             "prefer-destructuring": "@typescript-eslint/prefer-destructuring",
             "prefer-promise-reject-errors": "@typescript-eslint/prefer-promise-reject-errors",
@@ -232,4 +233,4 @@ export function getTsBase() {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../src/config/ts/base.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fengeTsPlugin from \"@fenge/eslint-plugin-ts\";\nimport { getJsBase } from \"../js/base.ts\";\n\nexport function getTsBase() {\n  const jsBase = getJsBase();\n\n  const getTsExtensionRules = () => {\n    // Key is js rule, value is ts rule\n    // https://typescript-eslint.io/rules/?=extension\n    const extensionRuleMap = {\n      \"class-methods-use-this\": \"@typescript-eslint/class-methods-use-this\",\n      \"consistent-return\": \"@typescript-eslint/consistent-return\",\n      \"default-param-last\": \"@typescript-eslint/default-param-last\",\n      \"dot-notation\": \"@typescript-eslint/dot-notation\",\n      \"init-declarations\": \"@typescript-eslint/init-declarations\",\n      \"max-params\": \"@typescript-eslint/max-params\",\n      \"no-array-constructor\": \"@typescript-eslint/no-array-constructor\",\n      \"no-dupe-class-members\": \"@typescript-eslint/no-dupe-class-members\",\n      \"no-empty-function\": \"@typescript-eslint/no-empty-function\",\n      \"no-implied-eval\": \"@typescript-eslint/no-implied-eval\",\n      \"no-invalid-this\": \"@typescript-eslint/no-invalid-this\",\n      \"no-loop-func\": \"@typescript-eslint/no-loop-func\",\n      // \"no-loss-of-precision\": \"@typescript-eslint/no-loss-of-precision\", // This rule has been deprecated\n      \"no-magic-numbers\": \"@typescript-eslint/no-magic-numbers\",\n      \"no-redeclare\": \"@typescript-eslint/no-redeclare\",\n      \"no-restricted-imports\": \"@typescript-eslint/no-restricted-imports\",\n      \"no-shadow\": \"@typescript-eslint/no-shadow\",\n      \"no-unused-expressions\": \"@typescript-eslint/no-unused-expressions\",\n      \"no-unused-vars\": \"@typescript-eslint/no-unused-vars\",\n      \"no-use-before-define\": \"@typescript-eslint/no-use-before-define\",\n      \"no-useless-constructor\": \"@typescript-eslint/no-useless-constructor\",\n      \"no-throw-literal\": \"@typescript-eslint/only-throw-error\",\n      \"prefer-destructuring\": \"@typescript-eslint/prefer-destructuring\",\n      \"prefer-promise-reject-errors\":\n        \"@typescript-eslint/prefer-promise-reject-errors\",\n      \"require-await\": \"@typescript-eslint/require-await\",\n      \"no-return-await\": \"@typescript-eslint/return-await\", // no-return-await has been deprecated\n    } as const;\n\n    type Js2TsRuleMap = typeof extensionRuleMap;\n    type Ts2JsRuleMap = {\n      [K in keyof Js2TsRuleMap as Js2TsRuleMap[K]]: K; // reverse\n    };\n\n    type JsExtensionKey = Extract<\n      keyof Js2TsRuleMap,\n      keyof typeof jsBase.rules\n    >; // Extract\n    type TsExtensionKey = Js2TsRuleMap[JsExtensionKey];\n\n    type JsResult = Record<JsExtensionKey, \"off\">;\n    type TsResult = {\n      [Key in TsExtensionKey]: (typeof jsBase.rules)[Ts2JsRuleMap[Key]];\n    };\n    type Result = JsResult & TsResult;\n\n    const isInExtensionRuleMap = (\n      key: string,\n    ): key is keyof typeof extensionRuleMap => key in extensionRuleMap;\n    return Object.entries(jsBase.rules).reduce(\n      (result, [jsRuleKey, jsRuleValue]) =>\n        isInExtensionRuleMap(jsRuleKey)\n          ? {\n              ...result,\n              [jsRuleKey]: \"off\",\n              [extensionRuleMap[jsRuleKey]]: jsRuleValue,\n            }\n          : result,\n      {} as Result,\n    );\n  };\n\n  return {\n    ...jsBase,\n    name: \"fenge/typescript\",\n    files: [\"**/*.{ts,cts,mts,tsx}\"],\n    languageOptions: {\n      ...jsBase.languageOptions,\n      parserOptions: {\n        ...jsBase.languageOptions.parserOptions,\n        // Setting `projectService: true` or `project: true` is pretty slow when lint a monorepo with many tsconfig.json files in each sub-app.\n        // But setting `project: \"tsconfig.json\"` will cause parser error when the project root tsconfig.json is `{ extends: \"fenge/tsconfig\" }`\n        projectService: true,\n      },\n      globals: {\n        ...jsBase.languageOptions.globals,\n        NodeJS: false,\n      },\n    },\n    plugins: {\n      ...jsBase.plugins,\n      \"@fenge-ts\": fengeTsPlugin,\n    },\n    rules: {\n      ...jsBase.rules,\n      ...getTsExtensionRules(),\n\n      // fenge\n      \"@fenge-ts/exact-map-set-type\": \"error\",\n      \"@fenge-ts/no-const-enum\": \"error\",\n      \"@fenge-ts/no-declares\": \"error\",\n      \"@fenge-ts/no-export-assignment\": \"error\",\n      \"@fenge-ts/no-misuse-spreading-parameter\": \"error\",\n      \"@fenge-ts/no-property-decorator\": \"error\",\n      \"@fenge-ts/no-untyped-empty-array\": \"error\",\n      // typescript\n      \"@typescript-eslint/adjacent-overload-signatures\": \"error\",\n      // \"@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.\n      \"@typescript-eslint/await-thenable\": \"error\",\n      \"@typescript-eslint/class-literal-property-style\": \"error\",\n      \"@typescript-eslint/consistent-generic-constructors\": \"error\",\n      \"@typescript-eslint/consistent-indexed-object-style\": \"error\",\n      \"@typescript-eslint/consistent-type-assertions\": [\n        \"error\",\n        {\n          assertionStyle: \"as\",\n          objectLiteralTypeAssertions: \"allow-as-parameter\",\n        },\n      ],\n      \"@typescript-eslint/consistent-type-definitions\": [\"error\", \"interface\"], // TODO should we change to 'type'?\n      \"@typescript-eslint/consistent-type-exports\": \"error\",\n      \"@typescript-eslint/consistent-type-imports\": \"error\",\n      \"@typescript-eslint/dot-notation\": [\"error\", { allowKeywords: true }],\n      \"@typescript-eslint/method-signature-style\": \"error\",\n      \"@typescript-eslint/naming-convention\": [\n        \"error\",\n        {\n          selector: \"function\",\n          format: [\"camelCase\", \"PascalCase\"],\n        },\n        {\n          selector: \"variable\",\n          types: [\"function\"],\n          format: [\"camelCase\", \"PascalCase\"], // decorators need PascalCase\n        },\n        {\n          selector: \"class\",\n          format: [\"PascalCase\"],\n        },\n        {\n          selector: \"interface\",\n          format: [\"PascalCase\"],\n        },\n        {\n          selector: \"typeAlias\",\n          format: [\"PascalCase\"],\n        },\n        {\n          selector: \"typeParameter\",\n          format: [\"UPPER_CASE\", \"PascalCase\"],\n        },\n      ],\n      \"@typescript-eslint/no-array-delete\": \"error\",\n      \"@typescript-eslint/no-base-to-string\": [\n        \"error\",\n        { ignoredTypeNames: [] },\n      ],\n      \"@typescript-eslint/no-confusing-non-null-assertion\": \"error\",\n      \"@typescript-eslint/no-confusing-void-expression\": [\n        \"error\",\n        { ignoreArrowShorthand: true },\n      ],\n      \"@typescript-eslint/no-deprecated\": \"error\",\n      \"@typescript-eslint/no-duplicate-enum-values\": \"error\",\n      \"@typescript-eslint/no-duplicate-type-constituents\": \"error\",\n      \"@typescript-eslint/no-empty-object-type\": \"error\",\n      // \"@typescript-eslint/no-explicit-any\": \"warn\",\n      \"@typescript-eslint/no-extra-non-null-assertion\": \"error\",\n      // \"@typescript-eslint/no-extraneous-class\": \"error\", // Classes have only static member is reasonable sometimes. Nestjs modules use it a lot.\n      \"@typescript-eslint/no-floating-promises\": [\n        \"error\",\n        {\n          ignoreVoid: false,\n        },\n      ],\n      \"@typescript-eslint/no-for-in-array\": \"error\",\n      \"@typescript-eslint/no-import-type-side-effects\": \"error\",\n      \"@typescript-eslint/no-inferrable-types\": \"error\",\n      \"@typescript-eslint/no-invalid-void-type\": \"error\",\n      \"@typescript-eslint/no-misused-new\": \"error\",\n      \"@typescript-eslint/no-misused-promises\": \"error\",\n      \"@typescript-eslint/no-misused-spread\": \"error\",\n      \"@typescript-eslint/no-mixed-enums\": \"error\",\n      \"@typescript-eslint/no-namespace\": [\n        \"error\",\n        { allowDefinitionFiles: false },\n      ],\n      \"@typescript-eslint/no-non-null-asserted-nullish-coalescing\": \"error\",\n      \"@typescript-eslint/no-non-null-asserted-optional-chain\": \"error\",\n      \"@typescript-eslint/no-non-null-assertion\": \"error\",\n      \"@typescript-eslint/no-redundant-type-constituents\": \"error\",\n      \"@typescript-eslint/no-require-imports\": \"error\",\n      \"@typescript-eslint/no-unnecessary-boolean-literal-compare\": \"error\",\n      \"@typescript-eslint/no-unnecessary-condition\": [\n        \"error\",\n        // TODO: If https://github.com/typescript-eslint/typescript-eslint/issues/11978 is fixed, change to `allowConstantLoopConditions: \"only-allowed-literals\"`.\n        { allowConstantLoopConditions: \"always\" },\n      ],\n      \"@typescript-eslint/no-unnecessary-parameter-property-assignment\":\n        \"error\",\n      \"@typescript-eslint/no-unnecessary-template-expression\": \"error\", // js also need this rule\n      \"@typescript-eslint/no-unnecessary-type-arguments\": \"error\",\n      \"@typescript-eslint/no-unnecessary-type-assertion\": \"error\",\n      \"@typescript-eslint/no-unnecessary-type-constraint\": \"error\",\n      \"@typescript-eslint/no-unnecessary-type-conversion\": \"error\",\n      \"@typescript-eslint/no-unsafe-call\": \"error\",\n      \"@typescript-eslint/no-unsafe-declaration-merging\": \"error\",\n      \"@typescript-eslint/no-unsafe-enum-comparison\": \"error\",\n      \"@typescript-eslint/no-unsafe-function-type\": \"error\",\n      \"@typescript-eslint/no-unsafe-return\": \"error\", // This rule is not very perfect. See https://github.com/typescript-eslint/typescript-eslint/issues/10439\n      \"@typescript-eslint/no-unsafe-unary-minus\": \"error\",\n      \"@typescript-eslint/no-useless-default-assignment\": \"error\",\n      \"@typescript-eslint/no-wrapper-object-types\": \"error\",\n      \"@typescript-eslint/non-nullable-type-assertion-style\": \"error\",\n      \"@typescript-eslint/only-throw-error\": [\n        \"error\",\n        { allowThrowingUnknown: false },\n      ],\n      \"@typescript-eslint/prefer-as-const\": \"error\",\n      \"@typescript-eslint/prefer-function-type\": \"error\",\n      \"@typescript-eslint/prefer-includes\": \"error\",\n      \"@typescript-eslint/prefer-literal-enum-member\": \"error\",\n      \"@typescript-eslint/prefer-namespace-keyword\": \"error\",\n      \"@typescript-eslint/prefer-nullish-coalescing\": \"error\",\n      \"@typescript-eslint/prefer-optional-chain\": \"error\",\n      \"@typescript-eslint/prefer-readonly\": \"error\",\n      \"@typescript-eslint/prefer-regexp-exec\": \"error\",\n      \"@typescript-eslint/prefer-return-this-type\": \"error\",\n      \"@typescript-eslint/promise-function-async\": \"error\",\n      \"@typescript-eslint/restrict-plus-operands\": [\n        \"error\",\n        {\n          // allowAny: false,\n          allowBoolean: false,\n          allowNullish: false,\n          allowNumberAndString: false,\n          allowRegExp: false,\n          skipCompoundAssignments: false,\n        },\n      ],\n      \"@typescript-eslint/restrict-template-expressions\": [\n        \"error\",\n        {\n          allow: [],\n          // allowAny: false,\n          allowBoolean: false,\n          allowNever: false,\n          allowNullish: false,\n          // allowNumber: false,\n          allowRegExp: false,\n        },\n      ],\n      \"@typescript-eslint/related-getter-setter-pairs\": \"error\",\n      \"@typescript-eslint/return-await\": [\"error\", \"always\"],\n      \"@typescript-eslint/switch-exhaustiveness-check\": [\n        \"error\",\n        { requireDefaultForNonUnion: true },\n      ],\n      \"@typescript-eslint/unbound-method\": \"error\",\n      \"@typescript-eslint/unified-signatures\": \"error\",\n      \"@typescript-eslint/use-unknown-in-catch-callback-variable\": \"error\",\n    },\n  } as const;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../src/config/ts/base.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fengeTsPlugin from \"@fenge/eslint-plugin-ts\";\nimport { getJsBase } from \"../js/base.ts\";\n\nexport function getTsBase() {\n  const jsBase = getJsBase();\n\n  const getTsExtensionRules = () => {\n    // Key is js rule, value is ts rule\n    // https://typescript-eslint.io/rules/?=extension\n    // Some rules are implemented by eslint core, so we comment them out.\n    const extensionRuleMap = {\n      // \"class-methods-use-this\": \"@typescript-eslint/class-methods-use-this\", // 9.23.0\n      \"consistent-return\": \"@typescript-eslint/consistent-return\",\n      // \"default-param-last\": \"@typescript-eslint/default-param-last\", // 9.23.0\n      \"dot-notation\": \"@typescript-eslint/dot-notation\",\n      // \"init-declarations\": \"@typescript-eslint/init-declarations\", // 9.24.0\n      // \"max-params\": \"@typescript-eslint/max-params\", // 9.27.0\n      // \"no-array-constructor\": \"@typescript-eslint/no-array-constructor\", // 9.24.0\n      // \"no-dupe-class-members\": \"@typescript-eslint/no-dupe-class-members\", // 9.24.0\n      // \"no-empty-function\": \"@typescript-eslint/no-empty-function\", // 9.25.0\n      \"no-implied-eval\": \"@typescript-eslint/no-implied-eval\",\n      // \"no-invalid-this\": \"@typescript-eslint/no-invalid-this\", // 9.25.0\n      // \"no-loop-func\": \"@typescript-eslint/no-loop-func\", // 9.25.0\n      // \"no-loss-of-precision\": \"@typescript-eslint/no-loss-of-precision\", // 9.24.0. And this rule has been deprecated\n      // \"no-magic-numbers\": \"@typescript-eslint/no-magic-numbers\", // 9.28.0\n      \"no-redeclare\": \"@typescript-eslint/no-redeclare\",\n      \"no-restricted-imports\": \"@typescript-eslint/no-restricted-imports\",\n      // \"no-shadow\": \"@typescript-eslint/no-shadow\", // 9.28.0\n      // \"no-unused-expressions\": \"@typescript-eslint/no-unused-expressions\", // 9.25.0\n      \"no-unused-vars\": \"@typescript-eslint/no-unused-vars\",\n      // \"no-use-before-define\": \"@typescript-eslint/no-use-before-define\", // 9.28.0\n      // \"no-useless-constructor\": \"@typescript-eslint/no-useless-constructor\", // 9.23.0\n      \"no-throw-literal\": \"@typescript-eslint/only-throw-error\",\n      \"prefer-destructuring\": \"@typescript-eslint/prefer-destructuring\",\n      \"prefer-promise-reject-errors\":\n        \"@typescript-eslint/prefer-promise-reject-errors\",\n      \"require-await\": \"@typescript-eslint/require-await\",\n      \"no-return-await\": \"@typescript-eslint/return-await\", // no-return-await has been deprecated\n    } as const;\n\n    type Js2TsRuleMap = typeof extensionRuleMap;\n    type Ts2JsRuleMap = {\n      [K in keyof Js2TsRuleMap as Js2TsRuleMap[K]]: K; // reverse\n    };\n\n    type JsExtensionKey = Extract<\n      keyof Js2TsRuleMap,\n      keyof typeof jsBase.rules\n    >; // Extract\n    type TsExtensionKey = Js2TsRuleMap[JsExtensionKey];\n\n    type JsResult = Record<JsExtensionKey, \"off\">;\n    type TsResult = {\n      [Key in TsExtensionKey]: (typeof jsBase.rules)[Ts2JsRuleMap[Key]];\n    };\n    type Result = JsResult & TsResult;\n\n    const isInExtensionRuleMap = (\n      key: string,\n    ): key is keyof typeof extensionRuleMap => key in extensionRuleMap;\n    return Object.entries(jsBase.rules).reduce(\n      (result, [jsRuleKey, jsRuleValue]) =>\n        isInExtensionRuleMap(jsRuleKey)\n          ? {\n              ...result,\n              [jsRuleKey]: \"off\",\n              [extensionRuleMap[jsRuleKey]]: jsRuleValue,\n            }\n          : result,\n      {} as Result,\n    );\n  };\n\n  return {\n    ...jsBase,\n    name: \"fenge/typescript\",\n    files: [\"**/*.{ts,cts,mts,tsx}\"],\n    languageOptions: {\n      ...jsBase.languageOptions,\n      parserOptions: {\n        ...jsBase.languageOptions.parserOptions,\n        // Setting `projectService: true` or `project: true` is pretty slow when lint a monorepo with many tsconfig.json files in each sub-app.\n        // But setting `project: \"tsconfig.json\"` will cause parser error when the project root tsconfig.json is `{ extends: \"fenge/tsconfig\" }`\n        projectService: true,\n      },\n      globals: {\n        ...jsBase.languageOptions.globals,\n        NodeJS: false,\n      },\n    },\n    plugins: {\n      ...jsBase.plugins,\n      \"@fenge-ts\": fengeTsPlugin,\n    },\n    rules: {\n      ...jsBase.rules,\n      ...getTsExtensionRules(),\n\n      // fenge\n      \"@fenge-ts/exact-map-set-type\": \"error\",\n      \"@fenge-ts/no-const-enum\": \"error\",\n      \"@fenge-ts/no-declares\": \"error\",\n      \"@fenge-ts/no-export-assignment\": \"error\",\n      \"@fenge-ts/no-misuse-spreading-parameter\": \"error\",\n      \"@fenge-ts/no-property-decorator\": \"error\",\n      \"@fenge-ts/no-untyped-empty-array\": \"error\",\n      // typescript\n      \"@typescript-eslint/adjacent-overload-signatures\": \"error\",\n      // \"@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.\n      \"@typescript-eslint/await-thenable\": \"error\",\n      \"@typescript-eslint/class-literal-property-style\": \"error\",\n      \"@typescript-eslint/consistent-generic-constructors\": \"error\",\n      \"@typescript-eslint/consistent-indexed-object-style\": \"error\",\n      \"@typescript-eslint/consistent-type-assertions\": [\n        \"error\",\n        {\n          assertionStyle: \"as\",\n          objectLiteralTypeAssertions: \"allow-as-parameter\",\n        },\n      ],\n      \"@typescript-eslint/consistent-type-definitions\": [\"error\", \"interface\"], // TODO should we change to 'type'?\n      \"@typescript-eslint/consistent-type-exports\": \"error\",\n      \"@typescript-eslint/consistent-type-imports\": \"error\",\n      \"@typescript-eslint/dot-notation\": [\"error\", { allowKeywords: true }],\n      \"@typescript-eslint/method-signature-style\": \"error\",\n      \"@typescript-eslint/naming-convention\": [\n        \"error\",\n        {\n          selector: \"function\",\n          format: [\"camelCase\", \"PascalCase\"],\n        },\n        {\n          selector: \"variable\",\n          types: [\"function\"],\n          format: [\"camelCase\", \"PascalCase\"], // decorators need PascalCase\n        },\n        {\n          selector: \"class\",\n          format: [\"PascalCase\"],\n        },\n        {\n          selector: \"interface\",\n          format: [\"PascalCase\"],\n        },\n        {\n          selector: \"typeAlias\",\n          format: [\"PascalCase\"],\n        },\n        {\n          selector: \"typeParameter\",\n          format: [\"UPPER_CASE\", \"PascalCase\"],\n        },\n      ],\n      \"@typescript-eslint/no-array-delete\": \"error\",\n      \"@typescript-eslint/no-base-to-string\": [\n        \"error\",\n        { ignoredTypeNames: [] },\n      ],\n      \"@typescript-eslint/no-confusing-non-null-assertion\": \"error\",\n      \"@typescript-eslint/no-confusing-void-expression\": [\n        \"error\",\n        { ignoreArrowShorthand: true },\n      ],\n      \"@typescript-eslint/no-deprecated\": \"error\",\n      \"@typescript-eslint/no-duplicate-enum-values\": \"error\",\n      \"@typescript-eslint/no-duplicate-type-constituents\": \"error\",\n      \"@typescript-eslint/no-empty-object-type\": \"error\",\n      // \"@typescript-eslint/no-explicit-any\": \"warn\",\n      \"@typescript-eslint/no-extra-non-null-assertion\": \"error\",\n      // \"@typescript-eslint/no-extraneous-class\": \"error\", // Classes have only static member is reasonable sometimes. Nestjs modules use it a lot.\n      \"@typescript-eslint/no-floating-promises\": [\n        \"error\",\n        {\n          ignoreVoid: false,\n        },\n      ],\n      \"@typescript-eslint/no-for-in-array\": \"error\",\n      \"@typescript-eslint/no-import-type-side-effects\": \"error\",\n      \"@typescript-eslint/no-inferrable-types\": \"error\",\n      \"@typescript-eslint/no-invalid-void-type\": \"error\",\n      \"@typescript-eslint/no-misused-new\": \"error\",\n      \"@typescript-eslint/no-misused-promises\": \"error\",\n      \"@typescript-eslint/no-misused-spread\": \"error\",\n      \"@typescript-eslint/no-mixed-enums\": \"error\",\n      \"@typescript-eslint/no-namespace\": [\n        \"error\",\n        { allowDefinitionFiles: false },\n      ],\n      \"@typescript-eslint/no-non-null-asserted-nullish-coalescing\": \"error\",\n      \"@typescript-eslint/no-non-null-asserted-optional-chain\": \"error\",\n      \"@typescript-eslint/no-non-null-assertion\": \"error\",\n      \"@typescript-eslint/no-redundant-type-constituents\": \"error\",\n      \"@typescript-eslint/no-require-imports\": \"error\",\n      \"@typescript-eslint/no-unnecessary-boolean-literal-compare\": \"error\",\n      \"@typescript-eslint/no-unnecessary-condition\": [\n        \"error\",\n        // TODO: If https://github.com/typescript-eslint/typescript-eslint/issues/11978 is fixed, change to `allowConstantLoopConditions: \"only-allowed-literals\"`.\n        { allowConstantLoopConditions: \"always\" },\n      ],\n      \"@typescript-eslint/no-unnecessary-parameter-property-assignment\":\n        \"error\",\n      \"@typescript-eslint/no-unnecessary-template-expression\": \"error\", // js also need this rule\n      \"@typescript-eslint/no-unnecessary-type-arguments\": \"error\",\n      \"@typescript-eslint/no-unnecessary-type-assertion\": \"error\",\n      \"@typescript-eslint/no-unnecessary-type-constraint\": \"error\",\n      \"@typescript-eslint/no-unnecessary-type-conversion\": \"error\",\n      \"@typescript-eslint/no-unsafe-call\": \"error\",\n      \"@typescript-eslint/no-unsafe-declaration-merging\": \"error\",\n      \"@typescript-eslint/no-unsafe-enum-comparison\": \"error\",\n      \"@typescript-eslint/no-unsafe-function-type\": \"error\",\n      \"@typescript-eslint/no-unsafe-return\": \"error\", // This rule is not very perfect. See https://github.com/typescript-eslint/typescript-eslint/issues/10439\n      \"@typescript-eslint/no-unsafe-unary-minus\": \"error\",\n      \"@typescript-eslint/no-useless-default-assignment\": \"error\",\n      \"@typescript-eslint/no-wrapper-object-types\": \"error\",\n      \"@typescript-eslint/non-nullable-type-assertion-style\": \"error\",\n      \"@typescript-eslint/only-throw-error\": [\n        \"error\",\n        { allowThrowingUnknown: false },\n      ],\n      \"@typescript-eslint/prefer-as-const\": \"error\",\n      \"@typescript-eslint/prefer-function-type\": \"error\",\n      \"@typescript-eslint/prefer-includes\": \"error\",\n      \"@typescript-eslint/prefer-literal-enum-member\": \"error\",\n      \"@typescript-eslint/prefer-namespace-keyword\": \"error\",\n      \"@typescript-eslint/prefer-nullish-coalescing\": \"error\",\n      \"@typescript-eslint/prefer-optional-chain\": \"error\",\n      \"@typescript-eslint/prefer-readonly\": \"error\",\n      \"@typescript-eslint/prefer-regexp-exec\": \"error\",\n      \"@typescript-eslint/prefer-return-this-type\": \"error\",\n      \"@typescript-eslint/promise-function-async\": \"error\",\n      \"@typescript-eslint/restrict-plus-operands\": [\n        \"error\",\n        {\n          // allowAny: false,\n          allowBoolean: false,\n          allowNullish: false,\n          allowNumberAndString: false,\n          allowRegExp: false,\n          skipCompoundAssignments: false,\n        },\n      ],\n      \"@typescript-eslint/restrict-template-expressions\": [\n        \"error\",\n        {\n          allow: [],\n          // allowAny: false,\n          allowBoolean: false,\n          allowNever: false,\n          allowNullish: false,\n          // allowNumber: false,\n          allowRegExp: false,\n        },\n      ],\n      \"@typescript-eslint/related-getter-setter-pairs\": \"error\",\n      \"@typescript-eslint/return-await\": [\"error\", \"always\"],\n      \"@typescript-eslint/switch-exhaustiveness-check\": [\n        \"error\",\n        { requireDefaultForNonUnion: true },\n      ],\n      \"@typescript-eslint/unbound-method\": \"error\",\n      \"@typescript-eslint/unified-signatures\": \"error\",\n      \"@typescript-eslint/use-unknown-in-catch-callback-variable\": \"error\",\n    },\n  } as const;\n}\n"]}