@fenge/eslint-config 0.6.2 → 0.6.3

package/src/config/ts/base.ts

@@ -1,238 +0,0 @@
-import * as fengeTsPlugin from "@fenge/eslint-plugin-ts";
-import tsParser from "@typescript-eslint/parser";
-import { getJsBase } from "../js/base.ts";
-
-export function getTsBase() {
-  const jsBase = getJsBase();
-
-  const getTsExtensionRules = () => {
-    // Key is js rule, value is ts rule
-    // https://typescript-eslint.io/rules/?=extension
-    const extensionRuleMap = {
-      "class-methods-use-this": "@typescript-eslint/class-methods-use-this",
-      "consistent-return": "@typescript-eslint/consistent-return",
-      "default-param-last": "@typescript-eslint/default-param-last",
-      "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",
-      "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-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-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-throw-literal": "@typescript-eslint/only-throw-error",
-      "prefer-destructuring": "@typescript-eslint/prefer-destructuring",
-      "prefer-promise-reject-errors":
-        "@typescript-eslint/prefer-promise-reject-errors",
-      "require-await": "@typescript-eslint/require-await",
-      "no-return-await": "@typescript-eslint/return-await", // no-return-await has been deprecated
-    } as const;
-
-    type Js2TsRuleMap = typeof extensionRuleMap;
-    type Ts2JsRuleMap = {
-      [K in keyof Js2TsRuleMap as Js2TsRuleMap[K]]: K; // reverse
-    };
-
-    type JsExtensionKey = Extract<
-      keyof Js2TsRuleMap,
-      keyof typeof jsBase.rules
-    >; // Extract
-    type TsExtensionKey = Js2TsRuleMap[JsExtensionKey];
-
-    type JsResult = Record<JsExtensionKey, "off">;
-    type TsResult = {
-      [Key in TsExtensionKey]: (typeof jsBase.rules)[Ts2JsRuleMap[Key]];
-    };
-    type Result = JsResult & TsResult;
-
-    const isInExtensionRuleMap = (
-      key: string,
-    ): key is keyof typeof extensionRuleMap => key in extensionRuleMap;
-    return Object.entries(jsBase.rules).reduce(
-      (result, [jsRuleKey, jsRuleValue]) =>
-        isInExtensionRuleMap(jsRuleKey)
-          ? {
-              ...result,
-              [jsRuleKey]: "off",
-              [extensionRuleMap[jsRuleKey]]: jsRuleValue,
-            }
-          : result,
-      {} as Result,
-    );
-  };
-
-  return {
-    ...jsBase,
-    name: "fenge/typescript",
-    files: ["**/*.{ts,cts,mts,tsx}"],
-    languageOptions: {
-      ...jsBase.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: {
-        ...jsBase.languageOptions.parserOptions,
-        // Setting `projectService: true` or `project: true` is pretty slow when lint a monorepo with many tsconfig.json files in each sub-app.
-        // But setting `project: "tsconfig.json"` will cause parser error when the project root tsconfig.json is `{ extends: "fenge/tsconfig" }`
-        projectService: true,
-      },
-    },
-    plugins: {
-      ...jsBase.plugins,
-      "@fenge-ts": fengeTsPlugin,
-    },
-    rules: {
-      ...jsBase.rules,
-      ...getTsExtensionRules(),
-
-      // fenge
-      "@fenge-ts/exact-map-set-type": "error",
-      "@fenge-ts/no-const-enum": "error",
-      "@fenge-ts/no-declares": "error",
-      "@fenge-ts/no-export-assignment": "error",
-      "@fenge-ts/no-misuse-spreading-parameter": "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/class-literal-property-style": "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-deprecated": "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-extraneous-class": "error", // Classes have only static member is reasonable sometimes. Nestjs modules use it a lot.
-      "@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-invalid-void-type": "error",
-      "@typescript-eslint/no-misused-new": "error",
-      "@typescript-eslint/no-misused-promises": "error",
-      "@typescript-eslint/no-misused-spread": "error",
-      "@typescript-eslint/no-mixed-enums": "error",
-      "@typescript-eslint/no-namespace": "error", // consider to add option `{"allowDefinitionFiles": false}` to strictly forbid `namespace` keyword
-      "@typescript-eslint/no-non-null-asserted-nullish-coalescing": "error",
-      "@typescript-eslint/no-non-null-asserted-optional-chain": "error",
-      "@typescript-eslint/no-non-null-assertion": "error",
-      "@typescript-eslint/no-redundant-type-constituents": "error",
-      "@typescript-eslint/no-require-imports": "error",
-      "@typescript-eslint/no-unnecessary-boolean-literal-compare": "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-arguments": "error",
-      "@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-enum-comparison": "error",
-      "@typescript-eslint/no-unsafe-function-type": "error",
-      "@typescript-eslint/no-unsafe-return": "error", // This rule is not very perfect. See https://github.com/typescript-eslint/typescript-eslint/issues/10439
-      "@typescript-eslint/no-unsafe-unary-minus": "error",
-      "@typescript-eslint/no-wrapper-object-types": "error",
-      "@typescript-eslint/non-nullable-type-assertion-style": "error",
-      "@typescript-eslint/prefer-as-const": "error",
-      "@typescript-eslint/prefer-function-type": "error",
-      "@typescript-eslint/prefer-literal-enum-member": "error",
-      "@typescript-eslint/prefer-namespace-keyword": "error",
-      "@typescript-eslint/prefer-optional-chain": "error",
-      "@typescript-eslint/prefer-readonly": "error",
-      "@typescript-eslint/prefer-return-this-type": "error",
-      "@typescript-eslint/restrict-plus-operands": [
-        "error",
-        {
-          // allowAny: false,
-          allowBoolean: false,
-          allowNullish: false,
-          allowNumberAndString: false,
-          allowRegExp: false,
-          skipCompoundAssignments: false,
-        },
-      ],
-      "@typescript-eslint/restrict-template-expressions": [
-        "error",
-        {
-          allow: [],
-          // allowAny: false,
-          allowBoolean: false,
-          allowNever: false,
-          allowNullish: false,
-          allowNumber: false,
-          allowRegExp: false,
-        },
-      ],
-      "@typescript-eslint/related-getter-setter-pairs": "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",
-    },
-  } as const;
-}

