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

package/cjs/estree-converter/utils.js

@@ -0,0 +1,135 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  convertLocation: () => convertLocation,
+  convertToken: () => convertToken,
+  extractComments: () => extractComments,
+  extractTokens: () => extractTokens,
+  getBaseType: () => getBaseType,
+  valueFromNode: () => valueFromNode
+});
+module.exports = __toCommonJS(utils_exports);
+var import_graphql = require("graphql");
+var import_valueFromASTUntyped = require("graphql/utilities/valueFromASTUntyped.js");
+const valueFromNode = (...args) => {
+  return (0, import_valueFromASTUntyped.valueFromASTUntyped)(...args);
+};
+function getBaseType(type) {
+  if ((0, import_graphql.isNonNullType)(type) || (0, import_graphql.isListType)(type)) {
+    return getBaseType(type.ofType);
+  }
+  return type;
+}
+function convertToken(token, type) {
+  const { line, column, end, start, value } = token;
+  return {
+    type,
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TODO: remove `!` when drop support of graphql@15
+    value,
+    /*
+     * ESLint has 0-based column number
+     * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
+     */
+    loc: {
+      start: {
+        line,
+        column: column - 1
+      },
+      end: {
+        line,
+        column: column - 1 + (end - start)
+      }
+    },
+    range: [start, end]
+  };
+}
+function getLexer(source) {
+  const gqlLanguage = require("graphql/language");
+  if (gqlLanguage == null ? void 0 : gqlLanguage.createLexer) {
+    return gqlLanguage.createLexer(source, {});
+  }
+  const { Lexer: LexerCls } = require("graphql");
+  if (LexerCls && typeof LexerCls === "function") {
+    return new LexerCls(source);
+  }
+  throw new Error("Unsupported GraphQL version! Please make sure to use GraphQL v14 or newer!");
+}
+function extractTokens(filePath, code) {
+  const source = new import_graphql.Source(code, filePath);
+  const lexer = getLexer(source);
+  const tokens = [];
+  let token = lexer.advance();
+  while (token && token.kind !== import_graphql.TokenKind.EOF) {
+    const result = convertToken(token, token.kind);
+    tokens.push(result);
+    token = lexer.advance();
+  }
+  return tokens;
+}
+function extractComments(loc) {
+  if (!loc) {
+    return [];
+  }
+  const comments = [];
+  let token = loc.startToken;
+  while (token) {
+    if (token.kind === import_graphql.TokenKind.COMMENT) {
+      const comment = convertToken(
+        token,
+        // `eslint-disable` directive works only with `Block` type comment
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TODO: remove `!` when drop support of graphql@15
+        token.value.trimStart().startsWith("eslint") ? "Block" : "Line"
+      );
+      comments.push(comment);
+    }
+    token = token.next;
+  }
+  return comments;
+}
+function convertLocation(location) {
+  const { startToken, endToken, source, start, end } = location;
+  const loc = {
+    start: {
+      /*
+       * Kind.Document has startToken: { line: 0, column: 0 }, we set line as 1 and column as 0
+       */
+      line: startToken.line === 0 ? 1 : startToken.line,
+      column: startToken.column === 0 ? 0 : startToken.column - 1
+    },
+    end: {
+      line: endToken.line,
+      column: endToken.column - 1
+    },
+    source: source.body
+  };
+  if (loc.start.column === loc.end.column) {
+    loc.end.column += end - start;
+  }
+  return loc;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertLocation,
+  convertToken,
+  extractComments,
+  extractTokens,
+  getBaseType,
+  valueFromNode
+});

package/cjs/flat-configs.d.ts

