@graphql-eslint/eslint-plugin 4.0.0-alpha-20220821140530-e968cfc → 4.0.0-alpha-20230810155929-e89edf7

package/cjs/estree-converter/utils.js

@@ -0,0 +1,105 @@
+"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: !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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), 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"), import_valueFromASTUntyped = require("graphql/utilities/valueFromASTUntyped.js");
+const valueFromNode = (...args) => (0, import_valueFromASTUntyped.valueFromASTUntyped)(...args);
+function getBaseType(type) {
+  return (0, import_graphql.isNonNullType)(type) || (0, import_graphql.isListType)(type) ? getBaseType(type.ofType) : type;
+}
+function convertToken(token, type) {
+  const { line, column, end, start, value } = token;
+  return {
+    type,
+    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 extractTokens(filePath, code) {
+  const source = new import_graphql.Source(code, filePath), lexer = new import_graphql.Lexer(source), tokens = [];
+  let token = lexer.advance();
+  for (; 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;
+  for (; token; ) {
+    if (token.kind === import_graphql.TokenKind.COMMENT) {
+      const comment = convertToken(
+        token,
+        // `eslint-disable` directive works only with `Block` type comment
+        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, 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
+  };
+  return loc.start.column === loc.end.column && (loc.end.column += end - start), 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,307 @@
+import { parseForESLint } from './parser.js';
+import './types.js';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'json-schema-to-ts';
+import './siblings.js';
+import '@graphql-tools/utils';
+import './estree-converter/types.js';
+import 'graphql-config';
+
+declare const flatConfigs: {
+    'operations-all': {
+        languageOptions: {
+            parser: {
+                parseForESLint: typeof parseForESLint;
+            };
+        };
+        rules: {
+            '@graphql-eslint/alphabetize': (string | {
+                definitions: boolean;
+                selections: string[];
+                variables: boolean;
+                arguments: string[];
+                groups: 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/require-import-fragment': 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-selections': 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-fragment-name': string;
+            '@graphql-eslint/unique-input-field-names': string;
+            '@graphql-eslint/unique-operation-name': 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-selections': 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-fragment-name': string;
+            '@graphql-eslint/unique-input-field-names': string;
+            '@graphql-eslint/unique-operation-name': 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;
+        };
+    };
+    'schema-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 | {
+                definitions: boolean;
+                fields: string[];
+                values: boolean;
+                arguments: string[];
+                groups: string[];
+            })[];
+            '@graphql-eslint/input-name': string;
+            '@graphql-eslint/no-root-type': (string | {
+                disallow: 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[];
+                };
+                'EnumTypeDefinition,EnumTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'InterfaceTypeDefinition,InterfaceTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'UnionTypeDefinition,UnionTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'ObjectTypeDefinition,ObjectTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+            })[];
+            '@graphql-eslint/no-hashtag-description': string;
+            '@graphql-eslint/no-typename-prefix': string;
+            '@graphql-eslint/no-unreachable-types': string;
+            '@graphql-eslint/possible-type-extension': string;
+            '@graphql-eslint/provided-required-arguments': string;
+            '@graphql-eslint/require-deprecation-reason': string;
+            '@graphql-eslint/require-description': (string | {
+                types: boolean;
+                DirectiveDefinition: boolean;
+                rootField: 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-enum-value-names': 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[];
+                };
+                'EnumTypeDefinition,EnumTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'InterfaceTypeDefinition,InterfaceTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'UnionTypeDefinition,UnionTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'ObjectTypeDefinition,ObjectTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+            })[];
+            '@graphql-eslint/no-hashtag-description': string;
+            '@graphql-eslint/no-typename-prefix': string;
+            '@graphql-eslint/no-unreachable-types': string;
+            '@graphql-eslint/possible-type-extension': string;
+            '@graphql-eslint/provided-required-arguments': string;
+            '@graphql-eslint/require-deprecation-reason': string;
+            '@graphql-eslint/require-description': (string | {
+                types: boolean;
+                DirectiveDefinition: boolean;
+                rootField: 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-enum-value-names': 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,55 @@
+"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: !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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var flat_configs_exports = {};
+__export(flat_configs_exports, {
+  flatConfigs: () => flatConfigs
+});
+module.exports = __toCommonJS(flat_configs_exports);
+var import_configs = require("./configs/index.js"), import_parser = require("./parser.js");
+const languageOptions = {
+  parser: { parseForESLint: import_parser.parseForESLint }
+}, 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
+  },
+  "schema-relay": {
+    languageOptions,
+    rules: import_configs.configs["schema-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,14 @@
+import { GraphQLConfig } from 'graphql-config';
+import { ParserOptions } from './types.js';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'json-schema-to-ts';
+import './siblings.js';
+import '@graphql-tools/utils';
+import './estree-converter/types.js';
+
+declare function loadOnDiskGraphQLConfig(filePath: string): GraphQLConfig;
+declare function loadGraphQLConfig({ graphQLConfig: config, filePath, }: ParserOptions): GraphQLConfig;
+
+export { loadGraphQLConfig, loadOnDiskGraphQLConfig };

package/cjs/graphql-config.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, __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 graphql_config_exports = {};
+__export(graphql_config_exports, {
+  loadGraphQLConfig: () => loadGraphQLConfig,
+  loadOnDiskGraphQLConfig: () => loadOnDiskGraphQLConfig
+});
+module.exports = __toCommonJS(graphql_config_exports);
+var import_node_path = __toESM(require("node:path")), import_code_file_loader = require("@graphql-tools/code-file-loader"), import_debug = __toESM(require("debug")), 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: import_node_path.default.dirname(filePath),
+    throwOnMissing: !1,
+    extensions: [codeFileLoaderExtension]
+  });
+}
+function loadGraphQLConfig({
+  graphQLConfig: config,
+  filePath
+}) {
+  if (graphQLConfig)
+    return graphQLConfig;
+  debug("parserOptions.graphQLConfig: %o", config);
+  const onDiskConfig = !config && loadOnDiskGraphQLConfig(filePath);
+  onDiskConfig && debug("GraphQL-Config path %o", onDiskConfig.filepath);
+  const configOptions = config && ("projects" in config || "schemaPath" in config) ? config : {
+    // if `schema` is `undefined` will throw error `Project 'default' not found`
+    schema: config?.schema ?? "",
+    ...config
+  };
+  return graphQLConfig = onDiskConfig || new import_graphql_config.GraphQLConfig({ config: configOptions, filepath: "" }, [codeFileLoaderExtension]), graphQLConfig;
+}
+const codeFileLoaderExtension = (api) => {
+  const { schema, documents } = api.loaders;
+  return schema.register(new import_code_file_loader.CodeFileLoader()), documents.register(new import_code_file_loader.CodeFileLoader()), { name: "code-file-loaders" };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadGraphQLConfig,
+  loadOnDiskGraphQLConfig
+});

package/cjs/index.d.ts

@@ -0,0 +1,28 @@
+import * as eslint from 'eslint';
+import { Block } from './processor.js';
+export { parseForESLint } from './parser.js';
+export { rules } from './rules/index.js';
+export { CategoryType, ConfigName, GraphQLESLintParseResult, GraphQLESLintRule, GraphQLESLintRuleContext, GraphQLESLintRuleListener, OmitRecursively, ParserOptions, ParserServices, Pointer, ReportDescriptor, RuleDocsInfo, Schema, ValueOf } from './types.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 'graphql/language/ast.js';
+import 'json-schema-to-ts/lib/types/type-utils/writable.js';
+import 'estree';
+import 'json-schema-to-ts';
+import './siblings.js';
+import '@graphql-tools/utils';
+import './estree-converter/types.js';
+import 'graphql-config';
+
+declare const processors: {
+    graphql: {
+        supportsAutofix: true;
+        preprocess(code: string, filePath: string): (string | Block)[];
+        postprocess(messages: eslint.Linter.LintMessage[][], filePath: string): eslint.Linter.LintMessage[];
+    };
+};
+
+export { processors };

package/cjs/index.js

@@ -0,0 +1,41 @@
+"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: !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;
+}, __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), 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"), import_parser = require("./parser.js"), import_rules = require("./rules/index.js");
+__reExport(src_exports, require("./types.js"), module.exports);
+var import_utils = require("./utils.js"), import_configs = require("./configs/index.js"), 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,13 @@
+import { ParserOptions, GraphQLESLintParseResult } from './types.js';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'json-schema-to-ts';
+import './siblings.js';
+import '@graphql-tools/utils';
+import './estree-converter/types.js';
+import 'graphql-config';
+
+declare function parseForESLint(code: string, options: ParserOptions): GraphQLESLintParseResult;
+
+export { parseForESLint };