@graphql-eslint/eslint-plugin 4.0.0-alpha-20220821140530-e968cfc → 4.0.0-alpha-20230801163310-8bc4340

package/cjs/schema.js

@@ -0,0 +1,65 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_exports = {};
+__export(schema_exports, {
+  getSchema: () => getSchema
+});
+module.exports = __toCommonJS(schema_exports);
+var import_debug = __toESM(require("debug"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_graphql = require("graphql");
+var import_cache = require("./cache.js");
+const schemaCache = new import_cache.ModuleCache();
+const debug = (0, import_debug.default)("graphql-eslint:schema");
+function getSchema(project, schemaOptions) {
+  const schemaKey = project.schema;
+  if (!schemaKey) {
+    return null;
+  }
+  const cache = schemaCache.get(schemaKey);
+  if (cache) {
+    return cache;
+  }
+  debug("Loading schema from %o", project.schema);
+  const schema = project.loadSchemaSync(project.schema, "GraphQLSchema", {
+    ...schemaOptions,
+    pluckConfig: project.extensions.pluckConfig
+  });
+  if (debug.enabled) {
+    debug("Schema loaded: %o", schema instanceof import_graphql.GraphQLSchema);
+    const schemaPaths = import_fast_glob.default.sync(project.schema, { absolute: true });
+    debug("Schema pointers %O", schemaPaths);
+  }
+  schemaCache.set(schemaKey, schema);
+  return schema;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSchema
+});

package/cjs/siblings.d.ts

@@ -0,0 +1,8 @@
+import 'graphql';
+import 'graphql-config';
+export { F as FragmentSource, h as OperationSource, g as SiblingOperations, i as getSiblings } from './types-8d5f4ae0.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'json-schema-to-ts';
+import './estree-converter/types.js';

package/cjs/siblings.js

@@ -0,0 +1,136 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var siblings_exports = {};
+__export(siblings_exports, {
+  getSiblings: () => getSiblings
+});
+module.exports = __toCommonJS(siblings_exports);
+var import_utils = require("@graphql-tools/utils");
+var import_graphql = require("graphql");
+var import_documents = require("./documents.js");
+var import_utils2 = require("./utils.js");
+const siblingOperationsCache = /* @__PURE__ */ new Map();
+function getSiblings(project, documents) {
+  const siblings = project ? (0, import_documents.getDocuments)(project) : typeof documents === "string" ? [(0, import_utils.parseGraphQLSDL)("operation.graphql", documents, { noLocation: true })] : [];
+  if (siblings.length === 0) {
+    let printed = false;
+    const noopWarn = () => {
+      if (!printed) {
+        import_utils2.logger.warn(
+          'getSiblingOperations was called without any operations. Make sure to set "parserOptions.operations" to make this feature available!'
+        );
+        printed = true;
+      }
+      return [];
+    };
+    return {
+      available: false,
+      getFragment: noopWarn,
+      getFragments: noopWarn,
+      getFragmentByType: noopWarn,
+      getFragmentsInUse: noopWarn,
+      getOperation: noopWarn,
+      getOperations: noopWarn,
+      getOperationByType: noopWarn
+    };
+  }
+  const value = siblingOperationsCache.get(siblings);
+  if (value) {
+    return value;
+  }
+  let fragmentsCache = null;
+  const getFragments = () => {
+    var _a;
+    if (fragmentsCache === null) {
+      const result = [];
+      for (const source of siblings) {
+        for (const definition of ((_a = source.document) == null ? void 0 : _a.definitions) || []) {
+          if (definition.kind === import_graphql.Kind.FRAGMENT_DEFINITION) {
+            result.push({
+              filePath: source.location,
+              document: definition
+            });
+          }
+        }
+      }
+      fragmentsCache = result;
+    }
+    return fragmentsCache;
+  };
+  let cachedOperations = null;
+  const getOperations = () => {
+    var _a;
+    if (cachedOperations === null) {
+      const result = [];
+      for (const source of siblings) {
+        for (const definition of ((_a = source.document) == null ? void 0 : _a.definitions) || []) {
+          if (definition.kind === import_graphql.Kind.OPERATION_DEFINITION) {
+            result.push({
+              filePath: source.location,
+              document: definition
+            });
+          }
+        }
+      }
+      cachedOperations = result;
+    }
+    return cachedOperations;
+  };
+  const getFragment = (name) => getFragments().filter((f) => f.document.name.value === name);
+  const collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => {
+    (0, import_graphql.visit)(selectable, {
+      FragmentSpread(spread) {
+        const fragmentName = spread.name.value;
+        const [fragment] = getFragment(fragmentName);
+        if (!fragment) {
+          import_utils2.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);
+          }
+        }
+      }
+    });
+    return collected;
+  };
+  const siblingOperations = {
+    available: true,
+    getFragment,
+    getFragments,
+    getFragmentByType: (typeName) => getFragments().filter((f) => f.document.typeCondition.name.value === typeName),
+    getFragmentsInUse: (selectable, recursive = true) => Array.from(collectFragments(selectable, recursive).values()),
+    getOperation: (name) => getOperations().filter((o) => {
+      var _a;
+      return ((_a = o.document.name) == null ? void 0 : _a.value) === name;
+    }),
+    getOperations,
+    getOperationByType: (type) => getOperations().filter((o) => o.document.operation === type)
+  };
+  siblingOperationsCache.set(siblings, siblingOperations);
+  return siblingOperations;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSiblings
+});

