@graphql-eslint/eslint-plugin 4.0.0-alpha.1 → 4.0.0-alpha.10

package/cjs/utils.js

@@ -1,49 +1,6 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: !0 });
-}, __copyProps = (to, from, except, desc) => {
-  if (from && typeof from == "object" || typeof from == "function")
-    for (let key of __getOwnPropNames(from))
-      !__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: !0 }) : target,
-  mod
-)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), 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_graphql = require("graphql"), import_lodash = __toESM(require("lodash.lowercase"));
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }require('./chunk-UIAXBAMD.js');
+var _graphql = require('graphql');
+var _lodashlowercase = require('lodash.lowercase'); var _lodashlowercase2 = _interopRequireDefault(_lodashlowercase);
 function requireSiblingsOperations(ruleId, context) {
   const { siblingOperations } = context.sourceCode.parserServices;
   if (!siblingOperations.available)
@@ -63,7 +20,7 @@ function requireGraphQLSchemaFromContext(ruleId, context) {
 const chalk = {
   red: (str) => `\x1B[31m${str}\x1B[39m`,
   yellow: (str) => `\x1B[33m${str}\x1B[39m`
-}, logger = {
+}, logger = exports.logger = {
   error: (...args) => (
     // eslint-disable-next-line no-console
     console.error(chalk.red("error"), "[graphql-eslint]", ...args)
@@ -72,28 +29,28 @@ const chalk = {
     // eslint-disable-next-line no-console
     console.warn(chalk.yellow("warning"), "[graphql-eslint]", ...args)
   )
-}, normalizePath = (path) => (path || "").replace(/\\/g, "/"), 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 = [
-  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
-], pascalCase = (str) => (0, import_lodash.default)(str).split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(""), camelCase = (str) => {
+}, slash = exports.slash = (path) => path.replaceAll("\\", "/"), VIRTUAL_DOCUMENT_REGEX = exports.VIRTUAL_DOCUMENT_REGEX = /[/\\]\d+_document.graphql$/, CWD = exports.CWD = process.cwd(), getTypeName = exports.getTypeName = (node) => "type" in node ? getTypeName(node.type) : "name" in node && node.name ? node.name.value : "", TYPES_KINDS = exports.TYPES_KINDS = [
+  _graphql.Kind.OBJECT_TYPE_DEFINITION,
+  _graphql.Kind.INTERFACE_TYPE_DEFINITION,
+  _graphql.Kind.ENUM_TYPE_DEFINITION,
+  _graphql.Kind.SCALAR_TYPE_DEFINITION,
+  _graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+  _graphql.Kind.UNION_TYPE_DEFINITION
+], pascalCase = exports.pascalCase = (str) => _lodashlowercase2.default.call(void 0, str).split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(""), camelCase = exports.camelCase = (str) => {
   const result = pascalCase(str);
   return result.charAt(0).toLowerCase() + result.slice(1);
-}, convertCase = (style, str) => {
+}, convertCase = exports.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, "_");
+      return _lodashlowercase2.default.call(void 0, str).replace(/ /g, "_");
     case "UPPER_CASE":
-      return (0, import_lodash.default)(str).replace(/ /g, "_").toUpperCase();
+      return _lodashlowercase2.default.call(void 0, str).replace(/ /g, "_").toUpperCase();
     case "kebab-case":
-      return (0, import_lodash.default)(str).replace(/ /g, "-");
+      return _lodashlowercase2.default.call(void 0, str).replace(/ /g, "-");
   }
 };
 function getLocation(start, fieldName = "") {
@@ -109,80 +66,102 @@ 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 }, ARRAY_DEFAULT_OPTIONS = exports.ARRAY_DEFAULT_OPTIONS = {
   type: "array",
   uniqueItems: !0,
   minItems: 1,
   items: {
     type: "string"
   }
-}, englishJoinWords = (words) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(words);
+}, englishJoinWords = exports.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"
+  [_graphql.Kind.ARGUMENT]: "argument",
+  [_graphql.Kind.BOOLEAN]: "boolean",
+  [_graphql.Kind.DIRECTIVE_DEFINITION]: "directive",
+  [_graphql.Kind.DIRECTIVE]: "directive",
+  [_graphql.Kind.DOCUMENT]: "document",
+  [_graphql.Kind.ENUM_TYPE_DEFINITION]: "enum",
+  [_graphql.Kind.ENUM_TYPE_EXTENSION]: "enum",
+  [_graphql.Kind.ENUM_VALUE_DEFINITION]: "enum value",
+  [_graphql.Kind.ENUM]: "enum",
+  [_graphql.Kind.FIELD_DEFINITION]: "field",
+  [_graphql.Kind.FIELD]: "field",
+  [_graphql.Kind.FLOAT]: "float",
+  [_graphql.Kind.FRAGMENT_DEFINITION]: "fragment",
+  [_graphql.Kind.FRAGMENT_SPREAD]: "fragment spread",
+  [_graphql.Kind.INLINE_FRAGMENT]: "inline fragment",
+  [_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION]: "input",
+  [_graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION]: "input",
+  [_graphql.Kind.INPUT_VALUE_DEFINITION]: "input value",
+  [_graphql.Kind.INT]: "int",
+  [_graphql.Kind.INTERFACE_TYPE_DEFINITION]: "interface",
+  [_graphql.Kind.INTERFACE_TYPE_EXTENSION]: "interface",
+  [_graphql.Kind.LIST_TYPE]: "list type",
+  [_graphql.Kind.LIST]: "list",
+  [_graphql.Kind.NAME]: "name",
+  [_graphql.Kind.NAMED_TYPE]: "named type",
+  [_graphql.Kind.NON_NULL_TYPE]: "non-null type",
+  [_graphql.Kind.NULL]: "null",
+  [_graphql.Kind.OBJECT_FIELD]: "object field",
+  [_graphql.Kind.OBJECT_TYPE_DEFINITION]: "type",
+  [_graphql.Kind.OBJECT_TYPE_EXTENSION]: "type",
+  [_graphql.Kind.OBJECT]: "object",
+  [_graphql.Kind.OPERATION_DEFINITION]: "operation",
+  [_graphql.Kind.OPERATION_TYPE_DEFINITION]: "operation type",
+  [_graphql.Kind.SCALAR_TYPE_DEFINITION]: "scalar",
+  [_graphql.Kind.SCALAR_TYPE_EXTENSION]: "scalar",
+  [_graphql.Kind.SCHEMA_DEFINITION]: "schema",
+  [_graphql.Kind.SCHEMA_EXTENSION]: "schema",
+  [_graphql.Kind.SELECTION_SET]: "selection set",
+  [_graphql.Kind.STRING]: "string",
+  [_graphql.Kind.UNION_TYPE_DEFINITION]: "union",
+  [_graphql.Kind.UNION_TYPE_EXTENSION]: "union",
+  [_graphql.Kind.VARIABLE_DEFINITION]: "variable",
+  [_graphql.Kind.VARIABLE]: "variable"
 };
 function displayNodeName(node) {
-  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}"`;
+  return `${node.kind === _graphql.Kind.OPERATION_DEFINITION ? node.operation : DisplayNodeNameMap[node.kind]} "${"alias" in node && _optionalChain([node, 'access', _ => _.alias, 'optionalAccess', _2 => _2.value]) || "name" in node && _optionalChain([node, 'access', _3 => _3.name, 'optionalAccess', _4 => _4.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:
+    case _graphql.Kind.OBJECT_TYPE_DEFINITION:
+    case _graphql.Kind.OBJECT_TYPE_EXTENSION:
+    case _graphql.Kind.INTERFACE_TYPE_DEFINITION:
+    case _graphql.Kind.ENUM_TYPE_DEFINITION:
+    case _graphql.Kind.SCALAR_TYPE_DEFINITION:
+    case _graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+    case _graphql.Kind.UNION_TYPE_DEFINITION:
+    case _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:
+    case _graphql.Kind.FIELD_DEFINITION:
+    case _graphql.Kind.INPUT_VALUE_DEFINITION:
+    case _graphql.Kind.ENUM_VALUE_DEFINITION:
       return `${displayNodeName(node)} in ${displayNodeName(node.parent)}`;
-    case import_graphql.Kind.OPERATION_DEFINITION:
+    case _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
-});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ARRAY_DEFAULT_OPTIONS = ARRAY_DEFAULT_OPTIONS; exports.CWD = CWD; exports.REPORT_ON_FIRST_CHARACTER = REPORT_ON_FIRST_CHARACTER; exports.TYPES_KINDS = TYPES_KINDS; exports.VIRTUAL_DOCUMENT_REGEX = VIRTUAL_DOCUMENT_REGEX; exports.camelCase = camelCase; exports.convertCase = convertCase; exports.displayNodeName = displayNodeName; exports.englishJoinWords = englishJoinWords; exports.getLocation = getLocation; exports.getNodeName = getNodeName; exports.getTypeName = getTypeName; exports.logger = logger; exports.pascalCase = pascalCase; exports.requireGraphQLSchemaFromContext = requireGraphQLSchemaFromContext; exports.requireSiblingsOperations = requireSiblingsOperations; exports.slash = slash; exports.truthy = truthy;

package/{cjs → esm}/cache.d.ts

@@ -1,4 +1,4 @@
-declare class ModuleCache<T, K = any> {
+declare class ModuleCache<K, T> {
     map: Map<K, {
         lastSeen: [number, number];
         result: T;

package/esm/configs/index.d.ts

@@ -0,0 +1,24 @@
+declare const configs: {
+    'schema-recommended': any;
+    'schema-all': any;
+    'schema-relay': any;
+    'operations-recommended': any;
+    'operations-all': any;
+    'flat/schema-recommended': {
+        rules: any;
+    };
+    'flat/schema-all': {
+        rules: any;
+    };
+    'flat/schema-relay': {
+        rules: any;
+    };
+    'flat/operations-recommended': {
+        rules: any;
+    };
+    'flat/operations-all': {
+        rules: any;
+    };
+};
+
+export { configs };

package/esm/configs/index.js

@@ -9,7 +9,28 @@ const configs = {
   "schema-all": schemaAllConfig,
   "schema-relay": relayConfig,
   "operations-recommended": operationsRecommendedConfig,
-  "operations-all": operationsAllConfig
+  "operations-all": operationsAllConfig,
+  "flat/schema-recommended": {
+    rules: schemaRecommendedConfig.rules
+  },
+  "flat/schema-all": {
+    rules: {
+      ...schemaRecommendedConfig.rules,
+      ...schemaAllConfig.rules
+    }
+  },
+  "flat/schema-relay": {
+    rules: relayConfig.rules
+  },
+  "flat/operations-recommended": {
+    rules: operationsRecommendedConfig.rules
+  },
+  "flat/operations-all": {
+    rules: {
+      ...operationsRecommendedConfig.rules,
+      ...operationsAllConfig.rules
+    }
+  }
 };
 export {
   configs

package/esm/configs/operations-all.js

@@ -13,7 +13,7 @@ var require_operations_all = __commonJS({
             selections: ["OperationDefinition", "FragmentDefinition"],
             variables: !0,
             arguments: ["Field", "Directive"],
-            groups: ["id", "*", "createdAt", "updatedAt"]
+            groups: ["...", "id", "*", "{"]
           }
         ],
         "@graphql-eslint/lone-executable-definition": "error",

package/esm/documents.js

@@ -1,5 +1,5 @@
 import "./chunk-UIAXBAMD.js";
-import { resolve } from "node:path";
+import path from "node:path";
 import debugFactory from "debug";
 import fg from "fast-glob";
 import { ModuleCache } from "./cache.js";
@@ -8,12 +8,17 @@ const debug = debugFactory("graphql-eslint:operations"), operationsCache = new M
   return documents.map((source) => {
     const location = source.location;
     if ([".gql", ".graphql"].some((extension) => location.endsWith(extension)))
-      return source;
+      return {
+        ...source,
+        // When using glob pattern e.g. `**/*.gql` location contains always forward slashes even on
+        // Windows
+        location: path.resolve(location)
+      };
     filepathMap[location] ??= -1;
     const index = filepathMap[location] += 1;
     return {
       ...source,
-      location: resolve(location, `${index}_document.graphql`)
+      location: path.resolve(location, `${index}_document.graphql`)
     };
   });
 }, getDocuments = (project) => {

package/{cjs → esm}/estree-converter/index.d.ts

@@ -4,5 +4,5 @@ export { convertLocation, convertToken, extractComments, extractTokens, getBaseT
 import 'graphql';
 import 'eslint';
 import 'estree';
-import 'graphql/jsutils/Maybe';
-import 'graphql/jsutils/ObjMap';
+import 'graphql/jsutils/Maybe.js';
+import 'graphql/jsutils/ObjMap.js';

package/{cjs → esm}/estree-converter/utils.d.ts

@@ -1,11 +1,11 @@
-import * as graphql_jsutils_Maybe from 'graphql/jsutils/Maybe';
-import * as graphql_jsutils_ObjMap from 'graphql/jsutils/ObjMap';
+import * as graphql_jsutils_Maybe_js from 'graphql/jsutils/Maybe.js';
+import * as graphql_jsutils_ObjMap_js from 'graphql/jsutils/ObjMap.js';
 import * as graphql from 'graphql';
 import { GraphQLOutputType, GraphQLNamedType, TokenKind, Token, Location } from 'graphql';
 import { AST } from 'eslint';
 import { Comment, SourceLocation } from 'estree';
 
-declare const valueFromNode: (valueNode: graphql.ValueNode, variables?: graphql_jsutils_Maybe.Maybe<graphql_jsutils_ObjMap.ObjMap<unknown>>) => any;
+declare const valueFromNode: (valueNode: graphql.ValueNode, variables?: graphql_jsutils_Maybe_js.Maybe<graphql_jsutils_ObjMap_js.ObjMap<unknown>>) => any;
 declare function getBaseType(type: GraphQLOutputType): GraphQLNamedType;
 declare function convertToken<T extends TokenKind | 'Block' | 'Line'>(token: Token, type: T): Omit<AST.Token, 'type'> & {
     type: T;

package/esm/graphql-config.js

@@ -17,7 +17,7 @@ function loadGraphQLConfig({
   graphQLConfig: config,
   filePath
 }) {
-  if (graphQLConfig)
+  if (process.env.NODE_ENV !== "test" && graphQLConfig)
     return graphQLConfig;
   debug("parserOptions.graphQLConfig: %o", config);
   const onDiskConfig = !config && loadOnDiskGraphQLConfig(filePath);

package/esm/index.d.ts

@@ -0,0 +1,184 @@
+import { RuleOptions } from './rules/require-description/index.js';
+import { CaseStyle } from './utils.js';
+export { requireGraphQLSchemaFromContext, requireSiblingsOperations } from './utils.js';
+import * as graphql from 'graphql';
+import { GraphQLESLintRule } from './types.js';
+export { CategoryType, ConfigName, GraphQLESLintParseResult, GraphQLESLintRuleContext, GraphQLESLintRuleListener, OmitRecursively, ParserOptions, ParserServices, Pointer, ReportDescriptor, RuleDocsInfo, Schema, ValueOf } from './types.js';
+import * as eslint from 'eslint';
+import { Block } from './processor.js';
+export { configs } from './configs/index.js';
+import { parseForESLint } from './parser.js';
+export { parser } from './parser.js';
+export { rules } from './rules/index.js';
+export { GraphQLESTreeNode } from './estree-converter/types.js';
+import 'estree';
+import './siblings.js';
+import '@graphql-tools/utils';
+import 'graphql-config';
+import 'json-schema-to-ts';
+
+declare const processors: {
+    graphql: {
+        meta: {
+            name: string;
+            version: string | undefined;
+        };
+        supportsAutofix: true;
+        preprocess(code: string, filePath: string): (string | Block)[];
+        postprocess(messages: eslint.Linter.LintMessage[][], filePath: string): eslint.Linter.LintMessage[];
+    };
+};
+
+declare const _default: {
+    parser: {
+        parseForESLint: typeof parseForESLint;
+        meta: {
+            name: string;
+            version: string | undefined;
+        };
+    };
+    processor: {
+        meta: {
+            name: string;
+            version: string | undefined;
+        };
+        supportsAutofix: true;
+        preprocess(code: string, filePath: string): (string | Block)[];
+        postprocess(messages: eslint.Linter.LintMessage[][], filePath: string): eslint.Linter.LintMessage[];
+    };
+    rules: {
+        alphabetize: GraphQLESLintRule<{
+            values?: boolean | undefined;
+            definitions?: boolean | undefined;
+            selections?: ("OperationDefinition" | "FragmentDefinition")[] | undefined;
+            arguments?: ("Field" | "Directive" | "FieldDefinition" | "DirectiveDefinition")[] | undefined;
+            fields?: ("ObjectTypeDefinition" | "InterfaceTypeDefinition" | "InputObjectTypeDefinition")[] | undefined;
+            variables?: boolean | undefined;
+            groups?: string[] | undefined;
+        }[]>;
+        'description-style': GraphQLESLintRule<{
+            style: "block" | "inline";
+        }[]>;
+        'input-name': GraphQLESLintRule<{
+            checkInputType?: boolean | undefined;
+            caseSensitiveInputType?: boolean | undefined;
+            checkQueries?: boolean | undefined;
+            checkMutations?: boolean | undefined;
+        }[]>;
+        'lone-executable-definition': GraphQLESLintRule<{
+            ignore?: (graphql.OperationTypeNode | "fragment")[] | undefined;
+        }[]>;
+        'match-document-filename': GraphQLESLintRule<{
+            fragment?: (CaseStyle | "matchDocumentStyle") | {
+                style?: (CaseStyle | "matchDocumentStyle") | undefined;
+                suffix?: string | undefined;
+                prefix?: string | undefined;
+            } | undefined;
+            mutation?: (CaseStyle | "matchDocumentStyle") | {
+                style?: (CaseStyle | "matchDocumentStyle") | undefined;
+                suffix?: string | undefined;
+                prefix?: string | undefined;
+            } | undefined;
+            subscription?: (CaseStyle | "matchDocumentStyle") | {
+                style?: (CaseStyle | "matchDocumentStyle") | undefined;
+                suffix?: string | undefined;
+                prefix?: string | undefined;
+            } | undefined;
+            query?: (CaseStyle | "matchDocumentStyle") | {
+                style?: (CaseStyle | "matchDocumentStyle") | undefined;
+                suffix?: string | undefined;
+                prefix?: string | undefined;
+            } | undefined;
+            fileExtension?: ".gql" | ".graphql" | undefined;
+        }[]>;
+        'naming-convention': GraphQLESLintRule<{
+            [x: string]: unknown;
+            types?: ("camelCase" | "PascalCase" | "snake_case" | "UPPER_CASE") | {
+                style?: ("camelCase" | "PascalCase" | "snake_case" | "UPPER_CASE") | undefined;
+                suffix?: string | undefined;
+                prefix?: string | undefined;
+                forbiddenPrefixes?: string[] | undefined;
+                forbiddenSuffixes?: string[] | undefined;
+                requiredPrefixes?: string[] | undefined;
+                requiredSuffixes?: string[] | undefined;
+                ignorePattern?: string | undefined;
+            } | undefined;
+            allowLeadingUnderscore?: boolean | undefined;
+            allowTrailingUnderscore?: boolean | undefined;
+        }[]>;
+        'no-anonymous-operations': GraphQLESLintRule;
+        'no-deprecated': GraphQLESLintRule<[], true>;
+        'no-duplicate-fields': GraphQLESLintRule;
+        'no-hashtag-description': GraphQLESLintRule;
+        'no-one-place-fragments': GraphQLESLintRule;
+        'no-root-type': GraphQLESLintRule<{
+            disallow: ("mutation" | "subscription")[];
+        }[]>;
+        'no-scalar-result-type-on-mutation': GraphQLESLintRule;
+        'no-typename-prefix': GraphQLESLintRule;
+        'no-unreachable-types': GraphQLESLintRule;
+        'no-unused-fields': GraphQLESLintRule;
+        'relay-arguments': GraphQLESLintRule<{
+            includeBoth: boolean;
+        }[], true>;
+        'relay-connection-types': GraphQLESLintRule;
+        'relay-edge-types': GraphQLESLintRule<{
+            withEdgeSuffix?: boolean | undefined;
+            shouldImplementNode?: boolean | undefined;
+            listTypeCanWrapOnlyEdgeType?: boolean | undefined;
+        }[], true>;
+        'relay-page-info': GraphQLESLintRule;
+        'require-deprecation-date': GraphQLESLintRule<{
+            argumentName?: string | undefined;
+        }[]>;
+        'require-deprecation-reason': GraphQLESLintRule;
+        'require-description': GraphQLESLintRule<RuleOptions>;
+        'require-field-of-type-query-in-mutation-result': GraphQLESLintRule;
+        'require-import-fragment': GraphQLESLintRule;
+        'require-nullable-fields-with-oneof': GraphQLESLintRule;
+        'require-nullable-result-in-root': GraphQLESLintRule;
+        'require-selections': GraphQLESLintRule<{
+            fieldName: string | string[];
+        }[], true>;
+        'require-type-pattern-with-oneof': GraphQLESLintRule;
+        'selection-set-depth': GraphQLESLintRule<{
+            ignore?: string[] | undefined;
+            maxDepth: number;
+        }[]>;
+        'strict-id-in-types': GraphQLESLintRule<{
+            acceptedIdNames?: string[] | undefined;
+            acceptedIdTypes?: string[] | undefined;
+            exceptions?: {
+                types?: string[] | undefined;
+                suffixes?: string[] | undefined;
+            } | undefined;
+        }[]>;
+        'unique-enum-value-names': GraphQLESLintRule;
+        'unique-fragment-name': GraphQLESLintRule;
+        'unique-operation-name': GraphQLESLintRule;
+    };
+    configs: {
+        'schema-recommended': any;
+        'schema-all': any;
+        'schema-relay': any;
+        'operations-recommended': any;
+        'operations-all': any;
+        'flat/schema-recommended': {
+            rules: any;
+        };
+        'flat/schema-all': {
+            rules: any;
+        };
+        'flat/schema-relay': {
+            rules: any;
+        };
+        'flat/operations-recommended': {
+            rules: any;
+        };
+        'flat/operations-all': {
+            rules: any;
+        };
+    };
+};
+
+export { GraphQLESLintRule, _default as default, parseForESLint, processors };

package/esm/index.js

@@ -1,16 +1,22 @@
 import "./chunk-UIAXBAMD.js";
+import { configs } from "./configs/index.js";
+import { parseForESLint, parser } from "./parser.js";
 import { processor } from "./processor.js";
-import { parseForESLint } from "./parser.js";
 import { rules } from "./rules/index.js";
 export * from "./types.js";
 import { requireGraphQLSchemaFromContext, requireSiblingsOperations } from "./utils.js";
 const processors = { graphql: processor };
-import { configs } from "./configs/index.js";
-import { flatConfigs } from "./flat-configs.js";
+var src_default = {
+  parser,
+  processor,
+  rules,
+  configs
+};
 export {
   configs,
-  flatConfigs,
+  src_default as default,
   parseForESLint,
+  parser,
   processors,
   requireGraphQLSchemaFromContext,
   requireSiblingsOperations,

package/esm/meta.d.ts

@@ -0,0 +1,3 @@
+declare const version: string | undefined;
+
+export { version };

package/esm/meta.js

@@ -0,0 +1,5 @@
+import "./chunk-UIAXBAMD.js";
+const version = "4.0.0-alpha.10";
+export {
+  version
+};

package/{cjs → esm}/parser.d.ts

@@ -9,5 +9,12 @@ import './siblings.js';
 import '@graphql-tools/utils';
 
 declare function parseForESLint(code: string, options: ParserOptions): GraphQLESLintParseResult;
+declare const parser: {
+    parseForESLint: typeof parseForESLint;
+    meta: {
+        name: string;
+        version: string | undefined;
+    };
+};
 
-export { parseForESLint };
+export { parseForESLint, parser };