@graphql-eslint/eslint-plugin 3.19.3-alpha-20230702093957-98f7783 → 3.20.0-alpha-20230703154330-0d51273

package/cjs/types-e3367e3c.d.ts

@@ -0,0 +1,129 @@
+import { GraphQLParseOptions } from '@graphql-tools/utils';
+import { RuleTester, Linter, Rule, AST } from 'eslint';
+import * as ESTree from 'estree';
+import { FragmentDefinitionNode, OperationDefinitionNode, SelectionSetNode, OperationTypeNode, ASTKindToNode, GraphQLSchema } 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 GraphQLESLintRuleListener<WithTypeInfo extends boolean = false> = Record<string, any> & {
+    [K in keyof ASTKindToNode]?: (node: GraphQLESTreeNode<ASTKindToNode[K], WithTypeInfo>) => void;
+};
+type GraphQLValidTestCase<Options = []> = Omit<RuleTester.ValidTestCase, 'options' | 'parserOptions'> & {
+    options?: Options;
+    parserOptions?: Omit<ParserOptions, 'filePath'>;
+};
+type GraphQLInvalidTestCase<T = []> = GraphQLValidTestCase<T> & {
+    errors: (RuleTester.TestCaseError | string)[] | number;
+    output?: string | null;
+};
+type RuleTesterConfig = {
+    parser: string;
+    parserOptions: Omit<ParserOptions, 'filePath'>;
+};
+declare class GraphQLRuleTester extends RuleTester {
+    config: RuleTesterConfig;
+    constructor(parserOptions?: Omit<ParserOptions, 'filePath'>);
+    fromMockFile(path: string): string;
+    runGraphQLTests<Options, WithTypeInfo extends boolean = false>(ruleId: string, rule: GraphQLESLintRule<Options, WithTypeInfo>, tests: {
+        valid: (GraphQLValidTestCase<Options> | string)[];
+        invalid: GraphQLInvalidTestCase<Options>[];
+    }): void;
+}
+
+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 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, GraphQLESLintRuleListener as G, OmitRecursively as O, ParserOptions as P, ReportDescriptor as R, Schema as S, ValueOf as V, GraphQLValidTestCase as a, GraphQLInvalidTestCase as b, GraphQLRuleTester as c, Pointer as d, ParserServices as e, GraphQLESLintParseResult as f, GraphQLESLintRuleContext as g, RuleDocsInfo as h, GraphQLESLintRule as i, SiblingOperations as j, OperationSource as k, getSiblings as l };

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, f as GraphQLESLintParseResult, i as GraphQLESLintRule, g as GraphQLESLintRuleContext, O as OmitRecursively, P as ParserOptions, e as ParserServices, d as Pointer, R as ReportDescriptor, h as RuleDocsInfo, S as Schema, V as ValueOf } from './types-e3367e3c.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 { g as GraphQLESLintRuleContext, j as SiblingOperations } from './types-e3367e3c.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

@@ -1,147 +1,204 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNodeName = exports.displayNodeName = exports.truthy = exports.englishJoinWords = exports.ARRAY_DEFAULT_OPTIONS = exports.REPORT_ON_FIRST_CHARACTER = exports.getLocation = exports.convertCase = exports.camelCase = exports.pascalCase = exports.TYPES_KINDS = exports.getTypeName = exports.CWD = exports.VIRTUAL_DOCUMENT_REGEX = exports.normalizePath = exports.logger = exports.requireGraphQLSchemaFromContext = exports.requireSiblingsOperations = void 0;
-const tslib_1 = require("tslib");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const graphql_1 = require("graphql");
-const lodash_lowercase_1 = tslib_1.__importDefault(require("lodash.lowercase"));
+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;
+  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;
 }
-exports.requireSiblingsOperations = requireSiblingsOperations;
 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 { 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;
 }