package/cjs/types-8d5f4ae0.d.ts

@@ -0,0 +1,107 @@
+import { GraphQLParseOptions } from '@graphql-tools/utils';
+import { Linter, Rule, AST } from 'eslint';
+import * as ESTree from 'estree';
+import { FragmentDefinitionNode, OperationDefinitionNode, SelectionSetNode, OperationTypeNode, GraphQLSchema, ASTKindToNode } from 'graphql';
+import { GraphQLProjectConfig, IExtensions, IGraphQLProject } from 'graphql-config';
+import { JSONSchema } from 'json-schema-to-ts';
+import { GraphQLESTreeNode } from './estree-converter/types.js';
+
+type FragmentSource = {
+    filePath: string;
+    document: FragmentDefinitionNode;
+};
+type OperationSource = {
+    filePath: string;
+    document: OperationDefinitionNode;
+};
+type SiblingOperations = {
+    available: boolean;
+    getFragment(fragmentName: string): FragmentSource[];
+    getFragments(): FragmentSource[];
+    getFragmentByType(typeName: string): FragmentSource[];
+    getFragmentsInUse(baseOperation: FragmentDefinitionNode | OperationDefinitionNode | SelectionSetNode, recursive?: boolean): FragmentDefinitionNode[];
+    getOperation(operationName: string): OperationSource[];
+    getOperations(): OperationSource[];
+    getOperationByType(operationType: OperationTypeNode): OperationSource[];
+};
+declare function getSiblings(project?: GraphQLProjectConfig, documents?: ParserOptions['documents']): SiblingOperations;
+
+type Schema = GraphQLSchema | null;
+type Pointer = string | string[];
+interface ParserOptions {
+    schema?: Pointer | Record<string, {
+        headers: Record<string, string>;
+    }>;
+    documents?: Pointer;
+    extensions?: IExtensions;
+    include?: Pointer;
+    exclude?: Pointer;
+    projects?: Record<string, IGraphQLProject>;
+    schemaOptions?: Omit<GraphQLParseOptions, 'assumeValidSDL'> & {
+        headers: Record<string, string>;
+    };
+    graphQLParserOptions?: Omit<GraphQLParseOptions, 'noLocation'>;
+    skipGraphQLConfig?: boolean;
+    filePath: string;
+    /** @deprecated Use `documents` instead */
+    operations?: Pointer;
+}
+type ParserServices = {
+    schema: Schema;
+    siblingOperations: SiblingOperations;
+};
+type GraphQLESLintParseResult = Linter.ESLintParseResult & {
+    services: ParserServices;
+};
+type Location = AST.SourceLocation | ESTree.Position;
+type ReportDescriptorLocation = {
+    loc: Location;
+} | {
+    node: {
+        loc: Location;
+    };
+};
+type ReportDescriptor = ReportDescriptorLocation & Rule.ReportDescriptorMessage & Rule.ReportDescriptorOptions;
+type GraphQLESLintRuleContext<Options = any[]> = Omit<Rule.RuleContext, 'options' | 'parserServices' | 'report'> & {
+    options: Options;
+    parserServices: ParserServices;
+    report(descriptor: ReportDescriptor): void;
+};
+type CategoryType = 'Operations' | 'Schema';
+type RuleMetaDataDocs = Required<Rule.RuleMetaData>['docs'];
+type RuleDocsInfo<T> = Omit<RuleMetaDataDocs, 'category' | 'suggestion'> & {
+    category: CategoryType | CategoryType[];
+    requiresSchema?: true;
+    requiresSiblings?: true;
+    examples?: {
+        title: string;
+        code: string;
+        usage?: T;
+    }[];
+    configOptions?: T | {
+        schema?: T;
+        operations?: T;
+    };
+    graphQLJSRuleName?: string;
+    isDisabledForAllConfig?: true;
+};
+type GraphQLESLintRuleListener<WithTypeInfo extends boolean = false> = Record<string, any> & {
+    [K in keyof ASTKindToNode]?: (node: GraphQLESTreeNode<ASTKindToNode[K], WithTypeInfo>) => void;
+};
+type GraphQLESLintRule<Options = [], WithTypeInfo extends boolean = false> = {
+    meta: Omit<Rule.RuleMetaData, 'docs' | 'schema'> & {
+        docs?: RuleDocsInfo<Options>;
+        schema: Readonly<JSONSchema> | [];
+    };
+    create(context: GraphQLESLintRuleContext<Options>): GraphQLESLintRuleListener<WithTypeInfo>;
+};
+type ValueOf<T> = T[keyof T];
+type Id<T> = {
+    [P in keyof T]: T[P];
+} & {};
+type OmitDistributive<T, K extends PropertyKey> = T extends object ? Id<OmitRecursively<T, K>> : T;
+type OmitRecursively<T extends object, K extends PropertyKey> = Omit<{
+    [P in keyof T]: OmitDistributive<T[P], K>;
+}, K>;
+
+export { CategoryType as C, FragmentSource as F, GraphQLESLintParseResult as G, OmitRecursively as O, ParserOptions as P, ReportDescriptor as R, Schema as S, ValueOf as V, Pointer as a, ParserServices as b, GraphQLESLintRuleContext as c, RuleDocsInfo as d, GraphQLESLintRuleListener as e, GraphQLESLintRule as f, SiblingOperations as g, OperationSource as h, getSiblings as i };