package/src/config/ts/cli.ts

@@ -1,13 +0,0 @@
-import { getJsCli } from "../js/cli.ts";
-
-export function getTsCli() {
-  const jsCli = getJsCli();
-  return {
-    ...jsCli,
-    name: "fenge/typescript/cli",
-    files: ["**/*.cli.{ts,cts,mts,tsx}"],
-    rules: {
-      ...jsCli.rules,
-    },
-  } as const;
-}

package/src/config/ts/config.ts

@@ -1,13 +0,0 @@
-import { getJsConfig } from "../js/config.ts";
-
-export function getTsConfig() {
-  const jsConfig = getJsConfig();
-  return {
-    ...jsConfig,
-    name: "fenge/typescript/config",
-    files: ["**/*.config.{ts,cts,mts,tsx}"],
-    rules: {
-      ...jsConfig.rules,
-    },
-  } as const;
-}

package/src/config/ts/declaration.ts

@@ -1,13 +0,0 @@
-export function getTsDeclaration() {
-  return {
-    name: "fenge/typescript/declaration",
-    files: ["**/*.d.{ts,cts,mts,tsx}"],
-    rules: {
-      "esm/no-declaration-file-imports": "off",
-      "esm/no-empty-exports": "off",
-      "esm/no-side-effect-imports": "off",
-      "esm/required-exports": "off",
-      "import/no-default-export": "off",
-    },
-  } as const;
-}

package/src/config/ts/test.ts

@@ -1,18 +0,0 @@
-import { getJsTest } from "../js/test.ts";
-
-export function getTsTest() {
-  const jsTest = getJsTest();
-  return {
-    ...jsTest,
-    name: "fenge/typescript/test",
-    files: [
-      "**/__tests__/**/*.{ts,cts,mts,tsx}",
-      "**/*.{test,spec}.{ts,cts,mts,tsx}",
-    ],
-    rules: {
-      ...jsTest.rules,
-      "@typescript-eslint/no-floating-promises": "off",
-      "@typescript-eslint/unbound-method": "off",
-    },
-  } as const;
-}

package/src/config/typescript.test.ts

