@graphql-eslint/eslint-plugin 4.3.0 → 4.3.1-alpha-20241209185034-de2d7397da8c26620a8930dd12b6dff42e43f537

package/esm/rules/require-type-pattern-with-oneof/index.js

@@ -1,5 +1,6 @@
 import { displayNodeName } from "../../utils.js";
-const RULE_ID = "require-type-pattern-with-oneof", rule = {
+const RULE_ID = "require-type-pattern-with-oneof";
+const rule = {
   meta: {
     type: "suggestion",
     docs: {
@@ -44,15 +45,18 @@ const RULE_ID = "require-type-pattern-with-oneof", rule = {
         parent
       }) {
         const requiredFields = ["error", "ok"];
-        for (const fieldName of requiredFields)
-          parent.fields?.some((field) => field.name.value === fieldName) || context.report({
-            node: parent.name,
-            messageId: RULE_ID,
-            data: {
-              nodeName: displayNodeName(parent),
-              fieldName
-            }
-          });
+        for (const fieldName of requiredFields) {
+          if (!parent.fields?.some((field) => field.name.value === fieldName)) {
+            context.report({
+              node: parent.name,
+              messageId: RULE_ID,
+              data: {
+                nodeName: displayNodeName(parent),
+                fieldName
+              }
+            });
+          }
+        }
       }
     };
   }

package/esm/rules/selection-set-depth/index.js

@@ -1,13 +1,14 @@
 import { Kind } from "graphql";
 import depthLimit from "graphql-depth-limit";
 import { ARRAY_DEFAULT_OPTIONS, logger, requireGraphQLOperations } from "../../utils.js";
-const RULE_ID = "selection-set-depth", schema = {
+const RULE_ID = "selection-set-depth";
+const schema = {
   type: "array",
   minItems: 1,
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     required: ["maxDepth"],
     properties: {
       maxDepth: {
@@ -16,15 +17,16 @@ const RULE_ID = "selection-set-depth", schema = {
       ignore: ARRAY_DEFAULT_OPTIONS
     }
   }
-}, rule = {
+};
+const rule = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Operations",
       description: "Limit the complexity of the GraphQL operations solely by their depth. Based on [graphql-depth-limit](https://npmjs.com/package/graphql-depth-limit).",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-      requiresSiblings: !0,
+      requiresSiblings: true,
       examples: [
         {
           title: "Incorrect",
@@ -66,7 +68,7 @@ const RULE_ID = "selection-set-depth", schema = {
           `
         }
       ],
-      recommended: !0,
+      recommended: true,
       configOptions: [{ maxDepth: 7 }]
     },
     schema
@@ -80,18 +82,23 @@ const RULE_ID = "selection-set-depth", schema = {
         `Rule "${RULE_ID}" works best with siblings operations loaded. See https://the-guild.dev/graphql/eslint/docs/usage#providing-operations for more info`
       );
     }
-    const { maxDepth, ignore = [] } = context.options[0], checkFn = depthLimit(maxDepth, { ignore });
+    const { maxDepth, ignore = [] } = context.options[0];
+    const checkFn = depthLimit(maxDepth, { ignore });
     return {
       "OperationDefinition, FragmentDefinition"(node) {
         try {
-          const rawNode = node.rawNode(), fragmentsInUse = siblings ? siblings.getFragmentsInUse(rawNode) : [], document = {
+          const rawNode = node.rawNode();
+          const fragmentsInUse = siblings ? siblings.getFragmentsInUse(rawNode) : [];
+          const document = {
             kind: Kind.DOCUMENT,
             definitions: [rawNode, ...fragmentsInUse]
           };
           checkFn({
             getDocument: () => document,
             reportError(error) {
-              const { line, column } = error.locations[0], token = context.sourceCode.getAncestors(node)[0].tokens.find(
+              const { line, column } = error.locations[0];
+              const ancestors = context.sourceCode.getAncestors(node);
+              const token = ancestors[0].tokens.find(
                 (token2) => token2.loc.start.line === line && token2.loc.start.column === column - 1
               );
               context.report({
@@ -106,7 +113,9 @@ const RULE_ID = "selection-set-depth", schema = {
                     {
                       desc: "Remove selections",
                       fix(fixer) {
-                        const foundNode = context.getSourceCode().getNodeByRangeIndex(token.range[0]), parentNode = foundNode.parent.parent;
+                        const sourceCode = context.getSourceCode();
+                        const foundNode = sourceCode.getNodeByRangeIndex(token.range[0]);
+                        const parentNode = foundNode.parent.parent;
                         return fixer.remove(
                           foundNode.kind === "Name" ? parentNode.parent : parentNode
                         );

package/esm/rules/strict-id-in-types/index.js

@@ -5,12 +5,13 @@ import {
   englishJoinWords,
   requireGraphQLSchema
 } from "../../utils.js";
-const RULE_ID = "strict-id-in-types", schema = {
+const RULE_ID = "strict-id-in-types";
+const schema = {
   type: "array",
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     properties: {
       acceptedIdNames: {
         ...ARRAY_DEFAULT_OPTIONS,
@@ -22,7 +23,7 @@ const RULE_ID = "strict-id-in-types", schema = {
       },
       exceptions: {
         type: "object",
-        additionalProperties: !1,
+        additionalProperties: false,
         properties: {
           types: {
             ...ARRAY_DEFAULT_OPTIONS,
@@ -36,15 +37,16 @@ const RULE_ID = "strict-id-in-types", schema = {
       }
     }
   }
-}, rule = {
+};
+const rule = {
   meta: {
     type: "suggestion",
     docs: {
       description: "Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers.",
       category: "Schema",
-      recommended: !0,
+      recommended: true,
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-      requiresSchema: !0,
+      requiresSchema: true,
       examples: [
         {
           title: "Incorrect",
@@ -121,22 +123,33 @@ const RULE_ID = "strict-id-in-types", schema = {
       acceptedIdTypes: ["ID"],
       exceptions: {},
       ...context.options[0]
-    }, schema2 = requireGraphQLSchema(RULE_ID, context);
+    };
+    const schema2 = requireGraphQLSchema(RULE_ID, context);
+    const rootTypeNames = [
+      schema2.getQueryType(),
+      schema2.getMutationType(),
+      schema2.getSubscriptionType()
+    ].filter((v) => !!v).map((type) => type.name);
+    const selector = `ObjectTypeDefinition[name.value!=/^(${rootTypeNames.join("|")})$/]`;
     return {
-      [`ObjectTypeDefinition[name.value!=/^(${[
-        schema2.getQueryType(),
-        schema2.getMutationType(),
-        schema2.getSubscriptionType()
-      ].filter((v) => !!v).map((type) => type.name).join("|")})$/]`](node) {
+      [selector](node) {
         const typeName = node.name.value;
-        if (options.exceptions.types?.includes(typeName) || options.exceptions.suffixes?.some((suffix) => typeName.endsWith(suffix)))
+        const shouldIgnoreNode = options.exceptions.types?.includes(typeName) || options.exceptions.suffixes?.some((suffix) => typeName.endsWith(suffix));
+        if (shouldIgnoreNode) {
           return;
-        if (node.fields?.filter((field) => {
-          const fieldNode = field.rawNode(), isValidIdName = options.acceptedIdNames.includes(fieldNode.name.value);
-          let isValidIdType = !1;
-          return fieldNode.type.kind === Kind.NON_NULL_TYPE && fieldNode.type.type.kind === Kind.NAMED_TYPE && (isValidIdType = options.acceptedIdTypes.includes(fieldNode.type.type.name.value)), isValidIdName && isValidIdType;
-        })?.length !== 1) {
-          const pluralNamesSuffix = options.acceptedIdNames.length > 1 ? "s" : "", pluralTypesSuffix = options.acceptedIdTypes.length > 1 ? "s" : "";
+        }
+        const validIds = node.fields?.filter((field) => {
+          const fieldNode = field.rawNode();
+          const isValidIdName = options.acceptedIdNames.includes(fieldNode.name.value);
+          let isValidIdType = false;
+          if (fieldNode.type.kind === Kind.NON_NULL_TYPE && fieldNode.type.type.kind === Kind.NAMED_TYPE) {
+            isValidIdType = options.acceptedIdTypes.includes(fieldNode.type.type.name.value);
+          }
+          return isValidIdName && isValidIdType;
+        });
+        if (validIds?.length !== 1) {
+          const pluralNamesSuffix = options.acceptedIdNames.length > 1 ? "s" : "";
+          const pluralTypesSuffix = options.acceptedIdTypes.length > 1 ? "s" : "";
           context.report({
             node: node.name,
             message: `${displayNodeName(node)} must have exactly one non-nullable unique identifier.

package/esm/rules/unique-enum-value-names/index.js

@@ -3,11 +3,11 @@ import { getNodeName } from "../../utils.js";
 const rule = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       url: "https://the-guild.dev/graphql/eslint/rules/unique-enum-value-names",
       category: "Schema",
-      recommended: !0,
+      recommended: true,
       description: `A GraphQL enum type is only valid if all its values are uniquely named.
 > This rule disallows case-insensitive enum values duplicates too.`,
       examples: [
@@ -42,8 +42,9 @@ const rule = {
     schema: []
   },
   create(context) {
+    const selector = [Kind.ENUM_TYPE_DEFINITION, Kind.ENUM_TYPE_EXTENSION].join(",");
     return {
-      [[Kind.ENUM_TYPE_DEFINITION, Kind.ENUM_TYPE_EXTENSION].join(",")](node) {
+      [selector](node) {
         const duplicates = node.values?.filter(
           (item, index, array) => array.findIndex((v) => v.name.value.toLowerCase() === item.name.value.toLowerCase()) !== index
         );

package/esm/rules/unique-fragment-name/index.js

@@ -1,30 +1,38 @@
 import { relative } from "node:path";
 import { Kind } from "graphql";
 import { CWD, requireGraphQLOperations, slash, VIRTUAL_DOCUMENT_REGEX } from "../../utils.js";
-const RULE_ID = "unique-fragment-name", checkNode = (context, node, ruleId) => {
-  const documentName = node.name.value, siblings = requireGraphQLOperations(ruleId, context), siblingDocuments = node.kind === Kind.FRAGMENT_DEFINITION ? siblings.getFragment(documentName) : siblings.getOperation(documentName), filepath = context.filename, conflictingDocuments = siblingDocuments.filter((f) => {
-    const isSameName = f.document.name?.value === documentName, isSamePath = slash(f.filePath) === slash(filepath);
+const RULE_ID = "unique-fragment-name";
+const checkNode = (context, node, ruleId) => {
+  const documentName = node.name.value;
+  const siblings = requireGraphQLOperations(ruleId, context);
+  const siblingDocuments = node.kind === Kind.FRAGMENT_DEFINITION ? siblings.getFragment(documentName) : siblings.getOperation(documentName);
+  const filepath = context.filename;
+  const conflictingDocuments = siblingDocuments.filter((f) => {
+    const isSameName = f.document.name?.value === documentName;
+    const isSamePath = slash(f.filePath) === slash(filepath);
     return isSameName && !isSamePath;
   });
-  conflictingDocuments.length > 0 && context.report({
-    messageId: ruleId,
-    data: {
-      documentName,
-      summary: conflictingDocuments.map((f) => `	${relative(CWD, f.filePath.replace(VIRTUAL_DOCUMENT_REGEX, ""))}`).join(`
-`)
-    },
-    // @ts-expect-error name will exist
-    node: node.name
-  });
-}, rule = {
+  if (conflictingDocuments.length > 0) {
+    context.report({
+      messageId: ruleId,
+      data: {
+        documentName,
+        summary: conflictingDocuments.map((f) => `	${relative(CWD, f.filePath.replace(VIRTUAL_DOCUMENT_REGEX, ""))}`).join("\n")
+      },
+      // @ts-expect-error name will exist
+      node: node.name
+    });
+  }
+};
+const rule = {
   meta: {
     type: "suggestion",
     docs: {
       category: "Operations",
       description: "Enforce unique fragment names across your project.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-      requiresSiblings: !0,
-      recommended: !0,
+      requiresSiblings: true,
+      recommended: true,
       examples: [
         {
           title: "Incorrect",
@@ -67,8 +75,7 @@ const RULE_ID = "unique-fragment-name", checkNode = (context, node, ruleId) => {
       ]
     },
     messages: {
-      [RULE_ID]: `Fragment named "{{ documentName }}" already defined in:
-{{ summary }}`
+      [RULE_ID]: 'Fragment named "{{ documentName }}" already defined in:\n{{ summary }}'
     },
     schema: []
   },

package/esm/rules/unique-operation-name/index.js

@@ -1,13 +1,14 @@
 import { checkNode } from "../unique-fragment-name/index.js";
-const RULE_ID = "unique-operation-name", rule = {
+const RULE_ID = "unique-operation-name";
+const rule = {
   meta: {
     type: "suggestion",
     docs: {
       category: "Operations",
       description: "Enforce unique operation names across your project.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-      requiresSiblings: !0,
-      recommended: !0,
+      requiresSiblings: true,
+      recommended: true,
       examples: [
         {
           title: "Incorrect",
@@ -54,8 +55,7 @@ const RULE_ID = "unique-operation-name", rule = {
       ]
     },
     messages: {
-      [RULE_ID]: `Operation named "{{ documentName }}" already defined in:
-{{ summary }}`
+      [RULE_ID]: 'Operation named "{{ documentName }}" already defined in:\n{{ summary }}'
     },
     schema: []
   },

package/esm/schema.js

@@ -3,19 +3,24 @@ import debugFactory from "debug";
 import fg from "fast-glob";
 import { BREAK, GraphQLSchema, visit } from "graphql";
 import { ModuleCache } from "./cache.js";
-const schemaCache = new ModuleCache(), debug = debugFactory("graphql-eslint:schema"), require2 = createRequire(import.meta.url);
+const schemaCache = new ModuleCache();
+const debug = debugFactory("graphql-eslint:schema");
+const require2 = createRequire(import.meta.url);
 function getSchema(project) {
   const schemaKey = project.schema;
-  if (!schemaKey)
+  if (!schemaKey) {
     return null;
+  }
   const cache = schemaCache.get(schemaKey);
-  if (cache)
+  if (cache) {
     return cache;
+  }
   debug("Loading schema from %o", project.schema);
   const opts = {
     pluckConfig: project.extensions.pluckConfig
-  }, typeDefs = project.loadSchemaSync(project.schema, "DocumentNode", opts);
-  let isFederation = !1;
+  };
+  const typeDefs = project.loadSchemaSync(project.schema, "DocumentNode", opts);
+  let isFederation = false;
   visit(typeDefs, {
     SchemaExtension(node) {
       const linkDirective = node.directives?.find((d) => d.name.value === "link");
@@ -30,14 +35,16 @@ function getSchema(project) {
   if (isFederation) {
     const { buildSubgraphSchema } = require2("@apollo/subgraph");
     schema = buildSubgraphSchema({ typeDefs });
-  } else
+  } else {
     schema = project.loadSchemaSync(project.schema, "GraphQLSchema", opts);
+  }
   if (debug.enabled) {
     debug("Schema loaded: %o", schema instanceof GraphQLSchema);
-    const schemaPaths = fg.sync(project.schema, { absolute: !0 });
+    const schemaPaths = fg.sync(project.schema, { absolute: true });
     debug("Schema pointers %O", schemaPaths);
   }
-  return schemaCache.set(schemaKey, schema), schema;
+  schemaCache.set(schemaKey, schema);
+  return schema;
 }
 export {
   getSchema

package/esm/siblings.js

@@ -6,12 +6,18 @@ import { logger } from "./utils.js";
 const siblingOperationsCache = /* @__PURE__ */ new Map();
 function getSiblings(documents) {
   if (documents.length === 0) {
-    let printed = !1;
-    const noopWarn = () => (printed || (logger.warn(
-      "getSiblingOperations was called without any operations. Make sure to set graphql-config `documents` field to make this feature available! See https://the-guild.dev/graphql/config/docs/user/documents for more info"
-    ), printed = !0), []);
+    let printed = false;
+    const noopWarn = () => {
+      if (!printed) {
+        logger.warn(
+          "getSiblingOperations was called without any operations. Make sure to set graphql-config `documents` field to make this feature available! See https://the-guild.dev/graphql/config/docs/user/documents for more info"
+        );
+        printed = true;
+      }
+      return [];
+    };
     return {
-      available: !1,
+      available: false,
       getFragment: noopWarn,
       getFragments: noopWarn,
       getFragmentByType: noopWarn,
@@ -22,18 +28,23 @@ function getSiblings(documents) {
     };
   }
   const value = siblingOperationsCache.get(documents);
-  if (value)
+  if (value) {
     return value;
+  }
   let fragmentsCache = null;
   const getFragments = () => {
     if (fragmentsCache === null) {
       const result = [];
-      for (const source of documents)
-        for (const definition of source.document?.definitions || [])
-          definition.kind === Kind.FRAGMENT_DEFINITION && result.push({
-            filePath: source.location,
-            document: definition
-          });
+      for (const source of documents) {
+        for (const definition of source.document?.definitions || []) {
+          if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+            result.push({
+              filePath: source.location,
+              document: definition
+            });
+          }
+        }
+      }
       fragmentsCache = result;
     }
     return fragmentsCache;
@@ -42,37 +53,54 @@ function getSiblings(documents) {
   const getOperations = () => {
     if (cachedOperations === null) {
       const result = [];
-      for (const source of documents)
-        for (const definition of source.document?.definitions || [])
-          definition.kind === Kind.OPERATION_DEFINITION && result.push({
-            filePath: source.location,
-            document: definition
-          });
+      for (const source of documents) {
+        for (const definition of source.document?.definitions || []) {
+          if (definition.kind === Kind.OPERATION_DEFINITION) {
+            result.push({
+              filePath: source.location,
+              document: definition
+            });
+          }
+        }
+      }
       cachedOperations = result;
     }
     return cachedOperations;
-  }, getFragment = (name) => getFragments().filter((f) => f.document.name.value === name), collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => (visit(selectable, {
-    FragmentSpread(spread) {
-      const fragmentName = spread.name.value, [fragment] = getFragment(fragmentName);
-      if (!fragment) {
-        logger.warn(
-          `Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`
-        );
-        return;
+  };
+  const getFragment = (name) => getFragments().filter((f) => f.document.name.value === name);
+  const collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => {
+    visit(selectable, {
+      FragmentSpread(spread) {
+        const fragmentName = spread.name.value;
+        const [fragment] = getFragment(fragmentName);
+        if (!fragment) {
+          logger.warn(
+            `Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`
+          );
+          return;
+        }
+        if (!collected.has(fragmentName)) {
+          collected.set(fragmentName, fragment.document);
+          if (recursive) {
+            collectFragments(fragment.document, recursive, collected);
+          }
+        }
       }
-      collected.has(fragmentName) || (collected.set(fragmentName, fragment.document), recursive && collectFragments(fragment.document, recursive, collected));
-    }
-  }), collected), siblingOperations = {
-    available: !0,
+    });
+    return collected;
+  };
+  const siblingOperations = {
+    available: true,
     getFragment,
     getFragments,
     getFragmentByType: (typeName) => getFragments().filter((f) => f.document.typeCondition.name.value === typeName),
-    getFragmentsInUse: (selectable, recursive = !0) => Array.from(collectFragments(selectable, recursive).values()),
+    getFragmentsInUse: (selectable, recursive = true) => Array.from(collectFragments(selectable, recursive).values()),
     getOperation: (name) => getOperations().filter((o) => o.document.name?.value === name),
     getOperations,
     getOperationByType: (type) => getOperations().filter((o) => o.document.operation === type)
   };
-  return siblingOperationsCache.set(documents, siblingOperations), siblingOperations;
+  siblingOperationsCache.set(documents, siblingOperations);
+  return siblingOperations;
 }
 export {
   getSiblings

package/esm/utils.js

@@ -2,24 +2,27 @@ import { Kind } from "graphql";
 import lowerCase from "lodash.lowercase";
 function requireGraphQLOperations(ruleId, context) {
   const { siblingOperations } = context.sourceCode.parserServices;
-  if (!siblingOperations.available)
+  if (!siblingOperations.available) {
     throw new Error(
       `Rule \`${ruleId}\` requires graphql-config \`documents\` field to be set and loaded. See https://the-guild.dev/graphql/eslint/docs/usage#providing-operations for more info`
     );
+  }
   return siblingOperations;
 }
 function requireGraphQLSchema(ruleId, context) {
   const { schema } = context.sourceCode.parserServices;
-  if (!schema)
+  if (!schema) {
     throw new Error(
       `Rule \`${ruleId}\` requires graphql-config \`schema\` field to be set and loaded. See https://the-guild.dev/graphql/eslint/docs/usage#providing-schema for more info`
     );
+  }
   return schema;
 }
 const chalk = {
   red: (str) => `\x1B[31m${str}\x1B[39m`,
   yellow: (str) => `\x1B[33m${str}\x1B[39m`
-}, logger = {
+};
+const logger = {
   error: (...args) => (
     // eslint-disable-next-line no-console
     console.error(chalk.red("error"), "[graphql-eslint]", ...args)
@@ -28,17 +31,25 @@ const chalk = {
     // eslint-disable-next-line no-console
     console.warn(chalk.yellow("warning"), "[graphql-eslint]", ...args)
   )
-}, slash = (path) => path.replaceAll("\\", "/"), VIRTUAL_DOCUMENT_REGEX = /[/\\]\d+_document.graphql$/, CWD = process.cwd(), getTypeName = (node) => "type" in node ? getTypeName(node.type) : "name" in node && node.name ? node.name.value : "", TYPES_KINDS = [
+};
+const slash = (path) => path.replaceAll("\\", "/");
+const VIRTUAL_DOCUMENT_REGEX = /[/\\]\d+_document.graphql$/;
+const CWD = process.cwd();
+const getTypeName = (node) => "type" in node ? getTypeName(node.type) : "name" in node && node.name ? node.name.value : "";
+const TYPES_KINDS = [
   Kind.OBJECT_TYPE_DEFINITION,
   Kind.INTERFACE_TYPE_DEFINITION,
   Kind.ENUM_TYPE_DEFINITION,
   Kind.SCALAR_TYPE_DEFINITION,
   Kind.INPUT_OBJECT_TYPE_DEFINITION,
   Kind.UNION_TYPE_DEFINITION
-], pascalCase = (str) => lowerCase(str).split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(""), camelCase = (str) => {
+];
+const pascalCase = (str) => lowerCase(str).split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+const camelCase = (str) => {
   const result = pascalCase(str);
   return result.charAt(0).toLowerCase() + result.slice(1);
-}, convertCase = (style, str) => {
+};
+const convertCase = (style, str) => {
   switch (style) {
     case "camelCase":
       return camelCase(str);
@@ -65,14 +76,17 @@ function getLocation(start, fieldName = "") {
     }
   };
 }
-const REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 }, ARRAY_DEFAULT_OPTIONS = {
+const REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 };
+const ARRAY_DEFAULT_OPTIONS = {
   type: "array",
-  uniqueItems: !0,
+  uniqueItems: true,
   minItems: 1,
   items: {
     type: "string"
   }
-}, englishJoinWords = (words) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(words), DisplayNodeNameMap = {
+};
+const englishJoinWords = (words) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(words);
+const DisplayNodeNameMap = {
   [Kind.ARGUMENT]: "argument",
   [Kind.BOOLEAN]: "boolean",
   [Kind.DIRECTIVE_DEFINITION]: "directive",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "4.3.0",
+  "version": "4.3.1-alpha-20241209185034-de2d7397da8c26620a8930dd12b6dff42e43f537",
   "type": "module",
   "description": "GraphQL plugin for ESLint",
   "repository": "https://github.com/dimaMachina/graphql-eslint",
@@ -20,6 +20,16 @@
         "types": "./esm/index.d.ts",
         "default": "./esm/index.js"
       }
+    },
+    "./*": {
+      "require": {
+        "types": "./cjs/*.d.cts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./esm/*.d.ts",
+        "default": "./esm/*.js"
+      }
     }
   },
   "types": "esm/index.d.ts",