package/cjs/types.d.ts

@@ -0,0 +1,8 @@
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import 'json-schema-to-ts';
+export { C as CategoryType, G as GraphQLESLintParseResult, f as GraphQLESLintRule, c as GraphQLESLintRuleContext, e as GraphQLESLintRuleListener, O as OmitRecursively, P as ParserOptions, b as ParserServices, a as Pointer, R as ReportDescriptor, d as RuleDocsInfo, S as Schema, V as ValueOf } from './types-8d5f4ae0.js';
+import './estree-converter/types.js';

package/cjs/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/cjs/utils.d.ts

@@ -0,0 +1,44 @@
+import { AST } from 'eslint';
+import { Position } from 'estree';
+import { GraphQLSchema, ASTNode, Kind } from 'graphql';
+import { c as GraphQLESLintRuleContext, g as SiblingOperations } from './types-8d5f4ae0.js';
+import { GraphQLESTreeNode } from './estree-converter/types.js';
+import '@graphql-tools/utils';
+import 'graphql-config';
+import 'json-schema-to-ts';
+
+declare function requireSiblingsOperations(ruleId: string, context: GraphQLESLintRuleContext): SiblingOperations | never;
+declare function requireGraphQLSchemaFromContext(ruleId: string, context: GraphQLESLintRuleContext): GraphQLSchema | never;
+declare const logger: {
+    error: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+};
+declare const normalizePath: (path: string) => string;
+declare const VIRTUAL_DOCUMENT_REGEX: RegExp;
+declare const CWD: string;
+declare const getTypeName: (node: ASTNode) => string;
+declare const TYPES_KINDS: readonly [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];
+type CaseStyle = 'camelCase' | 'kebab-case' | 'PascalCase' | 'snake_case' | 'UPPER_CASE';
+declare const pascalCase: (str: string) => string;
+declare const camelCase: (str: string) => string;
+declare const convertCase: (style: CaseStyle, str: string) => string;
+declare function getLocation(start: Position, fieldName?: string): AST.SourceLocation;
+declare const REPORT_ON_FIRST_CHARACTER: {
+    column: number;
+    line: number;
+};
+declare const ARRAY_DEFAULT_OPTIONS: {
+    readonly type: "array";
+    readonly uniqueItems: true;
+    readonly minItems: 1;
+    readonly items: {
+        readonly type: "string";
+    };
+};
+declare const englishJoinWords: (words: string[]) => string;
+type Truthy<T> = T extends '' | 0 | false | null | undefined ? never : T;
+declare function truthy<T>(value: T): value is Truthy<T>;
+declare function displayNodeName(node: GraphQLESTreeNode<ASTNode>): string;
+declare function getNodeName(node: GraphQLESTreeNode<ASTNode>): string;
+
+export { ARRAY_DEFAULT_OPTIONS, CWD, CaseStyle, REPORT_ON_FIRST_CHARACTER, TYPES_KINDS, VIRTUAL_DOCUMENT_REGEX, camelCase, convertCase, displayNodeName, englishJoinWords, getLocation, getNodeName, getTypeName, logger, normalizePath, pascalCase, requireGraphQLSchemaFromContext, requireSiblingsOperations, truthy };