@@ -1,98 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import { typescript } from "./typescript.ts";
-
-await describe("ts config", async () => {
-  await it("ts main config rules values should be error", () => {
-    Object.entries(typescript()[0].rules).forEach(([key, value]) => {
-      // Key is js rule, value is ts rule
-      // https://typescript-eslint.io/rules/?=extension
-      const extensionRuleMap = {
-        "class-methods-use-this": "@typescript-eslint/class-methods-use-this",
-        "consistent-return": "@typescript-eslint/consistent-return",
-        "default-param-last": "@typescript-eslint/default-param-last",
-        "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",
-        "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-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-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-throw-literal": "@typescript-eslint/only-throw-error",
-        "prefer-destructuring": "@typescript-eslint/prefer-destructuring",
-        "prefer-promise-reject-errors":
-          "@typescript-eslint/prefer-promise-reject-errors",
-        "require-await": "@typescript-eslint/require-await",
-        "no-return-await": "@typescript-eslint/return-await", // no-return-await has been deprecated
-      } as const;
-      if (key in extensionRuleMap) {
-        assert.strictEqual(getValueString(value), "off");
-      } else {
-        assert.strictEqual(getValueString(value), "error");
-      }
-    });
-  });
-
-  await it("ts rest configs rules should exist in main rules", () => {
-    const [main, ...restConfigs] = typescript();
-    restConfigs.forEach((restConfig) => {
-      Object.entries(restConfig.rules).forEach(([key, value]) => {
-        assert.strictEqual(key in main.rules, true);
-        assert.notDeepStrictEqual(value, Reflect.get(main.rules, key));
-      });
-    });
-  });
-
-  await it("properties in ts main config should be valid", () => {
-    const tsMainConfig = typescript()[0];
-    assert.deepStrictEqual(Object.keys(tsMainConfig), [
-      "name",
-      "files",
-      "languageOptions",
-      "plugins",
-      "rules",
-    ]);
-    assert.strictEqual(tsMainConfig.name.endsWith("/typescript"), true);
-    assert.strictEqual(
-      tsMainConfig.files.every((file) => file.endsWith(".{ts,cts,mts,tsx}")),
-      true,
-    );
-  });
-
-  await it("properties in ts rest configs should be valid", () => {
-    const [, ...restConfigs] = typescript();
-    for (const restConfig of restConfigs) {
-      assert.deepStrictEqual(Object.keys(restConfig), [
-        "name",
-        "files",
-        "rules",
-      ]);
-      assert.strictEqual(restConfig.name.includes("/typescript/"), true);
-      assert.strictEqual(
-        restConfig.files.every((file) => file.endsWith(".{ts,cts,mts,tsx}")),
-        true,
-      );
-    }
-  });
-});
-
-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/config/typescript.ts

@@ -1,15 +0,0 @@
-import { getTsBase } from "./ts/base.ts";
-import { getTsCli } from "./ts/cli.ts";
-import { getTsConfig } from "./ts/config.ts";
-import { getTsDeclaration } from "./ts/declaration.ts";
-import { getTsTest } from "./ts/test.ts";
-
-export function typescript() {
-  return [
-    getTsBase(),
-    getTsCli(),
-    getTsConfig(),
-    getTsTest(),
-    getTsDeclaration(),
-  ] as const;
-}

package/src/eslint.config.test.ts

@@ -1,108 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import config from "./eslint.config.ts";
-
-await describe("eslint.config", async () => {
-  await it("length of default export should be 13", () => {
-    assert.strictEqual(config.length, 13);
-  });
-
-  await it("no warns", () => {
-    config.forEach((configItem) => {
-      if (configItem.rules) {
-        Object.values(configItem.rules).forEach((value) => {
-          assert.notStrictEqual(getValueString(value), "warn");
-        });
-      }
-    });
-  });
-
-  await it("should not contain deprecated rules", () => {
-    // https://eslint.org/blog/2023/10/deprecating-formatting-rules/#the-deprecated-rules
-    const deprecatedRules = [
-      "array-bracket-newline",
-      "array-bracket-spacing",
-      "array-element-newline",
-      "arrow-parens",
-      "arrow-spacing",
-      "block-spacing",
-      "brace-style",
-      "comma-dangle",
-      "comma-spacing",
-      "comma-style",
-      "computed-property-spacing",
-      "dot-location",
-      "eol-last",
-      "func-call-spacing",
-      "function-call-argument-newline",
-      "function-paren-newline",
-      "generator-star-spacing",
-      "implicit-arrow-linebreak",
-      "indent",
-      "jsx-quotes",
-      "key-spacing",
-      "keyword-spacing",
-      "linebreak-style",
-      "lines-between-class-members",
-      "lines-around-comment",
-      "max-len",
-      "max-statements-per-line",
-      "multiline-ternary",
-      "new-parens",
-      "newline-per-chained-call",
-      "no-confusing-arrow",
-      "no-extra-parens",
-      "no-extra-semi",
-      "no-floating-decimal",
-      "no-mixed-operators",
-      "no-mixed-spaces-and-tabs",
-      "no-multi-spaces",
-      "no-multiple-empty-lines",
-      "no-tabs",
-      "no-trailing-spaces",
-      "no-whitespace-before-property",
-      "nonblock-statement-body-position",
-      "object-curly-newline",
-      "object-curly-spacing",
-      "object-property-newline",
-      "one-var-declaration-per-line",
-      "operator-linebreak",
-      "padded-blocks",
-      "padding-line-between-statements",
-      "quote-props",
-      "quotes",
-      "rest-spread-spacing",
-      "semi",
-      "semi-spacing",
-      "semi-style",
-      "space-before-blocks",
-      "space-before-function-paren",
-      "space-in-parens",
-      "space-infix-ops",
-      "space-unary-ops",
-      "spaced-comment",
-      "switch-colon-spacing",
-      "template-curly-spacing",
-      "template-tag-spacing",
-      "wrap-iife",
-      "wrap-regex",
-      "yield-star-spacing",
-    ];
-    for (const configItem of config) {
-      const containingDeprecatedRules = Object.keys(
-        configItem.rules ?? {},
-      ).filter((rule) => deprecatedRules.includes(rule));
-      assert.deepStrictEqual(containingDeprecatedRules, []);
-    }
-  });
-});
-
-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

