@borela-tech/eslint-config 2.1.2 → 2.2.1

package/dist/index.js

@@ -1,855 +0,0 @@
-// src/index.ts
-import eslint from "@eslint/js";
-import react from "eslint-plugin-react";
-import reactHooks from "eslint-plugin-react-hooks";
-import stylistic from "@stylistic/eslint-plugin";
-import typescript from "typescript-eslint";
-import { defineConfig } from "eslint/config";
-
-// src/rules/importsAndReExportsAtTop/getStatementType.ts
-function getStatementType(statement) {
-  if (statement.type === "ImportDeclaration")
-    return "import";
-  if (statement.type === "ExportAllDeclaration")
-    return "re-export";
-  if (statement.type === "ExportNamedDeclaration") {
-    if (statement.source !== null)
-      return "re-export";
-  }
-  return "other";
-}
-
-// src/rules/importsAndReExportsAtTop/categorizeStatements.ts
-function categorizeStatements(statements) {
-  const result = {
-    imports: [],
-    reExports: [],
-    other: []
-  };
-  for (const statement of statements) {
-    const type = getStatementType(statement);
-    if (type === "import")
-      result.imports.push(statement);
-    else if (type === "re-export")
-      result.reExports.push(statement);
-    else
-      result.other.push(statement);
-  }
-  return result;
-}
-
-// src/rules/importsAndReExportsAtTop/findStatementIndices.ts
-function findStatementIndices(statements) {
-  let firstRegularStatement = -1;
-  let lastImport = -1;
-  let lastReExport = -1;
-  for (let i = 0; i < statements.length; i++) {
-    const type = getStatementType(statements[i]);
-    if (type === "import")
-      lastImport = i;
-    else if (type === "re-export")
-      lastReExport = i;
-    else if (type === "other" && firstRegularStatement === -1)
-      firstRegularStatement = i;
-  }
-  return { firstRegularStatement, lastImport, lastReExport };
-}
-
-// src/rules/importsAndReExportsAtTop/generateSortedText.ts
-function generateSortedText(context, categories) {
-  const allStatements = [
-    ...categories.imports,
-    ...categories.reExports,
-    ...categories.other
-  ];
-  return allStatements.map(
-    (node) => context.sourceCode.getText(node)
-  ).join("\n");
-}
-
-// src/rules/importsAndReExportsAtTop/hasViolation.ts
-function hasViolation(indices, categories) {
-  const { firstRegularStatement, lastImport, lastReExport } = indices;
-  if (categories.imports.length === 0 && categories.reExports.length === 0)
-    return false;
-  const hasImportAfterRegularStatement = categories.imports.length > 0 && firstRegularStatement !== -1 && lastImport > firstRegularStatement;
-  const hasReExportAfterRegularStatement = categories.reExports.length > 0 && firstRegularStatement !== -1 && lastReExport > firstRegularStatement;
-  return hasImportAfterRegularStatement || hasReExportAfterRegularStatement;
-}
-
-// src/rules/importsAndReExportsAtTop/index.ts
-var importsAndReExportsAtTop = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Enforce imports and re-exports at the top of the file",
-      recommended: false
-    },
-    fixable: "code",
-    messages: {
-      importsAndReExportsAtTop: "Imports and re-exports should be at the top of the file."
-    },
-    schema: []
-  },
-  create(context) {
-    return {
-      Program(node) {
-        const statements = node.body;
-        const categories = categorizeStatements(statements);
-        const indices = findStatementIndices(statements);
-        if (!hasViolation(indices, categories))
-          return;
-        context.report({
-          node,
-          messageId: "importsAndReExportsAtTop",
-          fix(fixer) {
-            const sortedText = generateSortedText(context, categories);
-            return fixer.replaceText(node, sortedText);
-          }
-        });
-      }
-    };
-  }
-};
-
-// src/rules/individualImports.ts
-var individualImports = {
-  meta: {
-    docs: {
-      description: "Enforce individual imports instead of grouped imports",
-      recommended: true
-    },
-    fixable: "code",
-    messages: {
-      individualImports: "Use individual imports instead of grouped imports."
-    },
-    schema: [],
-    type: "suggestion"
-  },
-  create(context) {
-    return {
-      ImportDeclaration(node) {
-        if (node.specifiers.length <= 1)
-          return;
-        context.report({
-          node,
-          messageId: "individualImports",
-          fix(fixer) {
-            const source = node.source.raw;
-            const specifiers = node.specifiers.filter((s) => s.type === "ImportSpecifier").map((s) => `import {${s.local.name}} from ${source}`).join("\n");
-            return fixer.replaceText(node, specifiers);
-          }
-        });
-      }
-    };
-  }
-};
-
-// src/rules/individualReExports.ts
-var individualReExports = {
-  meta: {
-    docs: {
-      description: "Enforce individual exports instead of grouped exports",
-      recommended: true
-    },
-    fixable: "code",
-    messages: {
-      individualReExports: "Use individual exports instead of grouped exports."
-    },
-    schema: [],
-    type: "suggestion"
-  },
-  create(context) {
-    return {
-      ExportNamedDeclaration(node) {
-        const exportNode = node;
-        if (!exportNode.source || exportNode.specifiers.length <= 1)
-          return;
-        context.report({
-          node,
-          messageId: "individualReExports",
-          fix(fixer) {
-            const source = exportNode.source.value;
-            const typeKeyword = exportNode.exportKind === "type" ? "type " : "";
-            const specifiers = exportNode.specifiers.map((s) => {
-              const localName = s.local.type === "Identifier" ? s.local.name : s.local.value;
-              const exportedName = s.exported.type === "Identifier" ? s.exported.name : s.exported.value;
-              const name = localName === exportedName ? localName : `${localName} as ${exportedName}`;
-              return `export ${typeKeyword}{${name}} from '${source}'`;
-            }).join("\n");
-            return fixer.replaceText(node, specifiers);
-          }
-        });
-      }
-    };
-  }
-};
-
-// src/rules/sortedImports/categorizeImport.ts
-function categorizeImport(declaration) {
-  if (declaration.importKind === "type")
-    return "type";
-  if (declaration.specifiers.length === 0)
-    return "side-effect";
-  if (declaration.specifiers.some((s) => s.type === "ImportDefaultSpecifier"))
-    return "default";
-  return "named";
-}
-
-// src/rules/sortedImports/getSortKey.ts
-function getSortKey(declaration) {
-  const group = categorizeImport(declaration);
-  if (group === "side-effect")
-    return declaration.source.value;
-  if (group === "default") {
-    const defaultSpecifier = declaration.specifiers.find(
-      (s) => s.type === "ImportDefaultSpecifier"
-    );
-    return defaultSpecifier?.local.name ?? "";
-  }
-  const specifier = declaration.specifiers[0];
-  return specifier.local.name;
-}
-
-// src/rules/sortedImports/categorizeImports.ts
-function categorizeImports(declarations) {
-  return declarations.map((declaration) => ({
-    declaration,
-    group: categorizeImport(declaration),
-    sortKey: getSortKey(declaration)
-  }));
-}
-
-// src/lib/compare.ts
-function compare(a, b) {
-  return a.localeCompare(b, "en", { sensitivity: "case" });
-}
-
-// src/rules/sortedImports/ImportGroupOrder.ts
-var importGroupOrder = [
-  "side-effect",
-  "default",
-  "named",
-  "type"
-];
-
-// src/rules/sortedImports/checkAlphabeticalSorting.ts
-function checkAlphabeticalSorting(categorized) {
-  const errors = [];
-  for (const group of importGroupOrder) {
-    const groupImports = categorized.filter((c) => c.group === group);
-    const sorted = [...groupImports].sort((a, b) => compare(a.sortKey, b.sortKey));
-    for (let i = 0; i < groupImports.length; i++) {
-      if (groupImports[i] !== sorted[i]) {
-        errors.push({
-          node: groupImports[i].declaration,
-          messageId: "sortedImports"
-        });
-      }
-    }
-  }
-  return errors;
-}
-
-// src/rules/sortedImports/checkGroupOrdering.ts
-function checkGroupOrdering(categorized) {
-  const errors = [];
-  let currentGroupIndex = -1;
-  for (const { declaration, group } of categorized) {
-    const groupIndex = importGroupOrder.indexOf(group);
-    if (groupIndex < currentGroupIndex) {
-      errors.push({
-        node: declaration,
-        messageId: "wrongGroup"
-      });
-    } else
-      currentGroupIndex = groupIndex;
-  }
-  return errors;
-}
-
-// src/rules/sortedImports/getSpecifierName.ts
-function getSpecifierName(specifier) {
-  return specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value);
-}
-
-// src/rules/sortedImports/areSpecifiersSorted.ts
-function areSpecifiersSorted(specifiers) {
-  const names = specifiers.map((s) => getSpecifierName(s));
-  const sorted = [...names].sort((a, b) => compare(a, b));
-  return names.every((name, i) => name === sorted[i]);
-}
-
-// src/rules/sortedImports/getNamedSpecifiers.ts
-function getNamedSpecifiers(declaration) {
-  return declaration.specifiers.filter(
-    (s) => s.type === "ImportSpecifier"
-  );
-}
-
-// src/rules/sortedImports/checkSpecifiersSorting.ts
-function checkSpecifiersSorting(categorized) {
-  const errors = [];
-  const namedImports = categorized.filter((c) => c.group === "named");
-  for (const { declaration } of namedImports) {
-    const specifiers = getNamedSpecifiers(declaration);
-    if (specifiers.length > 1 && !areSpecifiersSorted(specifiers)) {
-      errors.push({
-        node: declaration,
-        messageId: "sortedNames"
-      });
-    }
-  }
-  return errors;
-}
-
-// src/rules/sortedImports/sortSpecifiersText.ts
-function sortSpecifiersText(specifiers, sourceCode) {
-  const sorted = [...specifiers].sort((a, b) => {
-    const nameA = getSpecifierName(a);
-    const nameB = getSpecifierName(b);
-    return compare(nameA, nameB);
-  });
-  return sorted.map((s) => sourceCode.getText(s)).join(", ");
-}
-
-// src/rules/sortedImports/createFix/formatNamedImport.ts
-function formatNamedImport(declaration, sourceCode) {
-  const specifiers = getNamedSpecifiers(declaration);
-  if (specifiers.length > 1 && !areSpecifiersSorted(specifiers)) {
-    const sortedSpecifiers = sortSpecifiersText(specifiers, sourceCode);
-    const source = declaration.source.value;
-    const prefix = declaration.importKind === "type" ? "import type " : "import ";
-    return `${prefix}{${sortedSpecifiers}} from '${source}'`;
-  }
-  return sourceCode.getText(declaration);
-}
-
-// src/rules/sortedImports/createFix/buildSortedCode.ts
-function buildSortedCode(grouped, sourceCode) {
-  const sortedCode = [];
-  for (const group of importGroupOrder) {
-    for (const { declaration } of grouped[group]) {
-      if (group === "named" || group === "type")
-        sortedCode.push(formatNamedImport(declaration, sourceCode));
-      else
-        sortedCode.push(sourceCode.getText(declaration));
-    }
-  }
-  return sortedCode;
-}
-
-// src/rules/sortedImports/createFix/groupImportsByType.ts
-function groupImportsByType(categorized) {
-  const grouped = {
-    "side-effect": [],
-    default: [],
-    named: [],
-    type: []
-  };
-  for (const item of categorized)
-    grouped[item.group].push(item);
-  return grouped;
-}
-
-// src/rules/sortedImports/createFix/sortImportGroups.ts
-function sortImportGroups(grouped) {
-  grouped["side-effect"].sort((a, b) => compare(a.sortKey, b.sortKey));
-  grouped["default"].sort((a, b) => compare(a.sortKey, b.sortKey));
-  grouped["named"].sort((a, b) => compare(a.sortKey, b.sortKey));
-  grouped["type"].sort((a, b) => compare(a.sortKey, b.sortKey));
-}
-
-// src/rules/sortedImports/createFix/index.ts
-function createFixForGroup(fixer, importDeclarations, sourceCode) {
-  if (importDeclarations.length === 0) {
-    return null;
-  }
-  const categorized = categorizeImports(importDeclarations);
-  const grouped = groupImportsByType(categorized);
-  sortImportGroups(grouped);
-  const sortedCode = buildSortedCode(grouped, sourceCode).join("\n");
-  const firstImport = importDeclarations[0];
-  const lastImport = importDeclarations[importDeclarations.length - 1];
-  return fixer.replaceTextRange(
-    [firstImport.range[0], lastImport.range[1]],
-    sortedCode
-  );
-}
-function createFix(fixer, importGroups, sourceCode) {
-  const fixes = [];
-  for (const group of importGroups) {
-    const fix = createFixForGroup(fixer, group, sourceCode);
-    if (fix)
-      fixes.push(fix);
-  }
-  return fixes;
-}
-
-// src/rules/sortedImports/getImportGroups.ts
-function getImportGroups(programBody) {
-  const groups = [];
-  let currentGroup = [];
-  for (const statement of programBody) {
-    if (statement.type === "ImportDeclaration") {
-      currentGroup.push(statement);
-      continue;
-    }
-    if (currentGroup.length > 0) {
-      groups.push(currentGroup);
-      currentGroup = [];
-    }
-  }
-  if (currentGroup.length > 0)
-    groups.push(currentGroup);
-  return groups;
-}
-
-// src/rules/sortedImports/index.ts
-var sortedImports = {
-  meta: {
-    docs: {
-      description: "Enforce sorted imports alphabetically",
-      recommended: true
-    },
-    fixable: "code",
-    messages: {
-      sortedImports: "Imports should be sorted alphabetically",
-      sortedNames: "Named imports should be sorted alphabetically",
-      wrongGroup: "Import is in wrong group"
-    },
-    schema: [],
-    type: "suggestion"
-  },
-  create(context) {
-    return {
-      Program(node) {
-        const body = node.body;
-        const importGroups = getImportGroups(body);
-        if (importGroups.length === 0)
-          return;
-        const allErrors = [];
-        for (const group of importGroups) {
-          const categorized = categorizeImports(group);
-          const errors = [
-            ...checkGroupOrdering(categorized),
-            ...checkAlphabeticalSorting(categorized),
-            ...checkSpecifiersSorting(categorized)
-          ];
-          allErrors.push(...errors);
-        }
-        for (const error of allErrors) {
-          context.report({
-            node: error.node,
-            messageId: error.messageId,
-            fix(fixer) {
-              const sourceCode = context.sourceCode;
-              return createFix(fixer, importGroups, sourceCode);
-            }
-          });
-        }
-      }
-    };
-  }
-};
-
-// src/rules/sortedReExports/categorizeReExport.ts
-function categorizeReExport(declaration) {
-  if (declaration.type === "ExportAllDeclaration")
-    return "re-export-all";
-  if (declaration.exportKind === "type")
-    return "re-export-type";
-  return "re-export-named";
-}
-
-// src/rules/sortedReExports/getSortKey.ts
-function getSortKey2(declaration) {
-  if (declaration.type === "ExportAllDeclaration")
-    return declaration.source.value;
-  const specifier = declaration.specifiers[0];
-  if (!specifier)
-    return "";
-  return specifier.local.type === "Identifier" ? specifier.local.name : specifier.local.value;
-}
-
-// src/rules/sortedReExports/categorizeReExports.ts
-function categorizeReExports(declarations) {
-  return declarations.map((declaration) => {
-    return {
-      declaration,
-      group: categorizeReExport(declaration),
-      sortKey: getSortKey2(declaration)
-    };
-  });
-}
-
-// src/rules/sortedReExports/ReExportGroupOrder.ts
-var reExportGroupOrder = [
-  "re-export-all",
-  "re-export-named",
-  "re-export-type"
-];
-
-// src/rules/sortedReExports/checkAlphabeticalSorting.ts
-function checkAlphabeticalSorting2(categorized) {
-  const errors = [];
-  for (const group of reExportGroupOrder) {
-    const groupReExports = categorized.filter((c) => c.group === group);
-    const sorted = [...groupReExports].sort(
-      (a, b) => compare(a.sortKey, b.sortKey)
-    );
-    for (let i = 0; i < groupReExports.length; i++) {
-      if (groupReExports[i] !== sorted[i]) {
-        errors.push({
-          node: groupReExports[i].declaration,
-          messageId: "sortedReExports"
-        });
-      }
-    }
-  }
-  return errors;
-}
-
-// src/rules/sortedReExports/checkGroupOrdering.ts
-function checkGroupOrdering2(categorized) {
-  const errors = [];
-  let currentGroupIndex = -1;
-  for (const { declaration, group } of categorized) {
-    const groupIndex = reExportGroupOrder.indexOf(group);
-    if (groupIndex < currentGroupIndex) {
-      errors.push({
-        node: declaration,
-        messageId: "wrongGroup"
-      });
-    } else
-      currentGroupIndex = groupIndex;
-  }
-  return errors;
-}
-
-// src/rules/sortedReExports/getSpecifierName.ts
-function getSpecifierName2(specifier) {
-  return specifier.local.type === "Identifier" ? specifier.local.name : String(specifier.local.value);
-}
-
-// src/rules/sortedReExports/areSpecifiersSorted.ts
-function areSpecifiersSorted2(specifiers) {
-  const names = specifiers.map((s) => getSpecifierName2(s));
-  const sorted = [...names].sort((a, b) => compare(a, b));
-  return names.every((name, i) => name === sorted[i]);
-}
-
-// src/rules/sortedReExports/getNamedSpecifiers.ts
-function getNamedSpecifiers2(declaration) {
-  return declaration.specifiers.filter(
-    (s) => s.type === "ExportSpecifier" && s.local.type === "Identifier"
-  );
-}
-
-// src/rules/sortedReExports/isNamedReExport.ts
-function isNamedReExport(x) {
-  return x.group !== "re-export-all";
-}
-
-// src/rules/sortedReExports/checkSpecifiersSorting.ts
-function checkSpecifiersSorting2(categorized) {
-  const errors = [];
-  const namedReExports = categorized.filter(isNamedReExport);
-  for (const { declaration } of namedReExports) {
-    const specifiers = getNamedSpecifiers2(declaration);
-    const isSorted = areSpecifiersSorted2(specifiers);
-    if (specifiers.length > 1 && !isSorted) {
-      errors.push({
-        node: declaration,
-        messageId: "sortedNames"
-      });
-    }
-  }
-  return errors;
-}
-
-// src/rules/sortedReExports/sortSpecifiersText.ts
-function sortSpecifiersText2(specifiers, sourceCode) {
-  const sorted = [...specifiers].sort((a, b) => {
-    const nameA = getSpecifierName2(a);
-    const nameB = getSpecifierName2(b);
-    return compare(nameA, nameB);
-  });
-  return sorted.map((s) => sourceCode.getText(s)).join(", ");
-}
-
-// src/rules/sortedReExports/createFix/formatNamedReExport.ts
-function formatNamedReExport(declaration, sourceCode) {
-  const specifiers = getNamedSpecifiers2(declaration);
-  if (specifiers.length > 1 && !areSpecifiersSorted2(specifiers)) {
-    const sortedSpecifiers = sortSpecifiersText2(specifiers, sourceCode);
-    const source = declaration.source.value;
-    const prefix = declaration.exportKind === "type" ? "export type " : "export ";
-    return `${prefix}{${sortedSpecifiers}} from '${source}'`;
-  }
-  return sourceCode.getText(declaration);
-}
-
-// src/rules/sortedReExports/createFix/buildSortedCode.ts
-function buildSortedCode2(grouped, sourceCode) {
-  const sortedCode = [];
-  for (const group of reExportGroupOrder) {
-    for (const item of grouped[group]) {
-      if (isNamedReExport(item)) {
-        sortedCode.push(
-          formatNamedReExport(
-            item.declaration,
-            sourceCode
-          )
-        );
-      } else
-        sortedCode.push(sourceCode.getText(item.declaration));
-    }
-  }
-  return sortedCode;
-}
-
-// src/rules/sortedReExports/createFix/groupReExportsByType.ts
-function groupReExportsByType(categorized) {
-  const grouped = {
-    "re-export-all": [],
-    "re-export-named": [],
-    "re-export-type": []
-  };
-  for (const item of categorized)
-    grouped[item.group].push(item);
-  return grouped;
-}
-
-// src/rules/sortedReExports/createFix/sortExportGroups.ts
-function sortExportGroups(grouped) {
-  grouped["re-export-all"].sort((a, b) => compare(a.sortKey, b.sortKey));
-  grouped["re-export-named"].sort((a, b) => compare(a.sortKey, b.sortKey));
-  grouped["re-export-type"].sort((a, b) => compare(a.sortKey, b.sortKey));
-}
-
-// src/rules/sortedReExports/createFix/index.ts
-function createFixForGroup2(fixer, reExportDeclarations, sourceCode) {
-  if (reExportDeclarations.length === 0) {
-    return null;
-  }
-  const categorized = categorizeReExports(reExportDeclarations);
-  const grouped = groupReExportsByType(categorized);
-  sortExportGroups(grouped);
-  const sortedCode = buildSortedCode2(grouped, sourceCode).join("\n");
-  const firstReExport = reExportDeclarations[0];
-  const lastReExport = reExportDeclarations[reExportDeclarations.length - 1];
-  return fixer.replaceTextRange(
-    [firstReExport.range[0], lastReExport.range[1]],
-    sortedCode
-  );
-}
-function createFix2(fixer, reExportGroups, sourceCode) {
-  const fixes = [];
-  for (const group of reExportGroups) {
-    const fix = createFixForGroup2(fixer, group, sourceCode);
-    if (fix)
-      fixes.push(fix);
-  }
-  return fixes;
-}
-
-// src/rules/sortedReExports/getReExportGroups.ts
-function isReExportDeclaration(statement) {
-  return statement.type === "ExportNamedDeclaration" && statement.source !== null || statement.type === "ExportAllDeclaration";
-}
-function getReExportGroups(programBody) {
-  const groups = [];
-  let currentGroup = [];
-  for (const statement of programBody) {
-    if (isReExportDeclaration(statement)) {
-      currentGroup.push(statement);
-      continue;
-    }
-    if (currentGroup.length > 0) {
-      groups.push(currentGroup);
-      currentGroup = [];
-    }
-  }
-  if (currentGroup.length > 0)
-    groups.push(currentGroup);
-  return groups;
-}
-
-// src/rules/sortedReExports/index.ts
-var sortedReExports = {
-  meta: {
-    docs: {
-      description: "Enforce sorted exports alphabetically",
-      recommended: true
-    },
-    fixable: "code",
-    messages: {
-      sortedReExports: "Exports should be sorted alphabetically",
-      sortedNames: "Named exports should be sorted alphabetically",
-      wrongGroup: "Export is in wrong group"
-    },
-    schema: [],
-    type: "suggestion"
-  },
-  create(context) {
-    return {
-      Program(node) {
-        const body = node.body;
-        const reExportGroups = getReExportGroups(body);
-        if (reExportGroups.length === 0)
-          return;
-        const allErrors = [];
-        for (const group of reExportGroups) {
-          const categorized = categorizeReExports(group);
-          const errors = [
-            ...checkGroupOrdering2(categorized),
-            ...checkAlphabeticalSorting2(categorized),
-            ...checkSpecifiersSorting2(categorized)
-          ];
-          allErrors.push(...errors);
-        }
-        for (const error of allErrors) {
-          context.report({
-            node: error.node,
-            messageId: error.messageId,
-            fix(fixer) {
-              const sourceCode = context.sourceCode;
-              return createFix2(fixer, reExportGroups, sourceCode);
-            }
-          });
-        }
-      }
-    };
-  }
-};
-
-// src/index.ts
-var CONFIG = defineConfig([
-  {
-    ignores: [
-      "src/graphql/sdk.ts",
-      "**/node_modules/**",
-      "**/dist/**"
-    ]
-  },
-  {
-    settings: {
-      react: {
-        version: "19"
-      }
-    }
-  },
-  eslint.configs.recommended,
-  react.configs.flat.recommended,
-  stylistic.configs.recommended,
-  typescript.configs.recommended,
-  typescript.configs.stylistic,
-  {
-    plugins: {
-      "react-hooks": reactHooks
-    },
-    rules: reactHooks.configs.recommended.rules
-  },
-  {
-    plugins: {
-      "@borela-tech": {
-        rules: {
-          "imports-and-re-exports-at-top": importsAndReExportsAtTop,
-          "individual-imports": individualImports,
-          "individual-re-exports": individualReExports,
-          "sorted-imports": sortedImports,
-          "sorted-re-exports": sortedReExports
-        }
-      }
-    },
-    rules: {
-      "@borela-tech/imports-and-re-exports-at-top": "error",
-      "@borela-tech/individual-imports": "error",
-      "@borela-tech/individual-re-exports": "error",
-      "@borela-tech/sorted-imports": "error",
-      "@borela-tech/sorted-re-exports": "error"
-    }
-  },
-  {
-    rules: {
-      "capitalized-comments": [
-        "error",
-        "always",
-        { ignoreConsecutiveComments: true }
-      ],
-      "react/react-in-jsx-scope": "off",
-      "@stylistic/arrow-parens": [
-        "error",
-        "as-needed"
-      ],
-      "@stylistic/array-bracket-newline": [
-        "error",
-        "consistent"
-      ],
-      "@stylistic/array-bracket-spacing": [
-        "error",
-        "never"
-      ],
-      "@stylistic/array-element-newline": [
-        "error",
-        "consistent"
-      ],
-      "@stylistic/block-spacing": "off",
-      "@stylistic/brace-style": [
-        "error",
-        "1tbs",
-        { allowSingleLine: true }
-      ],
-      "@stylistic/indent": [
-        "error",
-        2,
-        { ignoredNodes: ["TSMappedType > *"] }
-      ],
-      "@stylistic/jsx-tag-spacing": [
-        "error",
-        {
-          afterOpening: "never",
-          beforeClosing: "never",
-          beforeSelfClosing: "never",
-          closingSlash: "never"
-        }
-      ],
-      "@stylistic/jsx-wrap-multilines": "off",
-      "@stylistic/lines-between-class-members": "off",
-      "@stylistic/object-curly-newline": [
-        "error",
-        { consistent: true }
-      ],
-      "@stylistic/object-curly-spacing": [
-        "error",
-        "never"
-      ],
-      "@stylistic/operator-linebreak": [
-        "error",
-        "before",
-        { overrides: { "=": "after" } }
-      ],
-      "@stylistic/quotes": [
-        "error",
-        "single",
-        { avoidEscape: true }
-      ],
-      "@stylistic/quote-props": [
-        "error",
-        "as-needed"
-      ],
-      "@stylistic/semi": [
-        "error",
-        "never",
-        { beforeStatementContinuationChars: "always" }
-      ],
-      "@typescript-eslint/no-empty-function": "off",
-      "@typescript-eslint/consistent-indexed-object-style": "off"
-    }
-  }
-]);
-export {
-  CONFIG
-};
-//# sourceMappingURL=index.js.map