@@ -0,0 +1,260 @@
+import { parseForESLint } from './parser.js';
+import './types-8d5f4ae0.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import './estree-converter/types.js';
+
+declare const flatConfigs: {
+    'operations-all': {
+        languageOptions: {
+            parser: {
+                parseForESLint: typeof parseForESLint;
+            };
+        };
+        rules: {
+            '@graphql-eslint/alphabetize': (string | {
+                selections: string[];
+                variables: string[];
+                arguments: string[];
+            })[];
+            '@graphql-eslint/lone-executable-definition': string;
+            '@graphql-eslint/match-document-filename': (string | {
+                query: string;
+                mutation: string;
+                subscription: string;
+                fragment: string;
+            })[];
+            '@graphql-eslint/no-one-place-fragments': string;
+            '@graphql-eslint/unique-fragment-name': string;
+            '@graphql-eslint/unique-operation-name': string;
+            '@graphql-eslint/executable-definitions': string;
+            '@graphql-eslint/fields-on-correct-type': string;
+            '@graphql-eslint/fragments-on-composite-type': string;
+            '@graphql-eslint/known-argument-names': string;
+            '@graphql-eslint/known-directives': string;
+            '@graphql-eslint/known-fragment-names': string;
+            '@graphql-eslint/known-type-names': string;
+            '@graphql-eslint/lone-anonymous-operation': string;
+            '@graphql-eslint/naming-convention': (string | {
+                VariableDefinition: string;
+                OperationDefinition: {
+                    style: string;
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                FragmentDefinition: {
+                    style: string;
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+            })[];
+            '@graphql-eslint/no-anonymous-operations': string;
+            '@graphql-eslint/no-deprecated': string;
+            '@graphql-eslint/no-duplicate-fields': string;
+            '@graphql-eslint/no-fragment-cycles': string;
+            '@graphql-eslint/no-undefined-variables': string;
+            '@graphql-eslint/no-unused-fragments': string;
+            '@graphql-eslint/no-unused-variables': string;
+            '@graphql-eslint/one-field-subscriptions': string;
+            '@graphql-eslint/overlapping-fields-can-be-merged': string;
+            '@graphql-eslint/possible-fragment-spread': string;
+            '@graphql-eslint/provided-required-arguments': string;
+            '@graphql-eslint/require-id-when-available': string;
+            '@graphql-eslint/scalar-leafs': string;
+            '@graphql-eslint/selection-set-depth': (string | {
+                maxDepth: number;
+            })[];
+            '@graphql-eslint/unique-argument-names': string;
+            '@graphql-eslint/unique-directive-names-per-location': string;
+            '@graphql-eslint/unique-input-field-names': string;
+            '@graphql-eslint/unique-variable-names': string;
+            '@graphql-eslint/value-literals-of-correct-type': string;
+            '@graphql-eslint/variables-are-input-types': string;
+            '@graphql-eslint/variables-in-allowed-position': string;
+        };
+    };
+    'operations-recommended': {
+        languageOptions: {
+            parser: {
+                parseForESLint: typeof parseForESLint;
+            };
+        };
+        rules: {
+            '@graphql-eslint/executable-definitions': string;
+            '@graphql-eslint/fields-on-correct-type': string;
+            '@graphql-eslint/fragments-on-composite-type': string;
+            '@graphql-eslint/known-argument-names': string;
+            '@graphql-eslint/known-directives': string;
+            '@graphql-eslint/known-fragment-names': string;
+            '@graphql-eslint/known-type-names': string;
+            '@graphql-eslint/lone-anonymous-operation': string;
+            '@graphql-eslint/naming-convention': (string | {
+                VariableDefinition: string;
+                OperationDefinition: {
+                    style: string;
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                FragmentDefinition: {
+                    style: string;
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+            })[];
+            '@graphql-eslint/no-anonymous-operations': string;
+            '@graphql-eslint/no-deprecated': string;
+            '@graphql-eslint/no-duplicate-fields': string;
+            '@graphql-eslint/no-fragment-cycles': string;
+            '@graphql-eslint/no-undefined-variables': string;
+            '@graphql-eslint/no-unused-fragments': string;
+            '@graphql-eslint/no-unused-variables': string;
+            '@graphql-eslint/one-field-subscriptions': string;
+            '@graphql-eslint/overlapping-fields-can-be-merged': string;
+            '@graphql-eslint/possible-fragment-spread': string;
+            '@graphql-eslint/provided-required-arguments': string;
+            '@graphql-eslint/require-id-when-available': string;
+            '@graphql-eslint/scalar-leafs': string;
+            '@graphql-eslint/selection-set-depth': (string | {
+                maxDepth: number;
+            })[];
+            '@graphql-eslint/unique-argument-names': string;
+            '@graphql-eslint/unique-directive-names-per-location': string;
+            '@graphql-eslint/unique-input-field-names': string;
+            '@graphql-eslint/unique-variable-names': string;
+            '@graphql-eslint/value-literals-of-correct-type': string;
+            '@graphql-eslint/variables-are-input-types': string;
+            '@graphql-eslint/variables-in-allowed-position': string;
+        };
+    };
+    relay: {
+        languageOptions: {
+            parser: {
+                parseForESLint: typeof parseForESLint;
+            };
+        };
+        rules: {
+            '@graphql-eslint/relay-arguments': string;
+            '@graphql-eslint/relay-connection-types': string;
+            '@graphql-eslint/relay-edge-types': string;
+            '@graphql-eslint/relay-page-info': string;
+        };
+    };
+    'schema-all': {
+        languageOptions: {
+            parser: {
+                parseForESLint: typeof parseForESLint;
+            };
+        };
+        rules: {
+            '@graphql-eslint/alphabetize': (string | {
+                fields: string[];
+                values: string[];
+                arguments: string[];
+            })[];
+            '@graphql-eslint/input-name': string;
+            '@graphql-eslint/no-scalar-result-type-on-mutation': string;
+            '@graphql-eslint/require-deprecation-date': string;
+            '@graphql-eslint/require-field-of-type-query-in-mutation-result': string;
+            '@graphql-eslint/require-nullable-fields-with-oneof': string;
+            '@graphql-eslint/require-nullable-result-in-root': string;
+            '@graphql-eslint/require-type-pattern-with-oneof': string;
+            '@graphql-eslint/description-style': string;
+            '@graphql-eslint/known-argument-names': string;
+            '@graphql-eslint/known-directives': string;
+            '@graphql-eslint/known-type-names': string;
+            '@graphql-eslint/lone-schema-definition': string;
+            '@graphql-eslint/naming-convention': (string | {
+                types: string;
+                FieldDefinition: string;
+                InputValueDefinition: string;
+                Argument: string;
+                DirectiveDefinition: string;
+                EnumValueDefinition: string;
+                'FieldDefinition[parent.name.value=Query]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'FieldDefinition[parent.name.value=Mutation]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'FieldDefinition[parent.name.value=Subscription]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+            })[];
+            '@graphql-eslint/no-case-insensitive-enum-values-duplicates': string;
+            '@graphql-eslint/no-hashtag-description': string;
+            '@graphql-eslint/no-typename-prefix': string;
+            '@graphql-eslint/no-unreachable-types': string;
+            '@graphql-eslint/provided-required-arguments': string;
+            '@graphql-eslint/require-deprecation-reason': string;
+            '@graphql-eslint/require-description': (string | {
+                types: boolean;
+                DirectiveDefinition: boolean;
+            })[];
+            '@graphql-eslint/strict-id-in-types': string;
+            '@graphql-eslint/unique-directive-names': string;
+            '@graphql-eslint/unique-directive-names-per-location': string;
+            '@graphql-eslint/unique-field-definition-names': string;
+            '@graphql-eslint/unique-operation-types': string;
+            '@graphql-eslint/unique-type-names': string;
+        };
+    };
+    'schema-recommended': {
+        languageOptions: {
+            parser: {
+                parseForESLint: typeof parseForESLint;
+            };
+        };
+        rules: {
+            '@graphql-eslint/description-style': string;
+            '@graphql-eslint/known-argument-names': string;
+            '@graphql-eslint/known-directives': string;
+            '@graphql-eslint/known-type-names': string;
+            '@graphql-eslint/lone-schema-definition': string;
+            '@graphql-eslint/naming-convention': (string | {
+                types: string;
+                FieldDefinition: string;
+                InputValueDefinition: string;
+                Argument: string;
+                DirectiveDefinition: string;
+                EnumValueDefinition: string;
+                'FieldDefinition[parent.name.value=Query]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'FieldDefinition[parent.name.value=Mutation]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'FieldDefinition[parent.name.value=Subscription]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+            })[];
+            '@graphql-eslint/no-case-insensitive-enum-values-duplicates': string;
+            '@graphql-eslint/no-hashtag-description': string;
+            '@graphql-eslint/no-typename-prefix': string;
+            '@graphql-eslint/no-unreachable-types': string;
+            '@graphql-eslint/provided-required-arguments': string;
+            '@graphql-eslint/require-deprecation-reason': string;
+            '@graphql-eslint/require-description': (string | {
+                types: boolean;
+                DirectiveDefinition: boolean;
+            })[];
+            '@graphql-eslint/strict-id-in-types': string;
+            '@graphql-eslint/unique-directive-names': string;
+            '@graphql-eslint/unique-directive-names-per-location': string;
+            '@graphql-eslint/unique-field-definition-names': string;
+            '@graphql-eslint/unique-operation-types': string;
+            '@graphql-eslint/unique-type-names': string;
+        };
+    };
+};
+
+export { flatConfigs };

package/cjs/flat-configs.js

@@ -0,0 +1,60 @@
+"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 flat_configs_exports = {};
+__export(flat_configs_exports, {
+  flatConfigs: () => flatConfigs
+});
+module.exports = __toCommonJS(flat_configs_exports);
+var import_configs = require("./configs/index.js");
+var import_parser = require("./parser.js");
+const languageOptions = {
+  parser: { parseForESLint: import_parser.parseForESLint }
+};
+const flatConfigs = {
+  "operations-all": {
+    languageOptions,
+    rules: {
+      ...import_configs.configs["operations-recommended"].rules,
+      ...import_configs.configs["operations-all"].rules
+    }
+  },
+  "operations-recommended": {
+    languageOptions,
+    rules: import_configs.configs["operations-recommended"].rules
+  },
+  relay: {
+    languageOptions,
+    rules: import_configs.configs.relay.rules
+  },
+  "schema-all": {
+    languageOptions,
+    rules: {
+      ...import_configs.configs["schema-recommended"].rules,
+      ...import_configs.configs["schema-all"].rules
+    }
+  },
+  "schema-recommended": {
+    languageOptions,
+    rules: import_configs.configs["schema-recommended"].rules
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  flatConfigs
+});

package/cjs/graphql-config.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLConfig } from 'graphql-config';
+import { P as ParserOptions } from './types-8d5f4ae0.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'json-schema-to-ts';
+import './estree-converter/types.js';
+
+declare function loadOnDiskGraphQLConfig(filePath: string): GraphQLConfig;
+declare function loadGraphQLConfig(options: ParserOptions): GraphQLConfig;
+
+export { loadGraphQLConfig, loadOnDiskGraphQLConfig };

package/cjs/graphql-config.js

@@ -0,0 +1,86 @@
+"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 graphql_config_exports = {};
+__export(graphql_config_exports, {
+  loadGraphQLConfig: () => loadGraphQLConfig,
+  loadOnDiskGraphQLConfig: () => loadOnDiskGraphQLConfig
+});
+module.exports = __toCommonJS(graphql_config_exports);
+var import_path = require("path");
+var import_code_file_loader = require("@graphql-tools/code-file-loader");
+var import_debug = __toESM(require("debug"));
+var import_graphql_config = require("graphql-config");
+const debug = (0, import_debug.default)("graphql-eslint:graphql-config");
+let graphQLConfig;
+function loadOnDiskGraphQLConfig(filePath) {
+  return (0, import_graphql_config.loadConfigSync)({
+    // load config relative to the file being linted
+    rootDir: (0, import_path.dirname)(filePath),
+    throwOnEmpty: false,
+    throwOnMissing: false,
+    extensions: [codeFileLoaderExtension]
+  });
+}
+function loadGraphQLConfig(options) {
+  if (graphQLConfig) {
+    return graphQLConfig;
+  }
+  const onDiskConfig = !options.skipGraphQLConfig && loadOnDiskGraphQLConfig(options.filePath);
+  debug("options.skipGraphQLConfig: %o", options.skipGraphQLConfig);
+  if (onDiskConfig) {
+    debug("Graphql-config path %o", onDiskConfig.filepath);
+  }
+  const configOptions = options.projects ? { projects: options.projects } : {
+    schema: options.schema || "",
+    // if `schema` is `undefined` will throw error `Project 'default' not found`
+    documents: options.documents,
+    extensions: options.extensions,
+    include: options.include,
+    exclude: options.exclude
+  };
+  graphQLConfig = onDiskConfig || new import_graphql_config.GraphQLConfig(
+    {
+      config: configOptions,
+      filepath: "virtual-config"
+    },
+    [codeFileLoaderExtension]
+  );
+  return graphQLConfig;
+}
+const codeFileLoaderExtension = (api) => {
+  const { schema, documents } = api.loaders;
+  schema.register(new import_code_file_loader.CodeFileLoader());
+  documents.register(new import_code_file_loader.CodeFileLoader());
+  return { name: "graphql-eslint-loaders" };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadGraphQLConfig,
+  loadOnDiskGraphQLConfig
+});

package/cjs/index.d.ts

@@ -0,0 +1,22 @@
+import * as eslint from 'eslint';
+import { Block } from './processor.js';
+export { parseForESLint } from './parser.js';
+export { rules } from './rules/index.js';
+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';
+export { requireGraphQLSchemaFromContext, requireSiblingsOperations } from './utils.js';
+export { configs } from './configs/index.js';
+export { flatConfigs } from './flat-configs.js';
+import './rules/require-description.js';
+import 'graphql';
+import 'json-schema-to-ts/lib/types/type-utils/writable.js';
+import '@graphql-tools/utils';
+import 'estree';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import './estree-converter/types.js';
+
+declare const processors: {
+    graphql: eslint.Linter.Processor<string | Block>;
+};
+
+export { processors };

package/cjs/index.js

@@ -0,0 +1,49 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  configs: () => import_configs.configs,
+  flatConfigs: () => import_flat_configs.flatConfigs,
+  parseForESLint: () => import_parser.parseForESLint,
+  processors: () => processors,
+  requireGraphQLSchemaFromContext: () => import_utils.requireGraphQLSchemaFromContext,
+  requireSiblingsOperations: () => import_utils.requireSiblingsOperations,
+  rules: () => import_rules.rules
+});
+module.exports = __toCommonJS(src_exports);
+var import_processor = require("./processor.js");
+var import_parser = require("./parser.js");
+var import_rules = require("./rules/index.js");
+__reExport(src_exports, require("./types.js"), module.exports);
+var import_utils = require("./utils.js");
+var import_configs = require("./configs/index.js");
+var import_flat_configs = require("./flat-configs.js");
+const processors = { graphql: import_processor.processor };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configs,
+  flatConfigs,
+  parseForESLint,
+  processors,
+  requireGraphQLSchemaFromContext,
+  requireSiblingsOperations,
+  rules,
+  ...require("./types.js")
+});

package/cjs/parser.d.ts

@@ -0,0 +1,12 @@
+import { P as ParserOptions, G as GraphQLESLintParseResult } from './types-8d5f4ae0.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import './estree-converter/types.js';
+
+declare function parseForESLint(code: string, options: ParserOptions): GraphQLESLintParseResult;
+
+export { parseForESLint };