package/cjs/utils.js

@@ -0,0 +1,205 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  ARRAY_DEFAULT_OPTIONS: () => ARRAY_DEFAULT_OPTIONS,
+  CWD: () => CWD,
+  REPORT_ON_FIRST_CHARACTER: () => REPORT_ON_FIRST_CHARACTER,
+  TYPES_KINDS: () => TYPES_KINDS,
+  VIRTUAL_DOCUMENT_REGEX: () => VIRTUAL_DOCUMENT_REGEX,
+  camelCase: () => camelCase,
+  convertCase: () => convertCase,
+  displayNodeName: () => displayNodeName,
+  englishJoinWords: () => englishJoinWords,
+  getLocation: () => getLocation,
+  getNodeName: () => getNodeName,
+  getTypeName: () => getTypeName,
+  logger: () => logger,
+  normalizePath: () => normalizePath,
+  pascalCase: () => pascalCase,
+  requireGraphQLSchemaFromContext: () => requireGraphQLSchemaFromContext,
+  requireSiblingsOperations: () => requireSiblingsOperations,
+  truthy: () => truthy
+});
+module.exports = __toCommonJS(utils_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_graphql = require("graphql");
+var import_lodash = __toESM(require("lodash.lowercase"));
+function requireSiblingsOperations(ruleId, context) {
+  const { siblingOperations } = context.parserServices;
+  if (!siblingOperations.available) {
+    throw new Error(
+      `Rule \`${ruleId}\` requires \`parserOptions.operations\` to be set and loaded. See https://bit.ly/graphql-eslint-operations for more info`
+    );
+  }
+  return siblingOperations;
+}
+function requireGraphQLSchemaFromContext(ruleId, context) {
+  const { schema } = context.parserServices;
+  if (!schema) {
+    throw new Error(
+      `Rule \`${ruleId}\` requires \`parserOptions.schema\` to be set and loaded. See https://bit.ly/graphql-eslint-schema for more info`
+    );
+  }
+  return schema;
+}
+const logger = {
+  error: (...args) => (
+    // eslint-disable-next-line no-console
+    console.error(import_chalk.default.red("error"), "[graphql-eslint]", (0, import_chalk.default)(...args))
+  ),
+  warn: (...args) => (
+    // eslint-disable-next-line no-console
+    console.warn(import_chalk.default.yellow("warning"), "[graphql-eslint]", (0, import_chalk.default)(...args))
+  )
+};
+const normalizePath = (path) => (path || "").replace(/\\/g, "/");
+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 = [
+  import_graphql.Kind.OBJECT_TYPE_DEFINITION,
+  import_graphql.Kind.INTERFACE_TYPE_DEFINITION,
+  import_graphql.Kind.ENUM_TYPE_DEFINITION,
+  import_graphql.Kind.SCALAR_TYPE_DEFINITION,
+  import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+  import_graphql.Kind.UNION_TYPE_DEFINITION
+];
+const pascalCase = (str) => (0, import_lodash.default)(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);
+};
+const convertCase = (style, str) => {
+  switch (style) {
+    case "camelCase":
+      return camelCase(str);
+    case "PascalCase":
+      return pascalCase(str);
+    case "snake_case":
+      return (0, import_lodash.default)(str).replace(/ /g, "_");
+    case "UPPER_CASE":
+      return (0, import_lodash.default)(str).replace(/ /g, "_").toUpperCase();
+    case "kebab-case":
+      return (0, import_lodash.default)(str).replace(/ /g, "-");
+  }
+};
+function getLocation(start, fieldName = "") {
+  const { line, column } = start;
+  return {
+    start: {
+      line,
+      column
+    },
+    end: {
+      line,
+      column: column + fieldName.length
+    }
+  };
+}
+const REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 };
+const ARRAY_DEFAULT_OPTIONS = {
+  type: "array",
+  uniqueItems: true,
+  minItems: 1,
+  items: {
+    type: "string"
+  }
+};
+const englishJoinWords = (words) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(words);
+function truthy(value) {
+  return !!value;
+}
+const DisplayNodeNameMap = {
+  [import_graphql.Kind.OBJECT_TYPE_DEFINITION]: "type",
+  [import_graphql.Kind.OBJECT_TYPE_EXTENSION]: "type",
+  [import_graphql.Kind.INTERFACE_TYPE_DEFINITION]: "interface",
+  [import_graphql.Kind.INTERFACE_TYPE_EXTENSION]: "interface",
+  [import_graphql.Kind.ENUM_TYPE_DEFINITION]: "enum",
+  [import_graphql.Kind.ENUM_TYPE_EXTENSION]: "enum",
+  [import_graphql.Kind.SCALAR_TYPE_DEFINITION]: "scalar",
+  [import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION]: "input",
+  [import_graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION]: "input",
+  [import_graphql.Kind.UNION_TYPE_DEFINITION]: "union",
+  [import_graphql.Kind.UNION_TYPE_EXTENSION]: "union",
+  [import_graphql.Kind.DIRECTIVE_DEFINITION]: "directive",
+  [import_graphql.Kind.FIELD_DEFINITION]: "field",
+  [import_graphql.Kind.ENUM_VALUE_DEFINITION]: "enum value",
+  [import_graphql.Kind.INPUT_VALUE_DEFINITION]: "input value",
+  [import_graphql.Kind.ARGUMENT]: "argument",
+  [import_graphql.Kind.VARIABLE]: "variable",
+  [import_graphql.Kind.FRAGMENT_DEFINITION]: "fragment",
+  [import_graphql.Kind.OPERATION_DEFINITION]: "operation",
+  [import_graphql.Kind.FIELD]: "field"
+};
+function displayNodeName(node) {
+  var _a, _b;
+  return `${node.kind === import_graphql.Kind.OPERATION_DEFINITION ? node.operation : DisplayNodeNameMap[node.kind]} "${"alias" in node && ((_a = node.alias) == null ? void 0 : _a.value) || "name" in node && ((_b = node.name) == null ? void 0 : _b.value)}"`;
+}
+function getNodeName(node) {
+  switch (node.kind) {
+    case import_graphql.Kind.OBJECT_TYPE_DEFINITION:
+    case import_graphql.Kind.OBJECT_TYPE_EXTENSION:
+    case import_graphql.Kind.INTERFACE_TYPE_DEFINITION:
+    case import_graphql.Kind.ENUM_TYPE_DEFINITION:
+    case import_graphql.Kind.SCALAR_TYPE_DEFINITION:
+    case import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+    case import_graphql.Kind.UNION_TYPE_DEFINITION:
+    case import_graphql.Kind.DIRECTIVE_DEFINITION:
+      return displayNodeName(node);
+    case import_graphql.Kind.FIELD_DEFINITION:
+    case import_graphql.Kind.INPUT_VALUE_DEFINITION:
+    case import_graphql.Kind.ENUM_VALUE_DEFINITION:
+      return `${displayNodeName(node)} in ${displayNodeName(node.parent)}`;
+    case import_graphql.Kind.OPERATION_DEFINITION:
+      return node.name ? displayNodeName(node) : node.operation;
+  }
+  return "";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ARRAY_DEFAULT_OPTIONS,
+  CWD,
+  REPORT_ON_FIRST_CHARACTER,
+  TYPES_KINDS,
+  VIRTUAL_DOCUMENT_REGEX,
+  camelCase,
+  convertCase,
+  displayNodeName,
+  englishJoinWords,
+  getLocation,
+  getNodeName,
+  getTypeName,
+  logger,
+  normalizePath,
+  pascalCase,
+  requireGraphQLSchemaFromContext,
+  requireSiblingsOperations,
+  truthy
+});