@@ -1,99 +0,0 @@
-import type { Linter } from "eslint";
-import { base, type BaseOptions } from "./config/base.ts";
-import { javascript } from "./config/javascript.ts";
-import { packagejson } from "./config/packagejson.ts";
-import { typescript } from "./config/typescript.ts";
-
-type NoDuplicate<A extends unknown[]> = {
-  [I in keyof A]: true extends {
-    [J in keyof A]: J extends I ? false : A[J] extends A[I] ? true : false;
-  }[number]
-    ? never
-    : A[I];
-};
-
-type JsRuleKey = keyof ReturnType<typeof javascript>[0]["rules"];
-type TsRuleKey = keyof ReturnType<typeof typescript>[0]["rules"];
-type PkgRuleKey = keyof ReturnType<typeof packagejson>[0]["rules"];
-
-type RuleValue = "error" | "warn" | "off" | ["error" | "warn", ...unknown[]];
-interface Options<T extends string[]> {
-  pick?: NoDuplicate<T>;
-  omit?: NoDuplicate<T>;
-}
-interface ConfigItem {
-  name: string;
-  files: string[];
-  plugins?: Record<string, object>;
-  rules:
-    | Partial<Record<PkgRuleKey | JsRuleKey | TsRuleKey, RuleValue>>
-    | Record<string, RuleValue>;
-}
-
-export type BuilderOptions = BaseOptions;
-export class Builder {
-  private readonly configs: Linter.Config[] = [];
-  private readonly options: BuilderOptions;
-
-  private readonly enabled = new Set<"js" | "ts" | "pkg">();
-
-  constructor(options: BuilderOptions = {}) {
-    this.options = options;
-  }
-
-  toConfig() {
-    return [...base(this.options, this.enabled), ...this.configs];
-  }
-
-  private setup(
-    configItems: readonly { rules: object }[],
-    { pick, omit }: 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 result = configItems.map((configItem) => ({
-      ...configItem,
-      rules: Object.fromEntries(
-        Object.entries(configItem.rules).filter(([ruleKey]) => select(ruleKey)),
-      ),
-    }));
-    this.configs.push(...result);
-
-    return this;
-  }
-
-  enableTypeScript<T extends TsRuleKey[]>(options: Options<T> = {}) {
-    this.enabled.add("ts");
-    return this.setup(typescript(), options);
-  }
-
-  enableJavaScript<T extends JsRuleKey[]>(options: Options<T> = {}) {
-    this.enabled.add("js");
-    return this.setup(javascript(), options);
-  }
-
-  enablePackageJson<T extends PkgRuleKey[]>(options: Options<T> = {}) {
-    this.enabled.add("pkg");
-    return this.setup(packagejson(), options);
-  }
-
-  append(config: ConfigItem) {
-    this.configs.push(config);
-    return this;
-  }
-}
-
-export default new Builder()
-  .enablePackageJson()
-  .enableJavaScript()
-  .enableTypeScript()
-  .toConfig();

package/src/typing.d.ts

@@ -1,8 +0,0 @@
-module "eslint-plugin-*" {
-  const plugin: unknown = {}; // TODO: Add initializer because of this issue https://github.com/IanVS/prettier-plugin-sort-imports/issues/196
-  export default plugin;
-}
-module "confusing-browser-globals" {
-  const keys: string[] = [];
-  export default keys;
-}