-exports.requireGraphQLSchemaFromContext = requireGraphQLSchemaFromContext;
-exports.logger = {
-    error: (...args) => 
+const logger = {
+  error: (...args) => (
     // eslint-disable-next-line no-console
-    console.error(chalk_1.default.red('error'), '[graphql-eslint]', (0, chalk_1.default)(...args)),
-    warn: (...args) => 
+    console.error(import_chalk.default.red("error"), "[graphql-eslint]", (0, import_chalk.default)(...args))
+  ),
+  warn: (...args) => (
     // eslint-disable-next-line no-console
-    console.warn(chalk_1.default.yellow('warning'), '[graphql-eslint]', (0, chalk_1.default)(...args)),
+    console.warn(import_chalk.default.yellow("warning"), "[graphql-eslint]", (0, import_chalk.default)(...args))
+  )
 };
-const normalizePath = (path) => (path || '').replace(/\\/g, '/');
-exports.normalizePath = normalizePath;
-exports.VIRTUAL_DOCUMENT_REGEX = /\/\d+_document.graphql$/;
-exports.CWD = process.cwd();
-const getTypeName = (node) => 'type' in node ? (0, exports.getTypeName)(node.type) : 'name' in node && node.name ? node.name.value : '';
-exports.getTypeName = getTypeName;
-exports.TYPES_KINDS = [
-    graphql_1.Kind.OBJECT_TYPE_DEFINITION,
-    graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
-    graphql_1.Kind.ENUM_TYPE_DEFINITION,
-    graphql_1.Kind.SCALAR_TYPE_DEFINITION,
-    graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
-    graphql_1.Kind.UNION_TYPE_DEFINITION,
+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, lodash_lowercase_1.default)(str)
-    .split(' ')
-    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-    .join('');
-exports.pascalCase = pascalCase;
+const pascalCase = (str) => (0, import_lodash.default)(str).split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
 const camelCase = (str) => {
-    const result = (0, exports.pascalCase)(str);
-    return result.charAt(0).toLowerCase() + result.slice(1);
+  const result = pascalCase(str);
+  return result.charAt(0).toLowerCase() + result.slice(1);
 };
-exports.camelCase = camelCase;
 const convertCase = (style, str) => {
-    switch (style) {
-        case 'camelCase':
-            return (0, exports.camelCase)(str);
-        case 'PascalCase':
-            return (0, exports.pascalCase)(str);
-        case 'snake_case':
-            return (0, lodash_lowercase_1.default)(str).replace(/ /g, '_');
-        case 'UPPER_CASE':
-            return (0, lodash_lowercase_1.default)(str).replace(/ /g, '_').toUpperCase();
-        case 'kebab-case':
-            return (0, lodash_lowercase_1.default)(str).replace(/ /g, '-');
-    }
+  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, "-");
+  }
 };