package/esm/cache.d.mts

@@ -0,0 +1,12 @@
+declare class ModuleCache<T, K = any> {
+    map: Map<K, {
+        lastSeen: [number, number];
+        result: T;
+    }>;
+    set(cacheKey: K, result: T): void;
+    get(cacheKey: K, settings?: {
+        lifetime: number;
+    }): T | void;
+}
+
+export { ModuleCache };

package/esm/cache.js

@@ -0,0 +1,29 @@
+import "./chunk-BMTV3EA2.js";
+import debugFactory from "debug";
+const log = debugFactory("graphql-eslint:ModuleCache");
+class ModuleCache {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+  set(cacheKey, result) {
+    this.map.set(cacheKey, { lastSeen: process.hrtime(), result });
+    log("setting entry for", cacheKey);
+  }
+  get(cacheKey, settings = {
+    lifetime: 10
+    /* seconds */
+  }) {
+    const value = this.map.get(cacheKey);
+    if (!value) {
+      log("cache miss for", cacheKey);
+      return;
+    }
+    const { lastSeen, result } = value;
+    if (process.env.NODE || process.hrtime(lastSeen)[0] < settings.lifetime) {
+      return result;
+    }
+  }
+}
+export {
+  ModuleCache
+};

package/esm/chunk-BMTV3EA2.js

@@ -0,0 +1,8 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+export {
+  __commonJS
+};