-exports.convertCase = convertCase;
-function getLocation(start, fieldName = '') {
-    const { line, column } = start;
-    return {
-        start: {
-            line,
-            column,
-        },
-        end: {
-            line,
-            column: column + fieldName.length,
-        },
-    };
-}
-exports.getLocation = getLocation;
-exports.REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 };
-exports.ARRAY_DEFAULT_OPTIONS = {
-    type: 'array',
-    uniqueItems: true,
-    minItems: 1,
-    items: {
-        type: 'string',
+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);
-exports.englishJoinWords = englishJoinWords;
+const englishJoinWords = (words) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(words);
 function truthy(value) {
-    return !!value;
+  return !!value;
 }
-exports.truthy = truthy;
 const DisplayNodeNameMap = {
-    [graphql_1.Kind.OBJECT_TYPE_DEFINITION]: 'type',
-    [graphql_1.Kind.OBJECT_TYPE_EXTENSION]: 'type',
-    [graphql_1.Kind.INTERFACE_TYPE_DEFINITION]: 'interface',
-    [graphql_1.Kind.INTERFACE_TYPE_EXTENSION]: 'interface',
-    [graphql_1.Kind.ENUM_TYPE_DEFINITION]: 'enum',
-    [graphql_1.Kind.ENUM_TYPE_EXTENSION]: 'enum',
-    [graphql_1.Kind.SCALAR_TYPE_DEFINITION]: 'scalar',
-    [graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION]: 'input',
-    [graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION]: 'input',
-    [graphql_1.Kind.UNION_TYPE_DEFINITION]: 'union',
-    [graphql_1.Kind.UNION_TYPE_EXTENSION]: 'union',
-    [graphql_1.Kind.DIRECTIVE_DEFINITION]: 'directive',
-    [graphql_1.Kind.FIELD_DEFINITION]: 'field',
-    [graphql_1.Kind.ENUM_VALUE_DEFINITION]: 'enum value',
-    [graphql_1.Kind.INPUT_VALUE_DEFINITION]: 'input value',
-    [graphql_1.Kind.ARGUMENT]: 'argument',
-    [graphql_1.Kind.VARIABLE]: 'variable',
-    [graphql_1.Kind.FRAGMENT_DEFINITION]: 'fragment',
-    [graphql_1.Kind.OPERATION_DEFINITION]: 'operation',
-    [graphql_1.Kind.FIELD]: 'field',
+  [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 === graphql_1.Kind.OPERATION_DEFINITION ? node.operation : DisplayNodeNameMap[node.kind]} "${('alias' in node && ((_a = node.alias) === null || _a === void 0 ? void 0 : _a.value)) || ('name' in node && ((_b = node.name) === null || _b === void 0 ? void 0 : _b.value))}"`;
+  return `${node.kind === import_graphql.Kind.OPERATION_DEFINITION ? node.operation : DisplayNodeNameMap[node.kind]} "${"alias" in node && node.alias?.value || "name" in node && node.name?.value}"`;
 }
-exports.displayNodeName = displayNodeName;
 function getNodeName(node) {
-    switch (node.kind) {
-        case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-        case graphql_1.Kind.OBJECT_TYPE_EXTENSION:
-        case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
-        case graphql_1.Kind.ENUM_TYPE_DEFINITION:
-        case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
-        case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-        case graphql_1.Kind.UNION_TYPE_DEFINITION:
-        case graphql_1.Kind.DIRECTIVE_DEFINITION:
-            return displayNodeName(node);
-        case graphql_1.Kind.FIELD_DEFINITION:
-        case graphql_1.Kind.INPUT_VALUE_DEFINITION:
-        case graphql_1.Kind.ENUM_VALUE_DEFINITION:
-            return `${displayNodeName(node)} in ${displayNodeName(node.parent)}`;
-        case graphql_1.Kind.OPERATION_DEFINITION:
-            return node.name ? displayNodeName(node) : node.operation;
-    }
-    return '';
+  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 "";
 }
-exports.getNodeName = getNodeName;
+// 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/{typings/cache.d.cts → esm/cache.d.mts}

@@ -1,4 +1,4 @@
-export declare class ModuleCache<T, K = any> {
+declare class ModuleCache<T, K = any> {
     map: Map<K, {
         lastSeen: [number, number];
         result: T;
@@ -8,3 +8,5 @@ export declare class ModuleCache<T, K = any> {
         lifetime: number;
     }): T | void;
 }
+
+export { ModuleCache };

package/esm/cache.js

@@ -1,26 +1,28 @@
-// Based on the `eslint-plugin-import`'s cache
-// https://github.com/import-js/eslint-plugin-import/blob/main/utils/ModuleCache.js
-import debugFactory from 'debug';
-const log = debugFactory('graphql-eslint:ModuleCache');
-export class ModuleCache {
-    constructor() {
-        this.map = new Map();
+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;
     }
-    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;
-        // check freshness
-        if (process.env.NODE /* don't check for ESLint CLI */ ||
-            process.hrtime(lastSeen)[0] < settings.lifetime) {
-            return result;
-        }
+    const { lastSeen, result } = value;
+    if (process.env.NODE || process.hrtime(lastSeen)[0] < settings.lifetime) {
+      return result;
     }
+  }
 }
+export {
+  ModuleCache
+};

package/{typings/configs/index.d.cts → esm/configs/index.d.mts}

@@ -1,4 +1,4 @@
-export declare const configs: {
+declare const configs: {
     'schema-recommended': {
         parser: string;
         plugins: string[];
@@ -144,3 +144,5 @@ export declare const configs: {
         };
     };
 };
+
+export { configs };

package/esm/configs/index.js

@@ -1,12 +1,15 @@
-import operationsAllConfig from './operations-all.js';
-import operationsRecommendedConfig from './operations-recommended.js';
-import relayConfig from './relay.js';
-import schemaAllConfig from './schema-all.js';
-import schemaRecommendedConfig from './schema-recommended.js';
-export const configs = {
-    'schema-recommended': schemaRecommendedConfig,
-    'schema-all': schemaAllConfig,
-    'operations-recommended': operationsRecommendedConfig,
-    'operations-all': operationsAllConfig,
-    relay: relayConfig,
+import operationsAllConfig from "./operations-all.js";
+import operationsRecommendedConfig from "./operations-recommended.js";
+import relayConfig from "./relay.js";
+import schemaAllConfig from "./schema-all.js";
+import schemaRecommendedConfig from "./schema-recommended.js";
+const configs = {
+  "schema-recommended": schemaRecommendedConfig,
+  "schema-all": schemaAllConfig,
+  "operations-recommended": operationsRecommendedConfig,
+  "operations-all": operationsAllConfig,
+  relay: relayConfig
+};
+export {
+  configs
 };

package/{typings/configs/operations-all.d.cts → esm/configs/operations-all.d.mts}

@@ -18,4 +18,5 @@ declare const _default: {
         '@graphql-eslint/unique-operation-name': string;
     };
 };
-export default _default;
+
+export { _default as default };